DBTool for Oracle - Part 1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Reflection;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using Harlinn.Common.IO;
using Harlinn.Common;
using Harlinn.DBTool.DataSources;

namespace Harlinn.DBTool.Projects
{
    [Serializable]
    public class Project : ProjectElement
    {
        private static readonly log4net.ILog sLog = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
        private static void LogException(Exception exc, System.Reflection.MethodBase method)
        {
            Logger.LogException(sLog, exc, method);
        }


        ProjectEnvironment environment;
        ProjectDataSources dataSources;
        ProjectRoles roles;

        ProjectTables projectTables;
        ProjectViews projectViews;
        ProjectQueries projectQueries;
        ProjectTypes projectTypes;


        private string namespace_ = "Harlinn.Oracle.DBTool";
        private string databaseNamespace;
        private string clientNamespace;
        private string entityNamespace;
        private string dataNamespace;
        private string commonNamespace;
        private string serviceImplementationNamespace;

        private string outputDirectory;
        private string templateDirectory;

        private string roleName;
        private string schemaForTimeseriesData;


        [NonSerialized]
        private string fileName;
        //[NonSerialized]
        //StringTemplateGroup stringTemplateGroup;


        public Project()
        {
            fileName = string.Empty;
            Name = "DBToolProject";
            roleName = "Administrators";
            schemaForTimeseriesData = "DBToolData";
        }


        public override void WriteElement(BinaryWriter writer)
        {
            base.WriteElement(writer);

            writer.WriteNullable(Namespace);
            writer.WriteNullable(DatabaseNamespace);
            writer.WriteNullable(ClientNamespace);
            writer.WriteNullable(EntityNamespace);
            writer.WriteNullable(DataNamespace);
            writer.WriteNullable(CommonNamespace);
            writer.WriteNullable(ServiceImplementationNamespace);

            writer.WriteNullable(OutputDirectory);
            writer.WriteNullable(TemplateDirectory);
            writer.WriteNullable(RoleName);
            writer.WriteNullable(SchemaForTimeseriesData);

            ProjectTables projectTables = GetProjectTables();
            projectTables.WriteElement(writer);

            ProjectViews projectViews = GetProjectViews();
            projectViews.WriteElement(writer);

            ProjectQueries projectQueries = GetProjectQueries();
            projectQueries.WriteElement(writer);

            ProjectTypes projectTypes = GetProjectTypes();
            projectTypes.WriteElement(writer);
            


        }

        public override void ReadElement(BinaryReader reader)
        {
            base.ReadElement(reader);
            Namespace = reader.ReadNullableString();
            DatabaseNamespace = reader.ReadNullableString();
            ClientNamespace = reader.ReadNullableString();
            EntityNamespace = reader.ReadNullableString();
            DataNamespace = reader.ReadNullableString();
            CommonNamespace = reader.ReadNullableString();
            ServiceImplementationNamespace = reader.ReadNullableString();
            OutputDirectory = reader.ReadNullableString();
            TemplateDirectory = reader.ReadNullableString();
            RoleName = reader.ReadNullableString();
            SchemaForTimeseriesData = reader.ReadNullableString();

            Children.Clear();

            ProjectTables projectTables = new ProjectTables(this);
            Children.Add(projectTables);
            projectTables.ReadElement(reader);

            ProjectViews projectViews = new ProjectViews(this);
            Children.Add(projectViews);
            projectViews.ReadElement(reader);

            ProjectQueries projectQueries = new ProjectQueries(this);
            Children.Add(projectQueries);
            projectQueries.ReadElement(reader);

            ProjectTypes projectTypes = new ProjectTypes(this);
            Children.Add(projectTypes);
            projectTypes.ReadElement(reader);


        }


        public override Project GetProject()
        {
            return this;
        }




        public void SaveToStream(Stream stream)
        {
            try
            {
                //BinaryFormatter formatter = new BinaryFormatter();
                //formatter.Serialize(stream, this);

                BinaryWriter writer = new BinaryWriter(stream);
                WriteElement(writer);

                stream.Flush();
            }
            catch (Exception exc)
            {
                LogException(exc, MethodBase.GetCurrentMethod());
                throw;
            }
        }


        public void SaveToFile(string fileName)
        {
            try
            {
                FileStream fileStream = new FileStream(fileName, FileMode.Create);
                using (fileStream)
                {
                    SaveToStream(fileStream);
                    FileName = fileName;
                }
            }
            catch (Exception exc)
            {
                LogException(exc, MethodBase.GetCurrentMethod());
                throw;
            }
        }


        public void LoadFromStream(Stream stream)
        {
            try
            {
                //BinaryFormatter formatter = new BinaryFormatter();
                //Project result = (Project)formatter.Deserialize(stream);

                BinaryReader reader = new BinaryReader(stream);
                ReadElement(reader);
            }
            catch (Exception exc)
            {
                LogException(exc, MethodBase.GetCurrentMethod());
                throw;
            }
        }

        public void LoadFromFile(string fileName)
        {
            try
            {
                FileStream fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read);
                using(fileStream)
                {
                    LoadFromStream(fileStream);
                    FileName = fileName;
                }
            }
            catch (Exception exc)
            {
                LogException(exc, MethodBase.GetCurrentMethod());
                throw;
            }
        }



        public override ProjectElementType ElementType
        {
            get 
            {
                return ProjectElementType.Project;
            }
        }

        /*public StringTemplateGroup GetTemplateGroup()
        {
            if (stringTemplateGroup == null)
            {
                stringTemplateGroup = new StringTemplateGroup("Project",TemplateDirectory);
            }
            return stringTemplateGroup;
        }*/



        public string Namespace
        {
            get
            {
                return namespace_;
            }
            set
            {
                if (namespace_ == value)
                    return;
                namespace_ = value;
                OnPropertyChanged("Namespace");
            }
        }

        
        public string FileName
        {
            get
            {
                return fileName;
            }
            set
            {
                if (fileName == value)
                    return;
                fileName = value;
                OnPropertyChanged("FileName");
            }
        }

        
        public string DatabaseNamespace
        {
            get
            {
                if (string.IsNullOrWhiteSpace(databaseNamespace))
                {
                    return Namespace + ".DB";
                }
                return databaseNamespace;
            }
            set
            {
                if (DatabaseNamespace == value)
                    return;
                databaseNamespace = value;
                OnPropertyChanged("DatabaseNamespace");
            }
        }

        
        public string EntityNamespace
        {
            get
            {
                if (string.IsNullOrWhiteSpace(entityNamespace))
                {
                    return Namespace + ".Entities";
                }
                return entityNamespace;
            }
            set
            {
                if (EntityNamespace == value)
                    return;
                entityNamespace = value;
                OnPropertyChanged("EntityNamespace");
            }
        }

        
        public string DataNamespace
        {
            get
            {
                if (string.IsNullOrWhiteSpace(dataNamespace))
                {
                    return Namespace + ".Types";
                }
                return dataNamespace;
            }
            set
            {
                if (DataNamespace == value)
                    return;
                dataNamespace = value;
                OnPropertyChanged("DataNamespace");
            }
        }

        public string CommonNamespace
        {
            get
            {
                if (string.IsNullOrWhiteSpace(commonNamespace))
                {
                    return Namespace + ".Common";
                }
                return commonNamespace;
            }
            set
            {
                if (commonNamespace == value)
                    return;
                commonNamespace = value;
                OnPropertyChanged("CommonNamespace");
            }
        }


        public string ServiceImplementationNamespace
        {
            get
            {
                if (string.IsNullOrWhiteSpace(serviceImplementationNamespace))
                {
                    return Namespace + ".Implementation";
                }
                return serviceImplementationNamespace;
            }
            set
            {
                if (serviceImplementationNamespace == value)
                    return;
                serviceImplementationNamespace = value;
                OnPropertyChanged("ServiceImplementationNamespace");
            }
        }


        public string ClientNamespace
        {
            get
            {
                if (string.IsNullOrWhiteSpace(clientNamespace))
                {
                    return Namespace + ".Client";
                }
                return clientNamespace;
            }
            set
            {
                if (clientNamespace == value)
                    return;
                clientNamespace = value;
                OnPropertyChanged("ClientNamespace");
            }
        }




        public string OutputDirectory
        {
            get
            {
                if (string.IsNullOrWhiteSpace(outputDirectory))
                {
                    outputDirectory = LocateOutputDirectory();
                }
                return outputDirectory;
            }
            set
            {
                if (outputDirectory == value)
                    return;
                outputDirectory = value;
                OnPropertyChanged("OutputDirectory");
            }
        }

        public string NamespaceToDirectory(string namespace_)
        {
            string result = string.Empty;

            if (namespace_.StartsWith(Namespace))
            {
                namespace_ = namespace_.Substring(Namespace.Length);
                namespace_.TrimStart('.');
            }
            string relativeDirectory = namespace_.Replace('.', '\\');
            result = OutputDirectory.TrimEnd('\\', '/') + "\\" + relativeDirectory;

            return result;
        }


        



        public string TemplateDirectory
        {
            get
            {
                if (string.IsNullOrWhiteSpace(templateDirectory))
                {
                    templateDirectory = LocateTemplateDirectory();
                }
                return templateDirectory;
            }
            set
            {
                if (templateDirectory == value)
                    return;
                templateDirectory = value;
                OnPropertyChanged("TemplateDirectory");
            }
        }


        public string RoleName
        {
            get
            {
                return roleName;
            }
            set
            {
                if (roleName == value)
                    return;
                roleName = value;
                OnPropertyChanged("RoleName");
            }
        }
        public string SchemaForTimeseriesData
        {
            get
            {
                return schemaForTimeseriesData;
            }
            set
            {
                if (schemaForTimeseriesData == value)
                    return;
                schemaForTimeseriesData = value;
                OnPropertyChanged("SchemaForTimeseriesData");
            }
        }



        private string LocateDirectory(DirectoryInfo startDirectoryInfo, string directoryName)
        {
            string s = Path.Combine( startDirectoryInfo.FullName, directoryName);
            if (Directory.Exists(s))
            {
                return s;
            }
            if (startDirectoryInfo.Parent != null)
            {
                return LocateDirectory(startDirectoryInfo.Parent, directoryName);
            }
            return null;
        }


        private string LocateTemplateDirectory()
        {
            string theStartDirectory = System.IO.Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
            DirectoryInfo directoryInfo = new DirectoryInfo(theStartDirectory);
            return LocateDirectory(directoryInfo, "Templates");

        }


        private string LocateOutputDirectory()
        {
            string theStartDirectory = System.IO.Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
            DirectoryInfo directoryInfo = new DirectoryInfo(theStartDirectory);
            return LocateDirectory(directoryInfo, "Generated");

        }



        public string GetPropertyType(IDBColumn field)
        {
            string result = field.GetPropertyTypeName();

            return result;
        }


        public string GetReaderFunction(IDBColumn field)
        {
            string result = field.GetReaderFunctionName();

            return result;
        }


        public override void Refresh()
        {
            base.Refresh();
            Children.Clear();


            environment = new ProjectEnvironment(this);
            dataSources = new ProjectDataSources(this);
            roles = new ProjectRoles(this);



            projectTables = new ProjectTables(this);
            Children.Add(projectTables);

            projectViews = new ProjectViews(this);
            Children.Add(projectViews);

            projectQueries = new ProjectQueries(this);
            Children.Add(projectQueries);

            projectTypes = new ProjectTypes(this);
            Children.Add(projectTypes);

        }


        public ProjectEnvironment GetProjectEnvironment()
        {
            if (environment == null)
            {
                Refresh();
            }
            return environment;
        }


        public ProjectDataSources GetProjectDataSources()
        {
            if (dataSources == null)
            {
                Refresh();
            }
            return dataSources;
        }


        public ProjectRoles GetProjectRoles()
        {
            if (roles == null)
            {
                Refresh();
            }
            return roles;
        }




        public ProjectTables GetProjectTables()
        {
            if (projectTables == null)
            {
                Refresh();
            }
            ProjectTables result = projectTables;
            return result;
        }

        public List<ProjectTable> GetProjectTableList()
        {
            List<ProjectTable> result = new List<ProjectTable>();
            ProjectTables projectTables = GetProjectTables();
            foreach (ProjectTable projectTable in projectTables.Children)
            {
                result.Add(projectTable);
            }
            return result;
        }

        public List<ProjectTable> GetProjectTagTypeList()
        {
            List<ProjectTable> result = new List<ProjectTable>();
            ProjectTables projectTables = GetProjectTables();
            foreach (ProjectTable projectTable in projectTables.Children)
            {
                if (projectTable.IsTagValue)
                {
                    result.Add(projectTable);
                }
            }
            return result;
        }
        


        public ProjectViews GetProjectViews()
        {
            if (projectViews == null)
            {
                Refresh();
            }
            ProjectViews result = projectViews;
            return result;
        }

        public List<ProjectView> GetProjectViewList()
        {
            List<ProjectView> result = new List<ProjectView>();
            ProjectViews projectViews = GetProjectViews();
            foreach (ProjectView projectView in projectViews.Children)
            {
                result.Add(projectView);
            }
            return result;
        }


        public ProjectQueries GetProjectQueries()
        {
            if (projectQueries == null)
            {
                Refresh();
            }
            ProjectQueries result = projectQueries;
            return result;
        }

        public List<ProjectQuery> GetProjectQueryList()
        {
            List<ProjectQuery> result = new List<ProjectQuery>();
            ProjectQueries projectQueries = GetProjectQueries();
            foreach (ProjectQuery projectQuery in projectQueries.Children)
            {
                result.Add(projectQuery);
            }
            return result;
        }

        public List<ProjectTabular> GetProjectTabularList()
        {
            List<ProjectTabular> result = new List<ProjectTabular>();

            ProjectTables projectTables = GetProjectTables();
            foreach (ProjectTable projectTable in projectTables.Children)
            {
                result.Add(projectTable);
            }

            ProjectViews projectViews = GetProjectViews();
            foreach (ProjectView projectView in projectViews.Children)
            {
                result.Add(projectView);
            }

            ProjectQueries projectQueries = GetProjectQueries();
            foreach (ProjectQuery projectQuery in projectQueries.Children)
            {
                result.Add(projectQuery);
            }

            return result;
        }



        public ProjectTypes GetProjectTypes()
        {
            if (projectTypes == null)
            {
                Refresh();
            }
            ProjectTypes result = projectTypes;
            return result;
        }



        public bool AddTable(IDBTable table)
        {
            bool result = GetProjectTables().Add(table);
            return result;
        }

        public bool AddView(IDBView view)
        {
            bool result = GetProjectViews().Add(view);
            return result;
        }


        public override void GenerateCode()
        {
            base.GenerateCode();
            /*
            ElementStateGenerator elementStateGenerator = new ElementStateGenerator();

            using (elementStateGenerator)
            {
                elementStateGenerator.Generate();
                elementStateGenerator.SaveToFile();
            }

            LoggerGenerator loggerGenerator = new LoggerGenerator();
            using (loggerGenerator)
            {
                loggerGenerator.Generate();
                loggerGenerator.SaveToFile();
            }

            OperationContextGenerator operationContextGenerator = new OperationContextGenerator();
            using (operationContextGenerator)
            {
                operationContextGenerator.Generate();
                operationContextGenerator.SaveToFile();
            }


            IntervalGenerator intervalGenerator = new IntervalGenerator();
            using (intervalGenerator)
            {
                intervalGenerator.Generate();
                intervalGenerator.SaveToFile();
            }


            ReaderGenerator readerGenerator = new ReaderGenerator();
            using (readerGenerator)
            {
                readerGenerator.Generate();
                readerGenerator.SaveToFile();
            }


            AccessorGenerator accessorGenerator = new AccessorGenerator();
            using (accessorGenerator)
            {
                accessorGenerator.Generate();
                accessorGenerator.SaveToFile();
            }


            TagAccessorGenerator tagAccessorGenerator = new TagAccessorGenerator();
            using (tagAccessorGenerator)
            {
                tagAccessorGenerator.Generate();
                tagAccessorGenerator.SaveToFile();
            }


            ElementTypeGenerator elementTypeGenerator = new ElementTypeGenerator(this);
            using (elementTypeGenerator)
            {
                elementTypeGenerator.Generate();
                elementTypeGenerator.SaveToFile();
            }

            EventsGenerator eventsGenerator = new EventsGenerator(this);
            using (eventsGenerator)
            {
                eventsGenerator.Generate();
                eventsGenerator.SaveToFile();
            }

            DataProviderInterfaceGenerator dataProviderInterfaceGenerator = new DataProviderInterfaceGenerator(this);
            using (dataProviderInterfaceGenerator)
            {
                dataProviderInterfaceGenerator.Generate();
                dataProviderInterfaceGenerator.SaveToFile();
            }

            DataObserverInterfaceGenerator dataObserverInterfaceGenerator = new DataObserverInterfaceGenerator(this);
            using (dataObserverInterfaceGenerator)
            {
                dataObserverInterfaceGenerator.Generate();
                dataObserverInterfaceGenerator.SaveToFile();
            }

            DataContextProviderInterfaceGenerator dataContextProviderInterfaceGenerator = new DataContextProviderInterfaceGenerator(this);
            using (dataContextProviderInterfaceGenerator)
            {
                dataContextProviderInterfaceGenerator.Generate();
                dataContextProviderInterfaceGenerator.SaveToFile();
            }

            EntityContextBaseGenerator entityContextBaseGenerator = new EntityContextBaseGenerator(this);
            using (entityContextBaseGenerator)
            {
                entityContextBaseGenerator.Generate();
                entityContextBaseGenerator.SaveToFile();
            }


            ServiceImplementationGenerator serviceImplementationGenerator = new ServiceImplementationGenerator(this);
            using (serviceImplementationGenerator)
            {
                serviceImplementationGenerator.Generate();
                serviceImplementationGenerator.SaveToFile();
            }

            WCFServiceGenerator wcfServiceGenerator = new WCFServiceGenerator(this);
            using (wcfServiceGenerator)
            {
                wcfServiceGenerator.Generate();
                wcfServiceGenerator.SaveToFile();
            }

            EnumOperationsGenerator enumOperationsGenerator = new EnumOperationsGenerator(this);
            using (enumOperationsGenerator)
            {
                enumOperationsGenerator.Generate();
                enumOperationsGenerator.SaveToFile();
            }

            DataObserverGenerator dataObserverGenerator = new DataObserverGenerator(this);
            using (dataObserverGenerator)
            {
                dataObserverGenerator.Generate();
                dataObserverGenerator.SaveToFile();
            }

            OperationsHandlerBaseGenerator operationsHandlerBaseGenerator = new OperationsHandlerBaseGenerator(this);
            using (operationsHandlerBaseGenerator)
            {
                operationsHandlerBaseGenerator.Generate();
                operationsHandlerBaseGenerator.SaveToFile();
            }


            TypesConstantsGenerator typesConstantsGenerator = new TypesConstantsGenerator();
            using (typesConstantsGenerator)
            {
                typesConstantsGenerator.Generate();
                typesConstantsGenerator.SaveToFile();
            }

            CompareHelperGenerator compareHelperGenerator = new CompareHelperGenerator();
            using (compareHelperGenerator)
            {
                compareHelperGenerator.Generate();
                compareHelperGenerator.SaveToFile();
            }


            ElementBaseGenerator elementBaseGenerator = new ElementBaseGenerator();
            using (elementBaseGenerator)
            {
                elementBaseGenerator.Generate();
                elementBaseGenerator.SaveToFile();
            }

            SettingsGenerator settingsGenerator = new SettingsGenerator();
            using (settingsGenerator)
            {
                settingsGenerator.Generate();
                settingsGenerator.SaveToFile();
            }


            Generators.Templates.OperationGenerator operationGenerator = new Generators.Templates.OperationGenerator();
            using (operationGenerator)
            {
                operationGenerator.Generate();
                operationGenerator.SaveToFile();
            }

            MsMqAppenderGenerator msMqAppenderGenerator = new MsMqAppenderGenerator();
            using (msMqAppenderGenerator)
            {
                msMqAppenderGenerator.Generate();
                msMqAppenderGenerator.SaveToFile();
            }


            BaseQueueMonitorGenerator baseQueueMonitorGenerator = new BaseQueueMonitorGenerator();
            using (baseQueueMonitorGenerator)
            {
                baseQueueMonitorGenerator.Generate();
                baseQueueMonitorGenerator.SaveToFile();
            }

            EventLogQueueMonitorGenerator eventLogQueueMonitorGenerator = new EventLogQueueMonitorGenerator();
            using (eventLogQueueMonitorGenerator)
            {
                eventLogQueueMonitorGenerator.Generate();
                eventLogQueueMonitorGenerator.SaveToFile();
            }

            TagGenerator.Generate(this);


            EntityBaseGenerator entityBaseGenerator = new EntityBaseGenerator();
            using (entityBaseGenerator)
            {
                entityBaseGenerator.Generate();
                entityBaseGenerator.SaveToFile();
            }


            EntitySourceBaseGenerator entitySourceBaseGenerator = new EntitySourceBaseGenerator();
            using (entitySourceBaseGenerator)
            {
                entitySourceBaseGenerator.Generate();
                entitySourceBaseGenerator.SaveToFile();
            }


            EntityEventsGenerator entityEventsGenerator = new EntityEventsGenerator(this);
            using (entityEventsGenerator)
            {
                entityEventsGenerator.Generate();
                entityEventsGenerator.SaveToFile();
            }

            EntityContextGenerator entityContextGenerator = new EntityContextGenerator(this);
            using (entityContextGenerator)
            {
                entityContextGenerator.Generate();
                entityContextGenerator.SaveToFile();
            }

            EntityGenerator.Generate(this);
            TagEntityGenerator.Generate(this);


            EntitySourceGenerator entitySourceGenerator = new EntitySourceGenerator(this);
            using (entitySourceGenerator)
            {
                entitySourceGenerator.Generate();
                entitySourceGenerator.SaveToFile();
            }

            TagEntityEventArgsGenerator tagEntityEventArgsGenerator = new TagEntityEventArgsGenerator();
            using (tagEntityEventArgsGenerator)
            {
                tagEntityEventArgsGenerator.Generate();
                tagEntityEventArgsGenerator.SaveToFile();
            }


            DataObjectBaseGenerator dataObjectBaseGenerator = new DataObjectBaseGenerator();
            using (dataObjectBaseGenerator)
            {
                dataObjectBaseGenerator.Generate();
                dataObjectBaseGenerator.SaveToFile();
            }


            ServerComponentGenerator serverComponentGenerator = new ServerComponentGenerator();
            using (serverComponentGenerator)
            {
                serverComponentGenerator.Generate();
                serverComponentGenerator.SaveToFile();
            }

            ServerOperationsHandlerGenerator serverOperationsHandlerGenerator = new ServerOperationsHandlerGenerator();
            using (serverOperationsHandlerGenerator)
            {
                serverOperationsHandlerGenerator.Generate();
                serverOperationsHandlerGenerator.SaveToFile();
            }





            ClientGenerator clientGenerator = new ClientGenerator(this);
            using (clientGenerator)
            {
                clientGenerator.Generate();
                clientGenerator.SaveToFile();
            }
            */

        }
    }


}