internal static MappingEntity GetMappingEntity(EntityMetadata entityMetadata, string serverStamp,
                                                       MappingEntity entity, bool isTitleCaseLogicalName)
        {
            entity = entity ?? new MappingEntity();

            entity.MetadataId  = entityMetadata.MetadataId;
            entity.ServerStamp = serverStamp;

            entity.Attribute             = entity.Attribute ?? new CrmEntityAttribute();
            entity.TypeCode              = entityMetadata.ObjectTypeCode ?? entity.TypeCode;
            entity.Attribute.LogicalName = entityMetadata.LogicalName ?? entity.Attribute.LogicalName;
            entity.IsIntersect           = (entityMetadata.IsIntersect ?? entity.IsIntersect);
            entity.Attribute.PrimaryKey  = entityMetadata.PrimaryIdAttribute ?? entity.Attribute.PrimaryKey;

            if (entityMetadata.DisplayName?.UserLocalizedLabel != null)
            {
                entity.Label = entityMetadata.DisplayName.UserLocalizedLabel.Label;
            }

            if (entityMetadata.SchemaName != null)
            {
                entity.DisplayName = Naming.GetProperEntityName(entityMetadata.SchemaName);
                entity.SchemaName  = entityMetadata.SchemaName;

                if (entityMetadata.LogicalName != null)
                {
                    entity.HybridName = Naming.GetProperHybridName(entityMetadata.SchemaName, entityMetadata.LogicalName);
                }
            }

            entity.StateName = entity.HybridName + "State";

            if (entityMetadata.Description?.UserLocalizedLabel != null)
            {
                entity.Description = entityMetadata.Description.UserLocalizedLabel.Label;
            }

            var fields = (entity.Fields ?? new MappingField[0]).ToList();

            ////if (entityMetadata.Attributes != null)
            ////{

            var validFields = entityMetadata.Attributes
                              .Where(a => a.AttributeOf == null || a is ImageAttributeMetadata).ToArray();

            foreach (var field in validFields)
            {
                var existingField = fields.FirstOrDefault(fieldQ => fieldQ.MetadataId == field.MetadataId);

                // if it exists, remove it from the list
                if (existingField != null)
                {
                    fields.RemoveAll(fieldQ => fieldQ.MetadataId == field.MetadataId);
                }

                // update/create and add to list
                fields.Add(MappingField.GetMappingField(field, entity, existingField, isTitleCaseLogicalName));
            }

            fields.ForEach(
                f =>
            {
                if (f.DisplayName == entity.DisplayName)
                {
                    f.DisplayName += "1";
                }

                if (f.HybridName == entity.HybridName)
                {
                    f.HybridName += "1";
                }
            });

            AddImages(fields);
            AddLookupFields(fields);

            entity.Fields = fields.ToArray();

            // get the states enum from the metadata
            entity.States =
                entityMetadata.Attributes
                .Where(a => a is StateAttributeMetadata && a.AttributeOf == null)
                .Select(a => MappingEnum
                        .GetMappingEnum(a as EnumAttributeMetadata, null, isTitleCaseLogicalName))
                .FirstOrDefault() ?? entity.States;

            // get all optionsets from the metadata
            var newEnums = entityMetadata.Attributes
                           .Where(a => (a is EnumAttributeMetadata || a is BooleanAttributeMetadata) && a.AttributeOf == null);

            // if there was never any enums previously, then just take the ones sent
            if (entity.Enums == null)
            {
                entity.Enums = newEnums
                               .Select(newEnum => MappingEnum.GetMappingEnum(newEnum, null, isTitleCaseLogicalName))
                               .ToArray();
            }
            else
            {
                var existingEnums = entity.Enums.ToList();

                // else, update the changed ones
                newEnums.AsParallel()
                .ForAll(newEnum =>
                {
                    // has this enum been updated?
                    var existingEnum = existingEnums
                                       .Find(existingEnumQ => existingEnumQ.MetadataId == newEnum.MetadataId);

                    if (existingEnum != null)
                    {
                        // update it here
                        entity.Enums[existingEnums.IndexOf(existingEnum)] =
                            MappingEnum.GetMappingEnum(newEnum, existingEnum, isTitleCaseLogicalName);
                    }
                    else
                    {
                        // add new
                        existingEnums.Add(MappingEnum.GetMappingEnum(newEnum, null, isTitleCaseLogicalName));
                    }
                });

                entity.Enums = existingEnums.ToArray();
            }
            ////}

            entity.PrimaryKey           = entity.Fields.FirstOrDefault(f => f.Attribute.LogicalName == entity.Attribute.PrimaryKey);
            entity.PrimaryKeyProperty   = entity.PrimaryKey?.DisplayName;
            entity.PrimaryNameAttribute = entityMetadata.PrimaryNameAttribute ?? entity.PrimaryNameAttribute;

            if (entityMetadata.Keys?.Any(e => e.KeyAttributes?.Any() == true) == true)
            {
                entity.AlternateKeys = entityMetadata.Keys.SelectMany(e => e.KeyAttributes).ToArray();
            }

            if (entityMetadata.OneToManyRelationships != null)
            {
                MappingRelationship1N.UpdateCache(entityMetadata.OneToManyRelationships.ToList(), entity, entity.Fields);
            }

            if (entityMetadata.OneToManyRelationships != null)
            {
                MappingRelationshipN1.UpdateCache(entityMetadata.ManyToOneRelationships.ToList(), entity, entity.Fields);
            }

            if (entityMetadata.OneToManyRelationships != null)
            {
                MappingRelationshipMN.UpdateCache(entityMetadata.ManyToManyRelationships.ToList(), entity, entity.LogicalName);

                // add a clone for self-referenced relation
                var relationshipsManyToMany = entity.RelationshipsManyToMany.ToList();
                var selfReferenced          = relationshipsManyToMany.Where(r => r.IsSelfReferenced).ToList();

                foreach (var referenced in selfReferenced)
                {
                    if (relationshipsManyToMany.All(rel => rel.DisplayName
                                                    != "Referencing" + Naming.GetProperVariableName(referenced.SchemaName, false)))
                    {
                        var referencing = (MappingRelationshipMN)referenced.Clone();
                        referencing.DisplayName = "Referencing" + Naming.GetProperVariableName(referenced.SchemaName, false);
                        referencing.EntityRole  = "Microsoft.Xrm.Sdk.EntityRole.Referencing";
                        relationshipsManyToMany.Add(referencing);
                    }
                }

                entity.RelationshipsManyToMany = relationshipsManyToMany.OrderBy(r => r.DisplayName).ToArray();
            }

            entity.FriendlyName = Naming.Clean(string.IsNullOrEmpty(entity.Label)
                                ? Naming.Clean(entity.HybridName)
                                : Naming.Clean(entity.Label));

            // generate attribute friendly names and detect duplicates
            entity.Fields.AsParallel()
            .ForAll(field =>
            {
                var cleanFieldName =
                    Naming.Clean(
                        string.IsNullOrEmpty(field.Label)
                                                                                ? Naming.Clean(field.DisplayName)
                                                                                : Naming.Clean(field.Label))
                    + (field == entity.PrimaryKey ? "Id" : "");

                var isDuplicateName = entity.Fields
                                      .Count(fieldQ => Naming.Clean(
                                                 string.IsNullOrEmpty(fieldQ.Label)
                                                                                ? Naming.Clean(fieldQ.DisplayName)
                                                                                : Naming.Clean(fieldQ.Label))
                                             == cleanFieldName) > 1;

                isDuplicateName =
                    isDuplicateName ||
                    cleanFieldName == "Attributes" ||
                    cleanFieldName == entity.FriendlyName ||
                    cleanFieldName == "LogicalName" ||
                    cleanFieldName == "EntityLogicalName" ||
                    cleanFieldName == "SchemaName" ||
                    cleanFieldName == "DisplayName" ||
                    cleanFieldName == "EntityTypeCode";

                field.FriendlyName = cleanFieldName +
                                     (isDuplicateName ? "_" + field.DisplayName : "");
            });

            // generate enum friendly names
            entity.Enums.AsParallel()
            .ForAll(enm =>
            {
                var attribute    = entity.Fields.FirstOrDefault(field => field.LogicalName == enm.LogicalName);
                enm.FriendlyName = attribute == null ? enm.DisplayName : attribute.FriendlyName;
            });

            return(entity);
        }
        public static MappingEnum GetMappingEnum(AttributeMetadata picklist, MappingEnum mappingEnum, bool isTitleCaseLogicalName)
        {
            mappingEnum = mappingEnum
                          ?? new MappingEnum
            {
                MetadataId = picklist.MetadataId
            };

            if (picklist.SchemaName != null)
            {
                mappingEnum.DisplayName = Naming.GetProperVariableName(picklist, isTitleCaseLogicalName);
            }

            mappingEnum.LogicalName = picklist.LogicalName ?? mappingEnum.LogicalName;
            mappingEnum.Items       = new MapperEnumItem[0];

            var attributeAsEnum = picklist as EnumAttributeMetadata;

            if (attributeAsEnum?.OptionSet != null && attributeAsEnum.OptionSet.Options.Count > 0)
            {
                var newItems = new List <MapperEnumItem>();

                newItems.AddRange(attributeAsEnum.OptionSet.Options
                                  .Where(o => o.Label.UserLocalizedLabel != null)
                                  .Select(e => GetEnumItem(e, isTitleCaseLogicalName)));

                mappingEnum.Items = newItems.ToArray();
            }
            else
            {
                var attributeAsBool = picklist as BooleanAttributeMetadata;

                if (attributeAsBool?.OptionSet != null)
                {
                    var newItems = new List <MapperEnumItem>();

                    var trueOption = attributeAsBool.OptionSet.TrueOption;

                    if (trueOption.Label.UserLocalizedLabel != null)
                    {
                        newItems.Add(GetEnumItem(trueOption, isTitleCaseLogicalName));
                    }

                    var falseOption = attributeAsBool.OptionSet.FalseOption;

                    if (falseOption.Label.UserLocalizedLabel != null)
                    {
                        newItems.Add(GetEnumItem(falseOption, isTitleCaseLogicalName));
                    }

                    mappingEnum.Items = newItems.ToArray();
                }
            }

            var duplicates = new Dictionary <string, int>();

            foreach (var item in mappingEnum.Items)
            {
                if (duplicates.ContainsKey(item.Name))
                {
                    duplicates[item.Name] = duplicates[item.Name] + 1;
                    item.Name            += "_" + duplicates[item.Name];
                }
                else
                {
                    duplicates[item.Name] = 1;
                }
            }

            mappingEnum.IsMultiSelect = picklist is MultiSelectPicklistAttributeMetadata;

            return(mappingEnum);
        }
예제 #3
0
        public static MappingField GetMappingField(AttributeMetadata attribute, MappingEntity entity,
                                                   MappingField result, bool isTitleCaseLogicalName)
        {
            result = result ?? new MappingField();

            result.Entity           = entity;
            result.MetadataId       = attribute.MetadataId;
            result.LogicalName      = attribute.LogicalName ?? result.LogicalName;
            result.AttributeOf      = attribute.AttributeOf ?? result.AttributeOf;
            result.IsValidForCreate = attribute.IsValidForCreate ?? result.IsValidForCreate;
            result.IsValidForRead   = attribute.IsValidForRead ?? result.IsValidForRead;
            result.IsValidForUpdate = attribute.IsValidForUpdate ?? result.IsValidForUpdate;

            if (attribute.AttributeType != null)
            {
                result.FieldType       = attribute.AttributeType.Value;
                result.IsActivityParty = attribute.AttributeType == AttributeTypeCode.PartyList;
                result.IsStateCode     = attribute.AttributeType == AttributeTypeCode.State;
            }

            result.DeprecatedVersion = attribute.DeprecatedVersion ?? result.DeprecatedVersion;

            if (attribute.DeprecatedVersion != null)
            {
                result.IsDeprecated = !string.IsNullOrWhiteSpace(attribute.DeprecatedVersion);
            }

            if (attribute is EnumAttributeMetadata || attribute is BooleanAttributeMetadata)
            {
                result.EnumData = MappingEnum.GetMappingEnum(attribute, result.EnumData, isTitleCaseLogicalName);
            }

            if (attribute is LookupAttributeMetadata lookup)
            {
                result.LookupData = new MappingLookup();

                if (lookup.Targets?.Length == 1)
                {
                    result.LookupData.LookupSingleType = lookup.Targets[0];
                }
            }

            ParseDateTime(attribute, result);
            ParseMinMaxValues(attribute, result);
            ParseImageValues(attribute, result);

            result.IsPrimaryKey = attribute.IsPrimaryId ?? result.IsPrimaryKey;

            if (attribute.SchemaName != null)
            {
                result.SchemaName = attribute.SchemaName ?? result.SchemaName;

                if (attribute.LogicalName != null)
                {
                    result.DisplayName = Naming.GetProperVariableName(attribute, isTitleCaseLogicalName);
                }

                result.PrivatePropertyName = Naming.GetEntityPropertyPrivateName(attribute.SchemaName);
            }

            result.HybridName = Naming.GetProperHybridFieldName(result.DisplayName, result.Attribute);

            if (attribute.Description?.UserLocalizedLabel != null)
            {
                result.Description = attribute.Description.UserLocalizedLabel.Label;
            }

            if (attribute.DisplayName != null)
            {
                if (attribute.DisplayName.LocalizedLabels != null)
                {
                    result.LocalizedLabels = attribute.DisplayName.LocalizedLabels
                                             .Select(label =>
                                                     new LocalizedLabelSerialisable
                    {
                        LanguageCode = label.LanguageCode,
                        Label        = label.Label
                    }).ToArray();
                }

                if (attribute.DisplayName.UserLocalizedLabel != null)
                {
                    result.Label = attribute.DisplayName.UserLocalizedLabel.Label;
                }
            }

            if (attribute.RequiredLevel != null)
            {
                result.IsRequired = attribute.RequiredLevel.Value == AttributeRequiredLevel.ApplicationRequired;
            }

            if (attribute.AttributeType != null)
            {
                result.Attribute =
                    new CrmPropertyAttribute
                {
                    LogicalName = attribute.LogicalName,
                    IsLookup    = attribute.AttributeType == AttributeTypeCode.Lookup ||
                                  attribute.AttributeType == AttributeTypeCode.Owner ||
                                  attribute.AttributeType == AttributeTypeCode.Customer,
                    IsImage = attribute is ImageAttributeMetadata
                };
                result.Attribute.IsMultiTyped = result.Attribute.IsLookup && result.LookupData?.LookupSingleType.IsEmpty() == true;
            }

            result.TargetTypeForCrmSvcUtil = GetTargetType(result);
            result.FieldTypeString         = result.TargetTypeForCrmSvcUtil;

            return(result);
        }