Ejemplo n.º 1
0
        /// <summary>
        /// возвращает словарь куда входят все Field входящие в продукты и hashset их родительских Field или null если данный Field в корневом Article продукта
        /// </summary>
        /// <param name="definitions"></param>
        /// <returns></returns>
        private DefinitionsFields GetDefinitionsFields(IEnumerable <Content> definitions)
        {
            var definitionsFields = new DefinitionsFields();

            foreach (var definition in definitions)
            {
                FillDefinitionsFields(definitionsFields, definition, new Field[] { }, definition.ContentId);
            }

            return(definitionsFields);
        }
Ejemplo n.º 2
0
        private void FillDefinitionsFields(DefinitionsFields definitionsFields, Content definition, Field[] parentFields, int rootContentId)
        {
            if (definition.LoadAllPlainFields)
            {
                if (!definitionsFields.ContentIdsDependentOfAllPlainFields.ContainsKey(definition.ContentId))
                {
                    definitionsFields.ContentIdsDependentOfAllPlainFields[definition.ContentId] = new List <PathToRootContent>();
                }

                definitionsFields.ContentIdsDependentOfAllPlainFields[definition.ContentId].Add(new PathToRootContent(rootContentId, parentFields));
            }

            foreach (var field in definition.Fields)
            {
                if (field is BackwardRelationField)
                {
                    if (!definitionsFields.MonitoredBackwardRelationFields.ContainsKey(field.FieldId))
                    {
                        definitionsFields.MonitoredBackwardRelationFields[field.FieldId] = new List <PathToRootContent>();
                    }

                    definitionsFields.MonitoredBackwardRelationFields[field.FieldId].Add(new PathToRootContent(rootContentId, parentFields));
                }
                else
                {
                    if (!definitionsFields.MonitoredFieldIds.ContainsKey(field.FieldId))
                    {
                        definitionsFields.MonitoredFieldIds[field.FieldId] = new List <PathToRootContent>();
                    }

                    definitionsFields.MonitoredFieldIds[field.FieldId].Add(new PathToRootContent(rootContentId, parentFields));
                }

                var childDefinitionParentFields = new[] { field }.Concat(parentFields).ToArray();

                if (field is BackwardRelationField)
                {
                    FillDefinitionsFields(definitionsFields, ((BackwardRelationField)field).Content, childDefinitionParentFields, rootContentId);
                }
                else
                if (field is EntityField)
                {
                    FillDefinitionsFields(definitionsFields, ((EntityField)field).Content, childDefinitionParentFields, rootContentId);
                }
                else if (field is ExtensionField)
                {
                    foreach (var extFieldDefinition in ((ExtensionField)field).ContentMapping.Select(x => x.Value))
                    {
                        FillDefinitionsFields(definitionsFields, extFieldDefinition, childDefinitionParentFields, rootContentId);
                    }
                }
            }
        }