private static DataXml.Record GenerateRecordNode(Sdk.Entity entity, BuilderEntityMetadata builderEntityMetadata)
        {
            var RecordNode = new DataXml.Record
            {
                Id    = entity.Id.ToString(),
                Field = new List <DataXml.Field>()
            };

            foreach (var attribute in entity.Attributes)
            {
                var attributeMetadata = builderEntityMetadata.Metadata.Attributes.Where(a => a.LogicalName.Equals(attribute.Key)).First();

                if (!IsSupportedAttributeType(attributeMetadata.AttributeType))
                {
                    continue;
                }

                RecordNode.Field.Add(GenerateFieldNode(attribute, attributeMetadata, builderEntityMetadata));
            }

            RecordNode.Field.Sort((x, y) => string.Compare(x.Name, y.Name));

            return(RecordNode);
        }
        private static DataXml.Entity GenerateEntityNode(String logicalName, BuilderEntityMetadata builderEntityMetadata)
        {
            var EntityNode = new DataXml.Entity
            {
                Name        = logicalName,
                Displayname = builderEntityMetadata.Metadata.DisplayName.LocalizedLabels[0].Label
            };

            var RecordsNode = new DataXml.Records
            {
                Record = new List <Record>()
            };

            foreach (var entity in builderEntityMetadata.Entities)
            {
                RecordsNode.Record.Add(GenerateRecordNode(entity, builderEntityMetadata));
            }

            EntityNode.Records = RecordsNode;

            EntityNode.M2mrelationships = new DataXml.M2mrelationships()
            {
                M2mrelationship = new List <M2mrelationship>()
            };

            foreach (var relationshipName in builderEntityMetadata.RelatedEntities.Keys)
            {
                var relationshipMetadata = builderEntityMetadata.Metadata.ManyToManyRelationships.Where(x => x.IntersectEntityName == relationshipName).First();

                foreach (KeyValuePair <Guid, List <Guid> > relationshipPair in builderEntityMetadata.RelatedEntities[relationshipName])
                {
                    string targetPrimaryKey = relationshipMetadata.Entity2IntersectAttribute;
                    if (relationshipMetadata.Entity1LogicalName == relationshipMetadata.Entity2LogicalName)
                    {
                        targetPrimaryKey = relationshipMetadata.Entity2IntersectAttribute.Substring(0, relationshipMetadata.Entity2IntersectAttribute.Length - 3);
                    }

                    var relationship = new M2mrelationship()
                    {
                        Sourceid                = relationshipPair.Key.ToString(),
                        Targetentityname        = relationshipMetadata.Entity2LogicalName,
                        Targetentitynameidfield = targetPrimaryKey,
                        M2mrelationshipname     = relationshipMetadata.IntersectEntityName,
                        Targetids               = new Targetids()
                        {
                            Targetid = new List <string>()
                        }
                    };

                    foreach (var relatedId in relationshipPair.Value)
                    {
                        relationship.Targetids.Targetid.Add(relatedId.ToString());
                    }

                    EntityNode.M2mrelationships.M2mrelationship.Add(relationship);
                }
            }

            EntityNode.Records.Record.Sort((x, y) => string.Compare(x.Id, y.Id));

            return(EntityNode);
        }
        private static Activitypointerrecords GenerateActivitypointerNode(Sdk.Entity entity, BuilderEntityMetadata builderEntityMetadata)
        {
            var ActivitypointerNode = new DataXml.Activitypointerrecords
            {
                Id    = entity.Id.ToString(),
                Field = new List <DataXml.Field>()
            };

            foreach (var attribute in entity.Attributes)
            {
                ActivitypointerNode.Field.Add(GenerateFieldNode(attribute, Builders.ActivityPartyMetadata.Build().Attributes.Where(a => a.LogicalName.Equals(attribute.Key)).First(), builderEntityMetadata));
            }

            return(ActivitypointerNode);
        }
        private static DataXml.Field GenerateFieldNode(KeyValuePair <string, object> attribute, Sdk.Metadata.AttributeMetadata attributeMetadata, BuilderEntityMetadata builderEntityMetadata)
        {
            var FieldNode = new DataXml.Field
            {
                Name = attribute.Key
            };

            switch (attributeMetadata.AttributeType)
            {
            case Sdk.Metadata.AttributeTypeCode.Boolean:
            case Sdk.Metadata.AttributeTypeCode.DateTime:           // If need to convert to UTC may need to be isolated
            case Sdk.Metadata.AttributeTypeCode.Decimal:            // Precision should carry from initial value
            case Sdk.Metadata.AttributeTypeCode.Double:
            case Sdk.Metadata.AttributeTypeCode.Integer:
            case Sdk.Metadata.AttributeTypeCode.Memo:
            case Sdk.Metadata.AttributeTypeCode.String:
            case Sdk.Metadata.AttributeTypeCode.Uniqueidentifier:
                FieldNode.Value = attribute.Value.ToString();
                break;

            case Sdk.Metadata.AttributeTypeCode.Money:
                FieldNode.Value = ((Microsoft.Xrm.Sdk.Money)attribute.Value).Value.ToString();
                break;

            case Sdk.Metadata.AttributeTypeCode.Lookup:
            case Sdk.Metadata.AttributeTypeCode.Owner:
            case Sdk.Metadata.AttributeTypeCode.Customer:
                var EntityReference = (EntityReference)attribute.Value;
                FieldNode.Value            = EntityReference.Id.ToString();
                FieldNode.Lookupentity     = EntityReference.LogicalName;
                FieldNode.Lookupentityname = EntityReference.Name;
                break;

            case Sdk.Metadata.AttributeTypeCode.Picklist:
            case Sdk.Metadata.AttributeTypeCode.State:
            case Sdk.Metadata.AttributeTypeCode.Status:
                FieldNode.Value = ((OptionSetValue)attribute.Value).Value.ToString();
                break;

            case Sdk.Metadata.AttributeTypeCode.PartyList:
                FieldNode.Value            = String.Empty;
                FieldNode.Lookupentity     = String.Empty;
                FieldNode.Lookupentityname = String.Empty;
                var values = (EntityCollection)attribute.Value;
                FieldNode.Activitypointerrecords = new List <DataXml.Activitypointerrecords>();

                foreach (var entity in values.Entities)
                {
                    FieldNode.Activitypointerrecords.Add(GenerateActivitypointerNode(entity, builderEntityMetadata));
                }
                break;

            case Sdk.Metadata.AttributeTypeCode.CalendarRules:
            case Sdk.Metadata.AttributeTypeCode.Virtual:
            case Sdk.Metadata.AttributeTypeCode.BigInt:
            case Sdk.Metadata.AttributeTypeCode.ManagedProperty:
            case Sdk.Metadata.AttributeTypeCode.EntityName:
            default:
                throw new Exception(String.Format("GenerateFieldNode: Unknown Field Node Type - {0}", attributeMetadata.AttributeType));
            }

            return(FieldNode);
        }
        private static Entity GenerateEntityNode(string logicalName, BuilderEntityMetadata builderEntityMetadata)
        {
            SchemaXml.Entity entityNode = new SchemaXml.Entity()
            {
                Name             = logicalName,
                Displayname      = builderEntityMetadata.Metadata.DisplayName.LocalizedLabels[0].Label,
                Etc              = builderEntityMetadata.Metadata.ObjectTypeCode.ToString(),
                Primaryidfield   = builderEntityMetadata.Metadata.PrimaryIdAttribute,
                Primarynamefield = builderEntityMetadata.Metadata.PrimaryNameAttribute,
                Disableplugins   = (builderEntityMetadata.PluginsDisabled == null ||
                                    builderEntityMetadata.PluginsDisabled == false ? "false" : "true"),
                Skipupdate = (builderEntityMetadata.SkipUpdate == null ||
                              builderEntityMetadata.SkipUpdate == false ? "false" : "true"),
                Fields = new SchemaXml.Fields()
                {
                    Field = new List <SchemaXml.Field>()
                }
            };

            foreach (var attribute in builderEntityMetadata.Attributes)
            {
                var AttributeMetadata = builderEntityMetadata.Metadata.Attributes.Where(a => a.LogicalName == attribute).First();

                if (!IsSupportedAttributeType(AttributeMetadata.AttributeType))
                {
                    continue;
                }

                SchemaXml.Field field = new SchemaXml.Field()
                {
                    Displayname   = AttributeMetadata.DisplayName.LocalizedLabels[0].Label,
                    Name          = AttributeMetadata.LogicalName,
                    Type          = GetFieldNodeType(AttributeMetadata),
                    LookupType    = GetFieldNodeLookupType(AttributeMetadata),
                    UpdateCompare = (builderEntityMetadata.Identifiers.Contains(AttributeMetadata.LogicalName) ? "true" : null),
                    PrimaryKey    = (entityNode.Primaryidfield == AttributeMetadata.LogicalName ? "true" : null),
                    Customfield   = (AttributeMetadata.IsCustomAttribute == true ? "true" : null)
                };

                entityNode.Fields.Field.Add(field);
            }

            entityNode.Fields.Field.Sort((x, y) => string.Compare(x.Name, y.Name));

            if (builderEntityMetadata.RelatedEntities.Count > 0)
            {
                entityNode.Relationships = new SchemaXml.Relationships()
                {
                    Relationship = new List <SchemaXml.Relationship>()
                };

                foreach (var relationshipname in builderEntityMetadata.RelatedEntities.Keys)
                {
                    var relationshipMetadata = builderEntityMetadata.Metadata.ManyToManyRelationships.Where(x => x.IntersectEntityName == relationshipname).First();

                    string targetPrimaryKey = relationshipMetadata.Entity2IntersectAttribute;
                    if (relationshipMetadata.Entity1LogicalName == relationshipMetadata.Entity2LogicalName)
                    {
                        targetPrimaryKey = relationshipMetadata.Entity2IntersectAttribute.Substring(0, relationshipMetadata.Entity2IntersectAttribute.Length - 3);
                    }

                    entityNode.Relationships.Relationship.Add(new SchemaXml.Relationship()
                    {
                        Name                      = relationshipname,
                        ManyToMany                = "true",
                        Isreflexive               = (relationshipMetadata.Entity1LogicalName == relationshipMetadata.Entity2LogicalName).ToString().ToLower(),
                        RelatedEntityName         = relationshipMetadata.IntersectEntityName,
                        M2mTargetEntity           = relationshipMetadata.Entity2LogicalName,
                        M2mTargetEntityPrimaryKey = targetPrimaryKey
                    });
                }
            }

            return(entityNode);
        }