Exemple #1
0
        private List <nHydrateGeneratorProject> BuildModelList(nHydrateModel model, Microsoft.VisualStudio.Modeling.Diagrams.Diagram diagram, Microsoft.VisualStudio.Modeling.Shell.ModelingDocData docData)
        {
            var genList = new List <nHydrateGeneratorProject>();

            var genProject = new nHydrateGeneratorProject();

            genList.Add(genProject);
            var root = CreatePOCOModel(model, diagram);

            root.SetKey(model.Id.ToString());
            root.GeneratorProject            = genProject;
            genProject.RootController.Object = root;
            var fi = new System.IO.FileInfo(docData.FileName);

            genProject.FileName = docData.FileName + ".generating";
            var document = new System.Xml.XmlDocument();

            document.LoadXml("<modelRoot guid=\"" + model.Id + "\" type=\"nHydrate.Generator.nHydrateGeneratorProject\" assembly=\"nHydrate.Generator.dll\"><ModelRoot></ModelRoot></modelRoot>");
            ((nHydrate.Generator.Common.GeneratorFramework.IXMLable)root).XmlAppend(document.DocumentElement.ChildNodes[0]);
            System.IO.File.WriteAllText(genProject.FileName, document.ToIndentedString());

            ProcessRenamed(genProject.FileName + ".sql.lastgen", root);

            root.RemovedTables.AddRange(model.RemovedTables);

            //NOTE: This caused diff scripts to be generated EVERY time so removed for now
            //Remove associative tables since they cause issues if they exist
            //root.RemovedTables.AddRange(model.Entities.Where(x => x.IsAssociative && x.IsGenerated).Select(x => x.Name));

            root.RemovedViews.AddRange(model.RemovedViews);
            //Remove EnumOnly type-tables from the project
            root.RemovedTables.AddRange(model.Entities.Where(x => x.TypedEntity == TypedEntityConstants.EnumOnly).Select(x => x.Name));

            return(genList);
        }
        /// <summary>
        /// Saves Modules to disk
        /// </summary>
        private static void SaveToDisk(nHydrateModel modelRoot, IEnumerable<Module> list, string rootFolder, nHydrateDiagram diagram, List<string> generatedFileList)
        {
            var folder = rootFolder;
            if (!Directory.Exists(folder)) Directory.CreateDirectory(folder);

            var document = new XmlDocument();
            document.LoadXml(@"<configuration type=""module""></configuration>");

            foreach (var item in list)
            {
                var moduleNode = XmlHelper.AddElement(document.DocumentElement, "module") as XmlElement;
                XmlHelper.AddLineBreak(moduleNode);
                XmlHelper.AddCData(moduleNode, "summary", item.Summary);
                XmlHelper.AddAttribute(moduleNode, "id", item.Id);
                XmlHelper.AddAttribute(moduleNode, "name", item.Name);
                XmlHelper.AddLineBreak(moduleNode);

                var rulesNodes = XmlHelper.AddElement(moduleNode, "ruleset") as XmlElement;
                XmlHelper.AddLineBreak((XmlElement)rulesNodes);

                foreach (var rule in item.ModuleRules.OrderBy(x => x.Name))
                {
                    var fieldNode = XmlHelper.AddElement(rulesNodes, "rule");

                    XmlHelper.AddLineBreak((XmlElement)fieldNode);
                    XmlHelper.AddCData((XmlElement)fieldNode, "summary", rule.Summary);
                    XmlHelper.AddLineBreak((XmlElement)fieldNode);

                    XmlHelper.AddAttribute(fieldNode, "status", rule.Status.ToString("d"));
                    XmlHelper.AddAttribute(fieldNode, "dependentmodule", rule.DependentModule);
                    XmlHelper.AddAttribute(fieldNode, "name", rule.Name);
                    XmlHelper.AddAttribute(fieldNode, "inclusion", rule.Inclusion);
                    XmlHelper.AddAttribute(fieldNode, "enforced", rule.Enforced);

                    XmlHelper.AddLineBreak((XmlElement)rulesNodes);
                }

            }

            var f = Path.Combine(folder, "modules.configuration.xml");
            WriteFileIfNeedBe(f, document.ToIndentedString(), generatedFileList);
            WriteReadMeFile(folder, generatedFileList);
        }
        /// <summary>
        /// Saves Functions to disk
        /// </summary>
        private static void SaveToDisk(nHydrateModel modelRoot, IEnumerable<Function> list, string rootFolder, nHydrateDiagram diagram, List<string> generatedFileList)
        {
            var folder = Path.Combine(rootFolder, FOLDER_FC);
            if (!Directory.Exists(folder)) Directory.CreateDirectory(folder);
            foreach (var item in list)
            {
                var f = Path.Combine(folder, item.Name + ".sql");
                WriteFileIfNeedBe(f, item.SQL, generatedFileList);
            }

            #region Save other parameter/field information
            foreach (var item in list)
            {
                var document = new XmlDocument();
                document.LoadXml(@"<configuration type=""function"" name=""" + item.Name + @"""></configuration>");

                XmlHelper.AddLineBreak(document.DocumentElement);
                XmlHelper.AddCData(document.DocumentElement, "summary", item.Summary);
                XmlHelper.AddLineBreak(document.DocumentElement);

                XmlHelper.AddAttribute(document.DocumentElement, "id", item.Id);
                XmlHelper.AddAttribute(document.DocumentElement, "precedenceorder", item.PrecedenceOrder);
                XmlHelper.AddAttribute(document.DocumentElement, "codefacade", item.CodeFacade);
                XmlHelper.AddAttribute(document.DocumentElement, "isgenerated", item.IsGenerated);
                XmlHelper.AddAttribute(document.DocumentElement, "schema", item.Schema);
                XmlHelper.AddAttribute(document.DocumentElement, "istable", item.IsTable);
                XmlHelper.AddAttribute(document.DocumentElement, "returnvariable", item.ReturnVariable);

                var fieldsNodes = XmlHelper.AddElement(document.DocumentElement, "fieldset") as XmlElement;
                XmlHelper.AddLineBreak((XmlElement)fieldsNodes);

                foreach (var field in item.Fields.OrderBy(x => x.Name))
                {
                    var fieldNode = XmlHelper.AddElement(fieldsNodes, "field");

                    XmlHelper.AddLineBreak((XmlElement)fieldNode);
                    XmlHelper.AddCData((XmlElement)fieldNode, "summary", field.Summary);
                    XmlHelper.AddLineBreak((XmlElement)fieldNode);

                    XmlHelper.AddAttribute(fieldNode, "id", field.Id);
                    XmlHelper.AddAttribute(fieldNode, "name", field.Name);
                    XmlHelper.AddAttribute(fieldNode, "nullable", field.Nullable);
                    XmlHelper.AddAttribute(fieldNode, "datatype", field.DataType.ToString());
                    XmlHelper.AddAttribute(fieldNode, "codefacade", field.CodeFacade);
                    XmlHelper.AddAttribute(fieldNode, "default", field.Default);
                    XmlHelper.AddAttribute(fieldNode, "isgenerated", field.IsGenerated);
                    XmlHelper.AddAttribute(fieldNode, "length", field.Length);
                    XmlHelper.AddAttribute(fieldNode, "scale", field.Scale);

                    XmlHelper.AddLineBreak((XmlElement)fieldsNodes);
                }

                var parametersNodes = XmlHelper.AddElement(document.DocumentElement, "parameterset") as XmlElement;
                XmlHelper.AddLineBreak((XmlElement)parametersNodes);

                foreach (var parameter in item.Parameters.OrderBy(x => x.Name))
                {
                    var parameterNode = XmlHelper.AddElement(parametersNodes, "parameter");

                    XmlHelper.AddLineBreak((XmlElement)parameterNode);
                    XmlHelper.AddCData((XmlElement)parameterNode, "summary", parameter.Summary);
                    XmlHelper.AddLineBreak((XmlElement)parameterNode);

                    XmlHelper.AddAttribute(parameterNode, "id", parameter.Id);
                    XmlHelper.AddAttribute(parameterNode, "name", parameter.Name);
                    XmlHelper.AddAttribute(parameterNode, "nullable", parameter.Nullable);
                    XmlHelper.AddAttribute(parameterNode, "datatype", parameter.DataType.ToString());
                    XmlHelper.AddAttribute(parameterNode, "codefacade", parameter.CodeFacade);
                    XmlHelper.AddAttribute(parameterNode, "default", parameter.Default);
                    XmlHelper.AddAttribute(parameterNode, "isgenerated", parameter.IsGenerated);
                    XmlHelper.AddAttribute(parameterNode, "length", parameter.Length);
                    XmlHelper.AddAttribute(parameterNode, "scale", parameter.Scale);

                    XmlHelper.AddLineBreak((XmlElement)parametersNodes);
                }

                XmlHelper.AddLineBreak(document.DocumentElement);
                var f = Path.Combine(folder, item.Name + ".configuration.xml");
                WriteFileIfNeedBe(f, document.ToIndentedString(), generatedFileList);

                //Save other files
                SaveModules(folder, item, generatedFileList);

            }
            #endregion

            WriteReadMeFile(folder, generatedFileList);
        }
        /// <summary>
        /// Saves Stored Procedures to disk
        /// </summary>
        private static void SaveToDisk(nHydrateModel modelRoot, IEnumerable<Entity> list, string rootFolder, nHydrateDiagram diagram, List<string> generatedFileList)
        {
            var folder = Path.Combine(rootFolder, FOLDER_ET);
            if (!Directory.Exists(folder)) Directory.CreateDirectory(folder);

            #region Save other parameter/field information
            foreach (var item in list)
            {
                var document = new XmlDocument();
                document.LoadXml(@"<configuration type=""entity"" name=""" + item.Name + @"""></configuration>");

                XmlHelper.AddLineBreak(document.DocumentElement);
                XmlHelper.AddCData(document.DocumentElement, "summary", item.Summary);
                XmlHelper.AddLineBreak(document.DocumentElement);

                XmlHelper.AddAttribute(document.DocumentElement, "id", item.Id);
                XmlHelper.AddAttribute(document.DocumentElement, "allowaudittracking", item.AllowAuditTracking);
                XmlHelper.AddAttribute(document.DocumentElement, "allowcreateaudit", item.AllowCreateAudit);
                XmlHelper.AddAttribute(document.DocumentElement, "allowmodifyaudit", item.AllowModifyAudit);
                XmlHelper.AddAttribute(document.DocumentElement, "allowtimestamp", item.AllowTimestamp);
                XmlHelper.AddAttribute(document.DocumentElement, "codefacade", item.CodeFacade);
                XmlHelper.AddAttribute(document.DocumentElement, "immutable", item.Immutable);
                XmlHelper.AddAttribute(document.DocumentElement, "enforceprimarykey", item.EnforcePrimaryKey);
                XmlHelper.AddAttribute(document.DocumentElement, "isassociative", item.IsAssociative);
                XmlHelper.AddAttribute(document.DocumentElement, "typedentity", item.TypedEntity.ToString());
                XmlHelper.AddAttribute(document.DocumentElement, "schema", item.Schema);
                XmlHelper.AddAttribute(document.DocumentElement, "generatesdoublederived", item.GeneratesDoubleDerived);
                XmlHelper.AddAttribute(document.DocumentElement, "isgenerated", item.IsGenerated);
                XmlHelper.AddAttribute(document.DocumentElement, "isTenant", item.IsTenant);

                #region Fields
                {
                    var fieldsNodes = XmlHelper.AddElement(document.DocumentElement, "fieldset") as XmlElement;
                    XmlHelper.AddLineBreak((XmlElement)fieldsNodes);
                    foreach (var field in item.Fields.OrderBy(x => x.Name))
                    {
                        var fieldNode = XmlHelper.AddElement(fieldsNodes, "field");

                        XmlHelper.AddLineBreak((XmlElement)fieldNode);
                        XmlHelper.AddCData((XmlElement)fieldNode, "summary", field.Summary);
                        XmlHelper.AddLineBreak((XmlElement)fieldNode);

                        XmlHelper.AddAttribute(fieldNode, "id", field.Id);
                        XmlHelper.AddAttribute(fieldNode, "name", field.Name);
                        XmlHelper.AddAttribute(fieldNode, "nullable", field.Nullable);
                        XmlHelper.AddAttribute(fieldNode, "datatype", field.DataType.ToString());
                        XmlHelper.AddAttribute(fieldNode, "identity", field.Identity.ToString());
                        XmlHelper.AddAttribute(fieldNode, "codefacade", field.CodeFacade);
                        XmlHelper.AddAttribute(fieldNode, "dataformatstring", field.DataFormatString);
                        XmlHelper.AddAttribute(fieldNode, "default", field.Default);
                        XmlHelper.AddAttribute(fieldNode, "defaultisfunc", field.DefaultIsFunc);
                        XmlHelper.AddAttribute(fieldNode, "formula", field.Formula);
                        XmlHelper.AddAttribute(fieldNode, "isgenerated", field.IsGenerated);
                        XmlHelper.AddAttribute(fieldNode, "isindexed", field.IsIndexed);
                        XmlHelper.AddAttribute(fieldNode, "isprimarykey", field.IsPrimaryKey);
                        XmlHelper.AddAttribute(fieldNode, "Iscalculated", field.IsCalculated);
                        XmlHelper.AddAttribute(fieldNode, "isunique", field.IsUnique);
                        XmlHelper.AddAttribute(fieldNode, "length", field.Length);
                        XmlHelper.AddAttribute(fieldNode, "scale", field.Scale);
                        XmlHelper.AddAttribute(fieldNode, "sortorder", field.SortOrder);
                        XmlHelper.AddAttribute(fieldNode, "isreadonly", field.IsReadOnly);
                        XmlHelper.AddAttribute(fieldNode, "category", field.Category);
                        XmlHelper.AddAttribute(fieldNode, "collate", field.Collate);
                        XmlHelper.AddAttribute(fieldNode, "friendlyname", field.FriendlyName);
                        XmlHelper.AddAttribute(fieldNode, "isbrowsable", field.IsBrowsable);
                        XmlHelper.AddAttribute(fieldNode, "max", field.Max);
                        XmlHelper.AddAttribute(fieldNode, "min", field.Min);
                        XmlHelper.AddAttribute(fieldNode, "validationexpression", field.ValidationExpression);
                        XmlHelper.AddAttribute(fieldNode, "obsolete", field.Obsolete);

                        XmlHelper.AddLineBreak((XmlElement)fieldsNodes);
                    }
                    XmlHelper.AddLineBreak((XmlElement)document.DocumentElement);
                }
                #endregion

                #region Security

                if (item.SecurityFunction != null)
                {
                    var secNode = XmlHelper.AddElement(document.DocumentElement, "security") as XmlElement;

                    XmlHelper.AddAttribute(secNode, "id", item.SecurityFunction.Id);

                    var ff = Path.Combine(folder, item.Name + ".security.sql");
                    WriteFileIfNeedBe(ff, item.SecurityFunction.SQL, generatedFileList);

                    //Parameters
                    var secParamNodes = XmlHelper.AddElement(secNode, "parameterset") as XmlElement;
                    XmlHelper.AddLineBreak((XmlElement)secParamNodes);
                    foreach (var parameter in item.SecurityFunction.SecurityFunctionParameters.OrderBy(x => x.Name))
                    {
                        var parameterNode = XmlHelper.AddElement(secParamNodes, "field");

                        XmlHelper.AddLineBreak((XmlElement)parameterNode);
                        XmlHelper.AddCData((XmlElement)parameterNode, "summary", parameter.Summary);
                        XmlHelper.AddLineBreak((XmlElement)parameterNode);

                        XmlHelper.AddAttribute(parameterNode, "id", parameter.Id);
                        XmlHelper.AddAttribute(parameterNode, "name", parameter.Name);
                        XmlHelper.AddAttribute(parameterNode, "nullable", parameter.Nullable);
                        XmlHelper.AddAttribute(parameterNode, "datatype", parameter.DataType.ToString());
                        XmlHelper.AddAttribute(parameterNode, "codefacade", parameter.CodeFacade);
                        XmlHelper.AddAttribute(parameterNode, "default", parameter.Default);
                        XmlHelper.AddAttribute(parameterNode, "isgenerated", parameter.IsGenerated);
                        XmlHelper.AddAttribute(parameterNode, "length", parameter.Length);
                        XmlHelper.AddAttribute(parameterNode, "scale", parameter.Scale);
                    }
                }

                #endregion

                XmlHelper.AddLineBreak(document.DocumentElement);
                var f = Path.Combine(folder, item.Name + ".configuration.xml");
                WriteFileIfNeedBe(f, document.ToIndentedString(), generatedFileList);

                //Save other files
                SaveEntityIndexes(folder, item, generatedFileList);
                SaveModules(folder, item, generatedFileList);
                SaveRelations(folder, item, generatedFileList);
                SaveEntityStaticData(folder, item, generatedFileList);
                SaveEntityMetaData(folder, item, generatedFileList);
                SaveEntityComposites(folder, item, generatedFileList);

            }
            #endregion

            WriteReadMeFile(folder, generatedFileList);
        }
        private static void SaveRelations(string folder, Entity item, List<string> generatedFileList)
        {
            var document = new XmlDocument();
            document.LoadXml(@"<configuration type=""entity.relations"" id=""" + item.Id + @"""></configuration>");

            XmlHelper.AddLineBreak((XmlElement)document.DocumentElement);
            foreach (var relation in item.RelationshipList)
            {
                var relationNode = XmlHelper.AddElement(document.DocumentElement, "relation");

                XmlHelper.AddLineBreak((XmlElement)relationNode);
                XmlHelper.AddCData((XmlElement)relationNode, "summary", relation.Summary);
                XmlHelper.AddLineBreak((XmlElement)relationNode);

                XmlHelper.AddAttribute(relationNode, "id", relation.InternalId);
                XmlHelper.AddAttribute(relationNode, "childid", relation.ChildEntity.Id);
                XmlHelper.AddAttribute(relationNode, "isenforced", relation.IsEnforced);
                XmlHelper.AddAttribute(relationNode, "isinherited", false);
                XmlHelper.AddAttribute(relationNode, "rolename", relation.RoleName);

                XmlHelper.AddLineBreak((XmlElement)document.DocumentElement);

                //Process the columns
                var relationColumnsNodes = XmlHelper.AddElement((XmlElement)relationNode, "relationfieldset") as XmlElement;
                XmlHelper.AddLineBreak((XmlElement)relationColumnsNodes);
                foreach (var relationField in relation.FieldMapList())
                {
                    var realtionFieldNode = XmlHelper.AddElement(relationColumnsNodes, "field");
                    XmlHelper.AddAttribute(realtionFieldNode, "id", relationField.Id);
                    XmlHelper.AddAttribute(realtionFieldNode, "sourcefieldid", relationField.SourceFieldId);
                    XmlHelper.AddAttribute(realtionFieldNode, "targetfieldid", relationField.TargetFieldId);

                    XmlHelper.AddLineBreak((XmlElement)relationColumnsNodes);
                }
            }

            foreach (var relation in item.ParentRelationshipList)
            {
                var relationNode = XmlHelper.AddElement(document.DocumentElement, "relation");

                XmlHelper.AddLineBreak((XmlElement)relationNode);
                XmlHelper.AddCData((XmlElement)relationNode, "summary", relation.Summary);
                XmlHelper.AddLineBreak((XmlElement)relationNode);

                XmlHelper.AddAttribute(relationNode, "id", relation.InternalId);
                XmlHelper.AddAttribute(relationNode, "parentid", relation.ParentInheritedEntity.Id);
                XmlHelper.AddAttribute(relationNode, "isenforced", relation.IsEnforced);
                XmlHelper.AddAttribute(relationNode, "isinherited", true);
                XmlHelper.AddAttribute(relationNode, "rolename", relation.RoleName);
                XmlHelper.AddLineBreak((XmlElement)document.DocumentElement);
            }

            foreach (var relation in item.RelationshipViewList)
            {
                var relationNode = XmlHelper.AddElement(document.DocumentElement, "relation");
                XmlHelper.AddAttribute(relationNode, "isviewrelation", "true");

                XmlHelper.AddLineBreak((XmlElement)relationNode);
                XmlHelper.AddCData((XmlElement)relationNode, "summary", relation.Summary);
                XmlHelper.AddLineBreak((XmlElement)relationNode);

                XmlHelper.AddAttribute(relationNode, "id", relation.InternalId);
                XmlHelper.AddAttribute(relationNode, "childid", relation.ChildView.Id);
                XmlHelper.AddAttribute(relationNode, "rolename", relation.RoleName);

                XmlHelper.AddLineBreak((XmlElement)document.DocumentElement);

                //Process the columns
                var relationColumnsNodes = XmlHelper.AddElement((XmlElement)relationNode, "relationfieldset") as XmlElement;
                XmlHelper.AddLineBreak((XmlElement)relationColumnsNodes);
                foreach (var relationField in relation.FieldMapList())
                {
                    var realtionFieldNode = XmlHelper.AddElement(relationColumnsNodes, "field");
                    XmlHelper.AddAttribute(realtionFieldNode, "id", relationField.Id);
                    XmlHelper.AddAttribute(realtionFieldNode, "sourcefieldid", relationField.SourceFieldId);
                    XmlHelper.AddAttribute(realtionFieldNode, "targetfieldid", relationField.TargetFieldId);

                    XmlHelper.AddLineBreak((XmlElement)relationColumnsNodes);
                }
            }

            var f = Path.Combine(folder, item.Name + ".relations.xml");
            WriteFileIfNeedBe(f, document.ToIndentedString(), generatedFileList);

        }
 private static void SaveDiagramFiles(string rootFolder, nHydrateDiagram diagram, List<string> generatedFileList)
 {
     var fileName = Path.Combine(rootFolder, "diagram.xml");
     var document = new XmlDocument();
     document.LoadXml(@"<configuration type=""diagram""></configuration>");
     foreach (var shape in diagram.NestedChildShapes)
     {
         if (shape is EntityShape)
         {
             var item = ((shape as EntityShape).ModelElement as Entity);
             var node = XmlHelper.AddElement(document.DocumentElement, "element");
             XmlHelper.AddAttribute(node, "id", shape.ModelElement.Id);
             XmlHelper.AddAttribute(node, "bounds", shape.AbsoluteBoundingBox.ToXmlValue());
         }
         else if (shape is ViewShape)
         {
             var item = ((shape as ViewShape).ModelElement as View);
             var node = XmlHelper.AddElement(document.DocumentElement, "element");
             XmlHelper.AddAttribute(node, "id", shape.ModelElement.Id);
             XmlHelper.AddAttribute(node, "bounds", shape.AbsoluteBoundingBox.ToXmlValue());
         }
         else if (shape is StoredProcedureShape)
         {
             var item = ((shape as StoredProcedureShape).ModelElement as StoredProcedure);
             var node = XmlHelper.AddElement(document.DocumentElement, "element");
             XmlHelper.AddAttribute(node, "id", shape.ModelElement.Id);
             XmlHelper.AddAttribute(node, "bounds", shape.AbsoluteBoundingBox.ToXmlValue());
         }
         else if (shape is FunctionShape)
         {
             var item = ((shape as FunctionShape).ModelElement as Function);
             var node = XmlHelper.AddElement(document.DocumentElement, "element");
             XmlHelper.AddAttribute(node, "id", shape.ModelElement.Id);
             XmlHelper.AddAttribute(node, "bounds", shape.AbsoluteBoundingBox.ToXmlValue());
         }
     }
     WriteFileIfNeedBe(fileName, document.ToIndentedString(), generatedFileList);
 }
        private static void SaveEntityMetaData(string folder, Entity item, List<string> generatedFileList)
        {
            var f = Path.Combine(folder, item.Name + ".metadata.xml");
            if (item.StaticDatum.Count == 0)
                return;

            var fieldMetaData = item.Fields.SelectMany(x => x.FieldMetadata).ToList();
            if (item.EntityMetadata.Count == 0 && fieldMetaData.Count == 0)
                return;

            var document = new XmlDocument();
            document.LoadXml(@"<configuration type=""entity.metadata"" id=""" + item.Id + @"""></configuration>");

            XmlHelper.AddLineBreak((XmlElement)document.DocumentElement);
            foreach (var metadata in item.EntityMetadata)
            {
                var metaDataNode = XmlHelper.AddElement(document.DocumentElement, "metadata");
                XmlHelper.AddAttribute(metaDataNode, "key", metadata.Key);
                XmlHelper.AddAttribute(metaDataNode, "value", metadata.Value);
                XmlHelper.AddLineBreak((XmlElement)document.DocumentElement);

                //Metadata for fields
                var metadataColumnsNodes = XmlHelper.AddElement((XmlElement)document.DocumentElement, "fieldset") as XmlElement;
                XmlHelper.AddLineBreak((XmlElement)metadataColumnsNodes);
                foreach (var fmd in fieldMetaData)
                {
                    var fmdNode = XmlHelper.AddElement(metadataColumnsNodes, "metadata");
                    XmlHelper.AddAttribute(fmdNode, "columnid", fmd.Field.Id);
                    XmlHelper.AddAttribute(fmdNode, "key", fmd.Key);
                    XmlHelper.AddAttribute(fmdNode, "value", fmd.Value);

                    XmlHelper.AddLineBreak((XmlElement)metadataColumnsNodes);
                }

            }

            WriteFileIfNeedBe(f, document.ToIndentedString(), generatedFileList);
        }
        private static void SaveEntityStaticData(string folder, Entity item, List<string> generatedFileList)
        {
            var f = Path.Combine(folder, item.Name + ".staticdata.xml");
            if (item.StaticDatum.Count == 0)
                return;

            var document = new XmlDocument();
            document.LoadXml(@"<configuration type=""entity.staticdata"" id=""" + item.Id + @"""></configuration>");

            XmlHelper.AddLineBreak((XmlElement)document.DocumentElement);
            foreach (var data in item.StaticDatum)
            {
                var dataNode = XmlHelper.AddElement(document.DocumentElement, "data");

                XmlHelper.AddAttribute(dataNode, "columnkey", data.ColumnKey);
                XmlHelper.AddAttribute(dataNode, "value", data.Value);
                XmlHelper.AddAttribute(dataNode, "orderkey", data.OrderKey);
                XmlHelper.AddLineBreak((XmlElement)document.DocumentElement);
            }

            WriteFileIfNeedBe(f, document.ToIndentedString(), generatedFileList);
        }
        private static void SaveModules(string folder, Function item, List<string> generatedFileList)
        {
            var document = new XmlDocument();
            document.LoadXml(@"<configuration type=""function.modules"" id=""" + item.Id + @"""></configuration>");

            XmlHelper.AddLineBreak((XmlElement)document.DocumentElement);
            foreach (var module in item.Modules)
            {
                var newNode = XmlHelper.AddElement(document.DocumentElement, "map");
                XmlHelper.AddAttribute(newNode, "module", module.Id);
                XmlHelper.AddLineBreak((XmlElement)document.DocumentElement);
            }

            var f = Path.Combine(folder, item.Name + ".modules.xml");
            WriteFileIfNeedBe(f, document.ToIndentedString(), generatedFileList);
        }
        private static void SaveToDisk(nHydrateModel modelRoot, IEnumerable<ModelMetadata> list, string rootFolder, nHydrateDiagram diagram, List<string> generatedFileList)
        {
            if (!list.Any())
                return;

            var document = new XmlDocument();
            document.LoadXml(@"<configuration type=""model.metadata""></configuration>");

            XmlHelper.AddLineBreak((XmlElement)document.DocumentElement);
            foreach (var metadata in list)
            {
                var metaDataNode = XmlHelper.AddElement(document.DocumentElement, "metadata");
                XmlHelper.AddAttribute(metaDataNode, "key", metadata.Key);
                XmlHelper.AddAttribute(metaDataNode, "value", metadata.Value);
                XmlHelper.AddLineBreak((XmlElement)document.DocumentElement);
            }

            var f = Path.Combine(rootFolder, "metadata.configuration.xml");
            WriteFileIfNeedBe(f, document.ToIndentedString(), generatedFileList);
        }
        private static void SaveModules(string folder, Entity item, List<string> generatedFileList)
        {
            var document = new XmlDocument();
            document.LoadXml(@"<configuration type=""entity.modules"" id=""" + item.Id + @"""></configuration>");

            XmlHelper.AddLineBreak((XmlElement)document.DocumentElement);

            //Fields
            foreach (var field in item.Fields)
            {
                foreach (var module in field.Modules)
                {
                    var newNode = XmlHelper.AddElement(document.DocumentElement, "map");
                    XmlHelper.AddAttribute(newNode, "source", field.Id);
                    XmlHelper.AddAttribute(newNode, "module", module.Id);
                    XmlHelper.AddAttribute(newNode, "type", "field");
                    XmlHelper.AddLineBreak((XmlElement)document.DocumentElement);
                }
            }

            //Relations
            foreach (var relation in item.RelationshipList)
            {
                foreach (var rm in item.nHydrateModel.RelationModules.Where(x => x.RelationID == relation.Id))
                {
                    var newNode = XmlHelper.AddElement(document.DocumentElement, "map");
                    XmlHelper.AddAttribute(newNode, "source", relation.InternalId);
                    XmlHelper.AddAttribute(newNode, "module", rm.ModuleId);
                    XmlHelper.AddAttribute(newNode, "isenforced", rm.IsEnforced);
                    XmlHelper.AddAttribute(newNode, "type", "relation");
                    XmlHelper.AddLineBreak((XmlElement)document.DocumentElement);
                }
            }

            //Indexes
            foreach (var index in item.IndexList)
            {
                foreach (var rm in item.nHydrateModel.IndexModules.Where(x => x.IndexID == index.Id))
                {
                    var newNode = XmlHelper.AddElement(document.DocumentElement, "map");
                    XmlHelper.AddAttribute(newNode, "source", index.Id);
                    XmlHelper.AddAttribute(newNode, "module", rm.ModuleId);
                    XmlHelper.AddAttribute(newNode, "type", "index");
                    XmlHelper.AddLineBreak((XmlElement)document.DocumentElement);
                }
            }

            var f = Path.Combine(folder, item.Name + ".modules.xml");
            WriteFileIfNeedBe(f, document.ToIndentedString(), generatedFileList);

        }
        private static void SaveEntityComposites(string folder, Entity item, List<string> generatedFileList)
        {
            var document = new XmlDocument();
            document.LoadXml(@"<configuration type=""composite"" id=""" + item.Id + @"""></configuration>");

            if (item.Composites.Count == 0)
                return;

            XmlHelper.AddLineBreak((XmlElement)document.DocumentElement);
            foreach (var composite in item.Composites)
            {
                var indexNode = XmlHelper.AddElement(document.DocumentElement, "composite");

                XmlHelper.AddLineBreak((XmlElement)indexNode);
                XmlHelper.AddCData((XmlElement)indexNode, "summary", composite.Summary);
                XmlHelper.AddLineBreak((XmlElement)indexNode);

                XmlHelper.AddAttribute(indexNode, "codefacade", composite.CodeFacade);
                XmlHelper.AddAttribute(indexNode, "name", composite.Name);
                XmlHelper.AddAttribute(indexNode, "isgenerated", composite.IsGenerated);

                XmlHelper.AddLineBreak((XmlElement)document.DocumentElement);

                //Process the columns
                var columnsNodes = XmlHelper.AddElement((XmlElement)indexNode, "columnset") as XmlElement;
                XmlHelper.AddLineBreak((XmlElement)columnsNodes);
                foreach (var column in composite.Fields)
                {
                    var indexColumnNode = XmlHelper.AddElement(columnsNodes, "column");
                    XmlHelper.AddAttribute(indexColumnNode, "fieldid", column.FieldId);

                    XmlHelper.AddLineBreak((XmlElement)columnsNodes);
                }
            }

            var f = Path.Combine(folder, item.Name + ".composites.xml");
            WriteFileIfNeedBe(f, document.ToIndentedString(), generatedFileList);

        }
        private static void SaveEntityIndexes(string folder, Entity item, List<string> generatedFileList)
        {
            var document = new XmlDocument();
            document.LoadXml(@"<configuration type=""entity.indexes"" id=""" + item.Id + @"""></configuration>");

            XmlHelper.AddLineBreak((XmlElement)document.DocumentElement);
            foreach (var index in item.Indexes)
            {
                var indexNode = XmlHelper.AddElement(document.DocumentElement, "index");

                XmlHelper.AddLineBreak((XmlElement)indexNode);
                XmlHelper.AddCData((XmlElement)indexNode, "summary", index.Summary);
                XmlHelper.AddLineBreak((XmlElement)indexNode);

                XmlHelper.AddAttribute(indexNode, "id", index.Id);
                XmlHelper.AddAttribute(indexNode, "clustered", index.Clustered);
                XmlHelper.AddAttribute(indexNode, "importedname", index.ImportedName);
                XmlHelper.AddAttribute(indexNode, "indextype", index.IndexType.ToString("d"));
                XmlHelper.AddAttribute(indexNode, "isunique", index.IsUnique);

                XmlHelper.AddLineBreak((XmlElement)document.DocumentElement);

                //Process the columns
                var indexColumnsNodes = XmlHelper.AddElement((XmlElement)indexNode, "indexcolumnset") as XmlElement;
                XmlHelper.AddLineBreak((XmlElement)indexColumnsNodes);
                foreach (var indexColumn in index.IndexColumns)
                {
                    var indexColumnNode = XmlHelper.AddElement(indexColumnsNodes, "column");
                    XmlHelper.AddAttribute(indexColumnNode, "id", indexColumn.Id);
                    XmlHelper.AddAttribute(indexColumnNode, "ascending", indexColumn.Ascending);
                    XmlHelper.AddAttribute(indexColumnNode, "fieldid", indexColumn.FieldID);
                    XmlHelper.AddAttribute(indexColumnNode, "sortorder", indexColumn.SortOrder);

                    XmlHelper.AddLineBreak((XmlElement)indexColumnsNodes);
                }
            }

            var f = Path.Combine(folder, item.Name + ".indexes.xml");
            WriteFileIfNeedBe(f, document.ToIndentedString(), generatedFileList);

        }
        private static void WriteFileIfNeedBe(string fileName, string contents, List<string> generatedFileList)
        {
            if (fileName.ToLower().EndsWith(".xml"))
            {
                generatedFileList.Add(fileName);
                try
                {
                    //Load formatted original XML
                    var origXML = string.Empty;
                    if (File.Exists(fileName))
                    {
                        var xmlText = File.ReadAllText(fileName);
                        if (!string.IsNullOrEmpty(xmlText))
                        {
                            var documentCheck = new XmlDocument();
                            documentCheck.LoadXml(xmlText);
                            origXML = documentCheck.ToIndentedString();
                        }
                    }

                    //Load formatted new XML
                    var newXML = string.Empty;
                    {
                        var documentCheck = new XmlDocument();
                        documentCheck.LoadXml(contents);
                        newXML = documentCheck.ToIndentedString();
                    }

                    if (origXML == newXML)
                        return;
                    else
                        contents = newXML;
                }
                catch (Exception ex)
                {
                    //If there is an error then process like a non-XML file
                    //Do Nothing
                }
            }
            else
            {
                //Check if this is the same content and if so do nothing
                generatedFileList.Add(fileName);
                if (File.Exists(fileName))
                {
                    var t = File.ReadAllText(fileName);
                    if (t == contents)
                        return;
                }
            }

            File.WriteAllText(fileName, contents);
            System.Windows.Forms.Application.DoEvents();
        }
        private List<nHydrateGeneratorProject> BuildModelList(nHydrateModel model, Microsoft.VisualStudio.Modeling.Diagrams.Diagram diagram, Microsoft.VisualStudio.Modeling.Shell.ModelingDocData docData)
        {
            var genList = new List<nHydrateGeneratorProject>();

            if (model.UseModules)
            {
                foreach (var module in model.Modules)
                {
                    var genProject = new nHydrateGeneratorProject();
                    genList.Add(genProject);
                    var root = CreatePOCOModel(model, diagram, module);
                    root.SetKey(module.Id.ToString());
                    root.GeneratorProject = genProject;
                    genProject.RootController.Object = root;
                    var fi = new System.IO.FileInfo(docData.FileName);
                    genProject.FileName = docData.FileName + "." + module.Name + ".generating";
                    var document = new System.Xml.XmlDocument();
                    document.LoadXml("<modelRoot guid=\"" + module.Id + "\" type=\"nHydrate.Generator.nHydrateGeneratorProject\" assembly=\"nHydrate.Generator.dll\"><ModelRoot></ModelRoot></modelRoot>");
                    ((nHydrate.Generator.Common.GeneratorFramework.IXMLable)root).XmlAppend(document.DocumentElement.ChildNodes[0]);
                    System.IO.File.WriteAllText(genProject.FileName, document.ToIndentedString());

                    ProcessRenamed(genProject.FileName + ".sql.lastgen", root);

                    root.RemovedTables.AddRange(model.RemovedTables);
                    root.RemovedViews.AddRange(model.RemovedViews);
                    root.RemovedStoredProcedures.AddRange(model.RemovedStoredProcedures);
                    root.RemovedFunctions.AddRange(model.RemovedFunctions);

                    //Remove associative tables since they cause issues if they exist
                    root.RemovedTables.AddRange(model.Entities.Where(x => x.IsAssociative && x.IsGenerated).Select(x => x.Name));
                    //Remove non-generated items from the project
                    root.RemovedTables.AddRange(model.Entities.Where(x => !x.IsGenerated).Select(x => x.Name));
                    root.RemovedTables.AddRange(model.Views.Where(x => !x.IsGenerated).Select(x => x.Name));
                    root.RemovedTables.AddRange(model.StoredProcedures.Where(x => !x.IsGenerated).Select(x => x.Name));
                    root.RemovedTables.AddRange(model.Functions.Where(x => !x.IsGenerated).Select(x => x.Name));
                    //Remove EnumOnly type-tables from the project
                    root.RemovedTables.AddRange(model.Entities.Where(x => x.TypedEntity == TypedEntityConstants.EnumOnly && x.IsGenerated).Select(x => x.Name));
                }
            }
            else
            {
                var genProject = new nHydrateGeneratorProject();
                genList.Add(genProject);
                var root = CreatePOCOModel(model, diagram, null);
                root.SetKey(model.Id.ToString());
                root.GeneratorProject = genProject;
                genProject.RootController.Object = root;
                var fi = new System.IO.FileInfo(docData.FileName);
                genProject.FileName = docData.FileName + ".generating";
                var document = new System.Xml.XmlDocument();
                document.LoadXml("<modelRoot guid=\"" + model.Id + "\" type=\"nHydrate.Generator.nHydrateGeneratorProject\" assembly=\"nHydrate.Generator.dll\"><ModelRoot></ModelRoot></modelRoot>");
                ((nHydrate.Generator.Common.GeneratorFramework.IXMLable)root).XmlAppend(document.DocumentElement.ChildNodes[0]);
                System.IO.File.WriteAllText(genProject.FileName, document.ToIndentedString());

                ProcessRenamed(genProject.FileName + ".sql.lastgen", root);

                root.RemovedTables.AddRange(model.RemovedTables);
                root.RemovedViews.AddRange(model.RemovedViews);
                root.RemovedStoredProcedures.AddRange(model.RemovedStoredProcedures);
                root.RemovedFunctions.AddRange(model.RemovedFunctions);

                //Remove associative tables since they cause issues if they exist
                root.RemovedTables.AddRange(model.Entities.Where(x => x.IsAssociative && x.IsGenerated).Select(x => x.Name));
                //Remove non-generated items from the project
                root.RemovedTables.AddRange(model.Entities.Where(x => !x.IsGenerated).Select(x => x.Name));
                root.RemovedTables.AddRange(model.Views.Where(x => !x.IsGenerated).Select(x => x.Name));
                root.RemovedTables.AddRange(model.StoredProcedures.Where(x => !x.IsGenerated).Select(x => x.Name));
                root.RemovedTables.AddRange(model.Functions.Where(x => !x.IsGenerated).Select(x => x.Name));
                //Remove EnumOnly type-tables from the project
                root.RemovedTables.AddRange(model.Entities.Where(x => x.TypedEntity == TypedEntityConstants.EnumOnly && x.IsGenerated).Select(x => x.Name));

            }

            return genList;
        }