public object ResolveEntityPropertyValue(string rawValue, Type propertyType)
        {
            Type genericParameterType = propertyType.GetGenericArguments()[0];

            if (rawValue.IsNullOrEmpty())
            {
                return(CreateEmptyTypedList(genericParameterType));
            }

            return(CreateLazyList(genericParameterType, () => {
                IList list = CreateEmptyTypedList(genericParameterType);
                var delimiter = new[] { Settings.ValueDelimiter };
                string[] itemIds = rawValue.Split(delimiter, StringSplitOptions.RemoveEmptyEntries);

                IMap listTypeMap = MapFinder.FindMap(genericParameterType);
                foreach (
                    ISitecoreDomainEntity entity in
                    m_repository.GetEntities(itemIds.Select(itemId => new Guid(itemId)),
                                             listTypeMap))
                {
                    list.Add(entity);
                }
                return list;
            }));
        }
        private static string GetFieldName <TPropertyType>(Expression <Func <TDomainEntity, TPropertyType> > expression)
        {
            PropertyInfo propertyInfo = GetPropertyInfo(expression);

            Map <TDomainEntity> map = MapFinder.FindMap <TDomainEntity>();

            MapEntry mapEntry = map.Mappings.Single(x => x.MappedProperty.Name == propertyInfo.Name);

            return(mapEntry.MappedTo);
        }
        public object Resolve(Item item)
        {
            var genericParameterType = GetType().GetGenericArguments()[0];

            return(CreateLazyList(genericParameterType, () =>
            {
                var repository = new ReadOnlyRepository();
                var map = MapFinder.FindMap(genericParameterType);
                var list = CreateEmptyTypedList(genericParameterType);
                ProcessChildren(item, map, repository, list);
                return list;
            }));
        }
        public IList <TDomainEntity> Get <TDomainEntity>(IEnumerable <Guid> ids)
            where TDomainEntity : ISitecoreDomainEntity
        {
            IMap     map      = MapFinder.FindMap <TDomainEntity>();
            Template template = GetTemplate(map);

            var results = new List <TDomainEntity>();

            foreach (Guid id in ids)
            {
                Item item = GetItem(id);
                if (item != null && item.DescendsFromTemplate(template))
                {
                    results.Add((TDomainEntity)ParseItem(item, map));
                }
            }

            return(results);
        }
Exemple #5
0
        public object Resolve(Item item)
        {
            Type genericParameterType = GetType().GetGenericArguments()[0];

            return(CreateLazyList(genericParameterType, () =>
            {
                var repository = new ReadOnlyRepository();
                IMap map = MapFinder.FindMap(genericParameterType);
                IList list = CreateEmptyTypedList(genericParameterType);
                foreach (Item child in item.Children)
                {
                    if (child.DescendsFromTemplate(map.TemplatePath))
                    {
                        var entity = repository.Get <TChild>(child);
                        list.Add(entity);
                    }
                }
                return list;
            }));
        }