public void Init() {
            var builder = new ContainerBuilder();
            builder.RegisterType<InfosetStorageProvider>().As<IFieldStorageProvider>();

            _container = builder.Build();
            _provider = _container.Resolve<IFieldStorageProvider>();
        }
        public void Init()
        {
            var builder = new ContainerBuilder();

            builder.RegisterType <InfosetStorageProvider>().As <IFieldStorageProvider>();

            _container = builder.Build();
            _provider  = _container.Resolve <IFieldStorageProvider>();
        }
Example #3
0
        public IFieldStorageProvider GetProvider(ContentPartFieldDefinition partFieldDefinition) {

            IFieldStorageProvider provider = null;

            string storage;
            if (partFieldDefinition.Settings.TryGetValue(Storage, out storage))
                provider = Locate(storage);

            return provider ?? Locate(DefaultProviderName);
        }
        public FieldIndexPartHandler(
            IContentDefinitionManager contentDefinitionManager,
            IRepository<FieldIndexPartRecord> repository,
            IFieldIndexService fieldIndexService,
            IFieldStorageProvider fieldStorageProvider,
            IEnumerable<IContentFieldDriver> contentFieldDrivers) {
            Filters.Add(StorageFilter.For(repository));
            _contentDefinitionManager = contentDefinitionManager;
            _fieldIndexService = fieldIndexService;
            _fieldStorageProvider = fieldStorageProvider;
            _contentFieldDrivers = contentFieldDrivers;

            OnPublishing<FieldIndexPart>(Publishing);
        }
        public override void Init()
        {
            base.Init();

            _fieldIndexService = _container.Resolve <IFieldIndexService>();
            _contentManager    = _container.Resolve <IContentManager>();
            _provider          = _container.Resolve <IFieldStorageProvider>();
            _events            = _container.Resolve <IEnumerable <IFieldStorageEvents> >();

            _part = CreateContentItemPart();
            var partFieldDefinition = _part.PartDefinition.Fields.Single();
            var storage             = _provider.BindStorage(_part, partFieldDefinition);

            _storage = new FieldStorageEventStorage(storage, partFieldDefinition, _part, _events);
        }
 public FieldIndexPartHandler(
     IContentDefinitionManager contentDefinitionManager,
     IRepository <FieldIndexPartRecord> repository,
     IFieldIndexService fieldIndexService,
     IFieldStorageProvider fieldStorageProvider,
     IEnumerable <IContentFieldDriver> contentFieldDrivers)
 {
     Filters.Add(StorageFilter.For(repository));
     _contentDefinitionManager = contentDefinitionManager;
     _fieldIndexService        = fieldIndexService;
     _fieldStorageProvider     = fieldStorageProvider;
     _contentFieldDrivers      = contentFieldDrivers;
     OnUpdated <FieldIndexPart>(Updated);
     OnPublishing <FieldIndexPart>(Publishing);
 }
        public InfosetFieldIndexingHandler(
            IEnumerable<IContentFieldDriver> contentFieldDrivers,
            IFieldStorageProvider fieldStorageProvider) {
            
            _contentFieldDrivers = contentFieldDrivers;
            _fieldStorageProvider = fieldStorageProvider;

            OnIndexing<InfosetPart>(
                (context, cp) => {
                    var infosetPart = context.ContentItem.As<InfosetPart>();
                    if (infosetPart == null) {
                        return;
                    }


                    // part fields
                    foreach ( var part in infosetPart.ContentItem.Parts ) {
                        foreach ( var field in part.PartDefinition.Fields ) {
                            if (!field.Settings.GetModel<FieldIndexing>().Included) {
                                continue;
                            }

                            // get all drivers for the current field type
                            // the driver will describe what values of the field should be indexed
                            var drivers = _contentFieldDrivers.Where(x => x.GetFieldInfo().Any(fi => fi.FieldTypeName == field.FieldDefinition.Name)).ToList();

                            ContentPart localPart = part;
                            ContentPartFieldDefinition localField = field;
                            var membersContext = new DescribeMembersContext(
                                (storageName, storageType, displayName, description) =>
                                {
                                    var fieldStorage = _fieldStorageProvider.BindStorage(localPart, localField);

                                    // fieldStorage.Get<T>(storageName)
                                    var getter = typeof(IFieldStorage).GetMethod("Get").MakeGenericMethod(storageType);
                                    var fieldValue = getter.Invoke(fieldStorage, new[] { storageName });
                                    var indexName = String.Format("{0}-{1}", infosetPart.TypeDefinition.Name.ToLower(), field.Name.ToLower());

                                    TypeCode typeCode = Type.GetTypeCode(storageType);
                                    switch (typeCode)
                                    {
                                        case TypeCode.Empty:
                                        case TypeCode.Object:
                                        case TypeCode.DBNull:
                                        case TypeCode.String:
                                        case TypeCode.Char:
                                            context.DocumentIndex.Add(indexName, fieldValue.ToString()).RemoveTags().Analyze();
                                            break;
                                        case TypeCode.Boolean:
                                            context.DocumentIndex.Add(indexName, Convert.ToBoolean(fieldValue));
                                            break;
                                        case TypeCode.SByte:
                                        case TypeCode.Int16:
                                        case TypeCode.UInt16:
                                        case TypeCode.Int32:
                                        case TypeCode.UInt32:
                                        case TypeCode.Int64:
                                        case TypeCode.UInt64:
                                            context.DocumentIndex.Add(indexName, Convert.ToInt32(fieldValue));
                                            break;
                                        case TypeCode.Single:
                                        case TypeCode.Double:
                                        case TypeCode.Decimal:
                                            context.DocumentIndex.Add(indexName, Convert.ToDouble(fieldValue));
                                            break;
                                        case TypeCode.DateTime:
                                            context.DocumentIndex.Add(indexName, Convert.ToDateTime(fieldValue));
                                            break;
                                    }

                                });

                            foreach (var driver in drivers) {
                                driver.Describe(membersContext);
                            }
                        }
                    }
                });
        }
        public InfosetFieldIndexingHandler(
            IEnumerable <IContentFieldDriver> contentFieldDrivers,
            IFieldStorageProvider fieldStorageProvider)
        {
            _contentFieldDrivers  = contentFieldDrivers;
            _fieldStorageProvider = fieldStorageProvider;

            OnIndexing <InfosetPart>(
                (context, cp) => {
                var infosetPart = context.ContentItem.As <InfosetPart>();
                if (infosetPart == null)
                {
                    return;
                }


                // part fields
                foreach (var part in infosetPart.ContentItem.Parts)
                {
                    foreach (var field in part.PartDefinition.Fields)
                    {
                        if (!field.Settings.GetModel <FieldIndexing>().Included)
                        {
                            continue;
                        }

                        // get all drivers for the current field type
                        // the driver will describe what values of the field should be indexed
                        var drivers = _contentFieldDrivers.Where(x => x.GetFieldInfo().Any(fi => fi.FieldTypeName == field.FieldDefinition.Name)).ToList();

                        ContentPart localPart = part;
                        ContentPartFieldDefinition localField = field;
                        var membersContext = new DescribeMembersContext(
                            (storageName, storageType, displayName, description) =>
                        {
                            var fieldStorage = _fieldStorageProvider.BindStorage(localPart, localField);

                            // fieldStorage.Get<T>(storageName)
                            var getter     = typeof(IFieldStorage).GetMethod("Get").MakeGenericMethod(storageType);
                            var fieldValue = getter.Invoke(fieldStorage, new[] { storageName });
                            var indexName  = String.Format("{0}-{1}", infosetPart.TypeDefinition.Name.ToLower(), field.Name.ToLower());

                            TypeCode typeCode = Type.GetTypeCode(storageType);
                            switch (typeCode)
                            {
                            case TypeCode.Empty:
                            case TypeCode.Object:
                            case TypeCode.DBNull:
                            case TypeCode.String:
                            case TypeCode.Char:
                                context.DocumentIndex.Add(indexName, fieldValue.ToString()).RemoveTags().Analyze();
                                break;

                            case TypeCode.Boolean:
                                context.DocumentIndex.Add(indexName, Convert.ToBoolean(fieldValue));
                                break;

                            case TypeCode.SByte:
                            case TypeCode.Int16:
                            case TypeCode.UInt16:
                            case TypeCode.Int32:
                            case TypeCode.UInt32:
                            case TypeCode.Int64:
                            case TypeCode.UInt64:
                                context.DocumentIndex.Add(indexName, Convert.ToInt32(fieldValue));
                                break;

                            case TypeCode.Single:
                            case TypeCode.Double:
                            case TypeCode.Decimal:
                                context.DocumentIndex.Add(indexName, Convert.ToDouble(fieldValue));
                                break;

                            case TypeCode.DateTime:
                                context.DocumentIndex.Add(indexName, Convert.ToDateTime(fieldValue));
                                break;
                            }
                        });

                        foreach (var driver in drivers)
                        {
                            driver.Describe(membersContext);
                        }
                    }
                }
            });
        }
        public InfosetFieldIndexingHandler(
            IEnumerable<IContentFieldDriver> contentFieldDrivers,
            IFieldStorageProvider fieldStorageProvider) {
            
            _contentFieldDrivers = contentFieldDrivers;
            _fieldStorageProvider = fieldStorageProvider;

            OnIndexing<InfosetPart>(
                (context, cp) => {
                    var infosetPart = context.ContentItem.As<InfosetPart>();
                    if (infosetPart == null) {
                        return;
                    }

                    // part fields
                    foreach ( var part in infosetPart.ContentItem.Parts ) {
                        foreach ( var field in part.PartDefinition.Fields ) {
                            if (!field.Settings.GetModel<FieldIndexing>().Included) {
                                continue;
                            }

                            // get all drivers for the current field type
                            // the driver will describe what values of the field should be indexed
                            var drivers = _contentFieldDrivers.Where(x => x.GetFieldInfo().Any(fi => fi.FieldTypeName == field.FieldDefinition.Name)).ToList();

                            ContentPart localPart = part;
                            ContentPartFieldDefinition localField = field;
                            var fieldStorage = _fieldStorageProvider.BindStorage(localPart, localField);
                            var indexName = infosetPart.TypeDefinition.Name.ToLower() + "-" + field.Name.ToLower();

                            var membersContext = new DescribeMembersContext(fieldStorage, values => {

                                foreach (var value in values) {

                                    if (value == null) {
                                        continue;
                                    }

                                    var t = value.GetType();

                                    // the T is nullable, convert using underlying type
                                    if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable<>)) {
                                        t = Nullable.GetUnderlyingType(t);
                                    }
                                    
                                    var typeCode = Type.GetTypeCode(t);

                                    switch (typeCode) {
                                        case TypeCode.Empty:
                                        case TypeCode.Object:
                                        case TypeCode.DBNull:
                                        case TypeCode.String:
                                        case TypeCode.Char:
                                            context.DocumentIndex.Add(indexName, Convert.ToString(value)).RemoveTags().Analyze();
                                            break;
                                        case TypeCode.Boolean:
                                            context.DocumentIndex.Add(indexName, Convert.ToBoolean(value));
                                            break;
                                        case TypeCode.SByte:
                                        case TypeCode.Int16:
                                        case TypeCode.UInt16:
                                        case TypeCode.Int32:
                                        case TypeCode.UInt32:
                                        case TypeCode.Int64:
                                        case TypeCode.UInt64:
                                            context.DocumentIndex.Add(indexName, Convert.ToInt32(value));
                                            break;
                                        case TypeCode.Single:
                                        case TypeCode.Double:
                                        case TypeCode.Decimal:
                                            context.DocumentIndex.Add(indexName, Convert.ToDouble(value));
                                            break;
                                        case TypeCode.DateTime:
                                            context.DocumentIndex.Add(indexName, Convert.ToDateTime(value));
                                            break;
                                    }
                                }
                            });

                            foreach (var driver in drivers) {
                                driver.Describe(membersContext);
                            }
                        }
                    }
                });
        }
        public InfosetFieldIndexingHandler(
            IEnumerable <IContentFieldDriver> contentFieldDrivers,
            IFieldStorageProvider fieldStorageProvider)
        {
            _contentFieldDrivers  = contentFieldDrivers;
            _fieldStorageProvider = fieldStorageProvider;

            OnIndexing <InfosetPart>(
                (context, cp) => {
                var infosetPart = context.ContentItem.As <InfosetPart>();
                if (infosetPart == null)
                {
                    return;
                }

                // part fields
                foreach (var part in infosetPart.ContentItem.Parts)
                {
                    foreach (var field in part.PartDefinition.Fields)
                    {
                        if (!field.Settings.GetModel <FieldIndexing>().Included)
                        {
                            continue;
                        }

                        // get all drivers for the current field type
                        // the driver will describe what values of the field should be indexed
                        var drivers = _contentFieldDrivers.Where(x => x.GetFieldInfo().Any(fi => fi.FieldTypeName == field.FieldDefinition.Name)).ToList();

                        ContentPart localPart = part;
                        ContentPartFieldDefinition localField = field;
                        var fieldStorage = _fieldStorageProvider.BindStorage(localPart, localField);
                        var indexName    = infosetPart.TypeDefinition.Name.ToLower() + "-" + field.Name.ToLower();

                        var membersContext = new DescribeMembersContext(fieldStorage, values => {
                            foreach (var value in values)
                            {
                                if (value == null)
                                {
                                    continue;
                                }

                                var t = value.GetType();

                                // the T is nullable, convert using underlying type
                                if (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable <>))
                                {
                                    t = Nullable.GetUnderlyingType(t);
                                }

                                var typeCode = Type.GetTypeCode(t);

                                switch (typeCode)
                                {
                                case TypeCode.Empty:
                                case TypeCode.Object:
                                case TypeCode.DBNull:
                                case TypeCode.String:
                                case TypeCode.Char:
                                    context.DocumentIndex.Add(indexName, Convert.ToString(value)).RemoveTags().Analyze();
                                    break;

                                case TypeCode.Boolean:
                                    context.DocumentIndex.Add(indexName, Convert.ToBoolean(value));
                                    break;

                                case TypeCode.SByte:
                                case TypeCode.Int16:
                                case TypeCode.UInt16:
                                case TypeCode.Int32:
                                case TypeCode.UInt32:
                                case TypeCode.Int64:
                                case TypeCode.UInt64:
                                    context.DocumentIndex.Add(indexName, Convert.ToInt32(value));
                                    break;

                                case TypeCode.Single:
                                case TypeCode.Double:
                                case TypeCode.Decimal:
                                    context.DocumentIndex.Add(indexName, Convert.ToDouble(value));
                                    break;

                                case TypeCode.DateTime:
                                    context.DocumentIndex.Add(indexName, Convert.ToDateTime(value));
                                    break;
                                }
                            }
                        });

                        foreach (var driver in drivers)
                        {
                            driver.Describe(membersContext);
                        }
                    }
                }
            });
        }