Пример #1
0
        object DoRetrieveEntities(object arg)
        {
            SendStepChange("Retrieving entities...");

            var entities = new List <EntityDefinition>();

            var queryComponents = new QueryExpression(SolutionComponent.EntityLogicalName);

            queryComponents.ColumnSet.AllColumns = true;
            queryComponents.Criteria.AddCondition("componenttype", ConditionOperator.Equal, (int)componenttype.Entity);

            var linkSolution = queryComponents.AddLink(Solution.EntityLogicalName, "solutionid", "solutionid");

            linkSolution.EntityAlias = "solution";
            linkSolution.Columns.AddColumn("uniquename");

            var linkPublisher = linkSolution.AddLink(Publisher.EntityLogicalName, "publisherid", "publisherid");

            linkPublisher.EntityAlias = "publisher";
            linkPublisher.Columns.AddColumn("customizationprefix");
            queryComponents.Criteria.AddCondition("solutionid", ConditionOperator.Equal, _solution.Id);

            var components = _service.RetrieveMultiple(queryComponents).Entities;

            var max     = components.Count;
            var current = 1;

            foreach (var component in components)
            {
                var entity = ((RetrieveEntityResponse)_service.Execute(new RetrieveEntityRequest {
                    MetadataId = component.GetAttributeValue <Guid>("objectid"), EntityFilters = EntityFilters.Entity | EntityFilters.Attributes | EntityFilters.Relationships
                })).EntityMetadata;

                var solutionName = component.GetAttributeValue <Microsoft.Xrm.Sdk.AliasedValue>("solution.uniquename").Value as string;
                Prefix = component.GetAttributeValue <Microsoft.Xrm.Sdk.AliasedValue>("publisher.customizationprefix").Value as string;

                var entityDefinition = new EntityDefinition
                {
                    LogicalName           = entity.LogicalName,
                    Name                  = RemovePrefix(entity.SchemaName).FormatText() + "Definition",
                    IsActivity            = entity.IsActivity.Value,
                    LogicalCollectionName = entity.LogicalCollectionName,
                    IsLoaded              = true
                };

                ClassDefinition keyDefinition = null;
                if (entity.Keys != null && entity.Keys.Any())
                {
                    keyDefinition = new ClassDefinition
                    {
                        LogicalName = "AlternateKeyNames",
                        Name        = "AlternateKeyNames"
                    };
                    entityDefinition.AdditionalClassesCollection.Add(keyDefinition);
                    foreach (var key in entity.Keys)
                    {
                        keyDefinition.Attributes.Add(new AttributeDefinition {
                            LogicalName = key.LogicalName, Name = key.DisplayName.UserLocalizedLabel.Label.FormatText(), Value = key.LogicalName, Type = "String"
                        });
                    }
                }

                if (entity.OneToManyRelationships.Any())
                {
                    var classDefinition = new ClassDefinition
                    {
                        LogicalName = "OneToManyRelationships",
                        Name        = "OneToManyRelationships"
                    };
                    entityDefinition.AdditionalClassesCollection.Add(classDefinition);
                    foreach (var relationship in entity.OneToManyRelationships)
                    {
                        var attribute = new RelationshipAttributeDefinition
                        {
                            LogicalName            = relationship.SchemaName,
                            Name                   = relationship.SchemaName,
                            Value                  = relationship.SchemaName,
                            Type                   = "String",
                            Role                   = EntityRole.Referenced,
                            NavigationPropertyName = relationship.ReferencedEntityNavigationPropertyName,
                            TargetEntityName       = relationship.ReferencingEntity,
                            LookupFieldName        = relationship.ReferencingAttribute
                        };

                        classDefinition.Attributes.Add(attribute);
                    }
                }

                if (entity.ManyToManyRelationships.Any())
                {
                    var classDefinition = new ClassDefinition
                    {
                        LogicalName = "ManyToManyRelationships",
                        Name        = "ManyToManyRelationships"
                    };
                    entityDefinition.AdditionalClassesCollection.Add(classDefinition);
                    foreach (var relationship in entity.ManyToManyRelationships)
                    {
                        classDefinition.Attributes.Add(new RelationshipAttributeDefinition {
                            LogicalName            = relationship.SchemaName,
                            Name                   = relationship.SchemaName,
                            Value                  = relationship.SchemaName,
                            Type                   = "String",
                            NavigationPropertyName = relationship.IntersectEntityName,
                            TargetEntityName       = relationship.Entity1LogicalName == entityDefinition.LogicalName ? relationship.Entity2LogicalName : relationship.Entity1LogicalName,
                            LookupFieldName        = relationship.Entity1LogicalName == entityDefinition.LogicalName ? relationship.Entity2IntersectAttribute : relationship.Entity1IntersectAttribute
                        });
                    }
                }

                var lookupFields = new Dictionary <string, List <OneToManyRelationshipMetadata> >();
                if (entity.ManyToOneRelationships.Any())
                {
                    ClassDefinition classDefinition = new ClassDefinition
                    {
                        LogicalName = "ManyToOneRelationships",
                        Name        = "ManyToOneRelationships"
                    };
                    entityDefinition.AdditionalClassesCollection.Add(classDefinition);
                    foreach (var relationship in entity.ManyToOneRelationships)
                    {
                        var attribute = new RelationshipAttributeDefinition
                        {
                            LogicalName            = relationship.SchemaName,
                            Name                   = relationship.SchemaName,
                            Value                  = relationship.SchemaName,
                            Type                   = "String",
                            Role                   = EntityRole.Referencing,
                            NavigationPropertyName = relationship.ReferencingEntityNavigationPropertyName,
                            TargetEntityName       = relationship.ReferencedEntity,
                            LookupFieldName        = relationship.ReferencingAttribute
                        };

                        classDefinition.Attributes.Add(attribute);

                        List <OneToManyRelationshipMetadata> list;

                        if (lookupFields.ContainsKey(relationship.ReferencingAttribute))
                        {
                            list = lookupFields[relationship.ReferencingAttribute];
                        }
                        else
                        {
                            list = new List <OneToManyRelationshipMetadata>();
                            lookupFields.Add(relationship.ReferencingAttribute, list);
                        }

                        list.Add(relationship);
                    }
                }

                SendStepChange(string.Format("({1}/{2}) Retrieved '{0}' entity", entity.LogicalName, current.ToString("00"), max.ToString("00")));
                current++;

                entities.Add(entityDefinition);

                foreach (AttributeMetadata attributeMetadata in entity.Attributes.OrderBy(a => a.LogicalName))
                {
                    if (!attributeMetadata.IsValidForCreate.Value && !attributeMetadata.IsValidForRead.Value && !attributeMetadata.IsValidForUpdate.Value)
                    {
                        continue;
                    }
                    if (attributeMetadata.AttributeType.Value == AttributeTypeCode.EntityName || !string.IsNullOrEmpty(attributeMetadata.AttributeOf))
                    {
                        continue;
                    }

                    EnumDefinition enumDefinition = null;

                    if (attributeMetadata.AttributeType.Value == AttributeTypeCode.Picklist || attributeMetadata.AttributeType.Value == AttributeTypeCode.State || attributeMetadata.AttributeType.Value == AttributeTypeCode.Status)
                    {
                        var meta = ((EnumAttributeMetadata)attributeMetadata).OptionSet;

                        var enumLogicalName = meta.IsGlobal.Value ? meta.Name : entity.LogicalName + "_" + attributeMetadata.LogicalName;

                        var tempEnumDefinition = new EnumDefinition
                        {
                            LogicalName  = enumLogicalName,
                            IsGlobal     = meta.IsGlobal.Value,
                            HasNullValue = attributeMetadata.AttributeType.Value == AttributeTypeCode.Picklist && meta.Options.All(option => option.Value.GetValueOrDefault() != 0)
                        };

                        if (attributeMetadata.AttributeType.Value == AttributeTypeCode.State)
                        {
                            tempEnumDefinition.Name = entityDefinition.Name.Replace("Definition", "") + "State";
                        }
                        else if (attributeMetadata.AttributeType.Value == AttributeTypeCode.Status)
                        {
                            tempEnumDefinition.Name = entityDefinition.Name.Replace("Definition", "") + "Status";
                        }
                        else
                        {
                            tempEnumDefinition.Name = meta.DisplayName.UserLocalizedLabel.Label.FormatText();
                        }

                        foreach (var option in meta.Options)
                        {
                            if (option.Label.UserLocalizedLabel == null)
                            {
                                continue;
                            }
                            tempEnumDefinition.Values.Add(new EnumValueDefinition
                            {
                                Name        = option.Label.UserLocalizedLabel.Label.FormatText(),
                                LogicalName = option.Value.Value.ToString(),
                                DisplayName = option.Label.UserLocalizedLabel.Label,
                                Value       = option.Value.Value.ToString()
                            });
                        }

                        if (!EnumDefinitionCollection.Instance.Contains(enumLogicalName))
                        {
                            enumDefinition = tempEnumDefinition;
                            EnumDefinitionCollection.Instance.Add(enumDefinition);
                        }
                        else
                        {
                            enumDefinition = EnumDefinitionCollection.Instance[enumLogicalName];
                            enumDefinition.Merge(tempEnumDefinition);
                        }
                    }

                    var name = RemovePrefix(attributeMetadata.SchemaName);

                    if (attributeMetadata.LogicalName == entity.PrimaryIdAttribute)
                    {
                        name = "Id";
                    }

                    int?   maxLength = null;
                    double?minRangeDouble = null, maxRangeDouble = null;

                    switch (attributeMetadata.AttributeType.Value)
                    {
                    case AttributeTypeCode.String:
                        maxLength = ((StringAttributeMetadata)attributeMetadata).MaxLength;
                        break;

                    case AttributeTypeCode.Memo:
                        maxLength = ((MemoAttributeMetadata)attributeMetadata).MaxLength;
                        break;

                    case AttributeTypeCode.Money:
                        var m = (MoneyAttributeMetadata)attributeMetadata;
                        minRangeDouble = m.MinValue;
                        maxRangeDouble = m.MaxValue;
                        break;

                    case AttributeTypeCode.Integer:
                        var mi = (IntegerAttributeMetadata)attributeMetadata;
                        minRangeDouble = mi.MinValue;
                        maxRangeDouble = mi.MaxValue;
                        break;

                    case AttributeTypeCode.Double:
                        var md = (DoubleAttributeMetadata)attributeMetadata;
                        minRangeDouble = md.MinValue;
                        maxRangeDouble = md.MaxValue;
                        break;

                    case AttributeTypeCode.Decimal:
                        var mde = (DecimalAttributeMetadata)attributeMetadata;
                        minRangeDouble = (double?)mde.MinValue;
                        maxRangeDouble = (double?)mde.MaxValue;
                        break;
                    }

                    var attributeDefinition = new AttributeDefinition
                    {
                        LogicalName             = attributeMetadata.LogicalName,
                        Name                    = name,
                        DisplayName             = attributeMetadata.DisplayName.UserLocalizedLabel == null ? attributeMetadata.SchemaName : attributeMetadata.DisplayName.UserLocalizedLabel.Label,
                        IsValidForAdvancedFind  = attributeMetadata.IsValidForAdvancedFind.Value,
                        IsValidForCreate        = attributeMetadata.IsValidForCreate.Value,
                        IsValidForRead          = attributeMetadata.IsValidForRead.Value,
                        IsValidForUpdate        = attributeMetadata.IsValidForUpdate.Value,
                        Type                    = attributeMetadata.AttributeType.Value.ToString(),
                        Enum                    = enumDefinition,
                        ParentEntity            = entityDefinition,
                        IsPrimaryIdAttribute    = attributeMetadata.LogicalName == entity.PrimaryIdAttribute,
                        IsPrimaryNameAttribute  = attributeMetadata.LogicalName == entity.PrimaryNameAttribute,
                        IsPrimaryImageAttribute = attributeMetadata.LogicalName == entity.PrimaryImageAttribute,
                        Relationships           = lookupFields.ContainsKey(attributeMetadata.LogicalName) ? lookupFields[attributeMetadata.LogicalName] : null,
                        StringMaxLength         = maxLength,
                        MinRange                = minRangeDouble,
                        MaxRange                = maxRangeDouble
                    };

                    if (attributeMetadata.AttributeType == AttributeTypeCode.DateTime)
                    {
                        var meta = (DateTimeAttributeMetadata)attributeMetadata;

                        attributeDefinition.DateTimeBehavior = meta.DateTimeBehavior;
                    }

                    if (attributeMetadata.LogicalName == "ownerid")
                    {
                        attributeDefinition.Relationships.Clear();
                        if (lookupFields.ContainsKey("owninguser"))
                        {
                            attributeDefinition.Relationships.Add(new OneToManyRelationshipMetadata
                            {
                                ReferencingAttribute = "ownerid",
                                ReferencedAttribute  = "systemuserid",
                                ReferencedEntity     = "systemuser",
                                ReferencingEntity    = entityDefinition.LogicalName,
                                SchemaName           = lookupFields["owninguser"].First().SchemaName
                            });
                        }
                        if (lookupFields.ContainsKey("owningteam"))
                        {
                            attributeDefinition.Relationships.Add(new OneToManyRelationshipMetadata
                            {
                                ReferencingAttribute = "ownerid",
                                ReferencedAttribute  = "teamid",
                                ReferencedEntity     = "team",
                                ReferencingEntity    = entityDefinition.LogicalName,
                                SchemaName           = lookupFields["owningteam"].First().SchemaName
                            });
                        }
                    }

                    if (keyDefinition != null)
                    {
                        foreach (var key in entity.Keys.Where(k => k.KeyAttributes.Contains(attributeDefinition.LogicalName)))
                        {
                            attributeDefinition.KeyNames.Add(keyDefinition.Attributes[key.LogicalName].Name);
                        }
                    }

                    if (attributeDefinition.IsPrimaryIdAttribute || attributeDefinition.IsPrimaryNameAttribute || attributeDefinition.IsPrimaryImageAttribute || attributeDefinition.KeyNames.Any())
                    {
                        attributeDefinition.IsSelected = true;
                    }

                    entityDefinition.AttributesCollection.Add(attributeDefinition);
                }
            }
            SendStepChange(string.Empty);
            return(entities);
        }
Пример #2
0
 internal void Add(AttributeDefinition attributeDefinition)
 {
     _attributes.Add(attributeDefinition);
 }
Пример #3
0
        public void UnRegister(AttributeDefinition definition)
        {
            _referencingAttributes.Remove(definition);

            OnPropertyChanged("IsSelected");
        }