public void Describe(DescribeSortCriterionContext describe) {
            foreach(var part in _contentDefinitionManager.ListPartDefinitions()) {
                if(!part.Fields.Any()) {
                    continue;
                }

                var descriptor = describe.For(part.Name + "ContentFields", T("{0} Content Fields", part.Name.CamelFriendly()), T("Content Fields for {0}", part.Name.CamelFriendly()));

                foreach(var field in part.Fields) {
                    var localField = field;
                    var localPart = part;
                    var drivers = _contentFieldDrivers.Where(x => x.GetFieldInfo().Any(fi => fi.FieldTypeName == localField.FieldDefinition.Name)).ToList();

                    var membersContext = new DescribeMembersContext(
                        (storageName, storageType, displayName, description) => {
                            // look for a compatible field type editor
                            IFieldTypeEditor fieldTypeEditor = _fieldTypeEditors.FirstOrDefault(x => x.CanHandle(storageType));

                            descriptor.Element(
                                type: localPart.Name + "." + localField.Name + "." + storageName ?? "",
                                name: new LocalizedString(localField.DisplayName + (displayName != null ? ":" + displayName.Text : "")),
                                description: description ?? T("{0} property for {1}", storageName, localField.DisplayName),
                                sort: context => ApplySortCriterion(context, fieldTypeEditor, storageName, storageType, localPart, localField),
                                display: context => DisplaySortCriterion(context, localPart, localField),
                                form: SortCriterionFormProvider.FormName);
                        });
                    
                    foreach(var driver in drivers) {
                        driver.Describe(membersContext);
                    }
                }
            }
        }
        public void Publishing(PublishContentContext context, FieldIndexPart fieldIndexPart) {
            foreach (var part in fieldIndexPart.ContentItem.Parts) {
                foreach(var field in part.PartDefinition.Fields) {
                    
                    // 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});

                            _fieldIndexService.Set(fieldIndexPart,
                                localPart.PartDefinition.Name,
                                localField.Name,
                                storageName, fieldValue, storageType);
                        });

                    foreach (var driver in drivers) {
                        driver.Describe(membersContext);
                    }
                }
            }
        }
示例#3
0
 public Type GetFieldType(string fieldNameType) {
     var drivers = _contentFieldDrivers.Where(x => x.GetFieldInfo().Any(fi => fi.FieldTypeName == fieldNameType)).ToList();
     Type defaultType = typeof(string);
     var membersContext = new DescribeMembersContext(
                 (storageName, storageType, displayName, description) => {
                     defaultType = storageType;
                 });
     foreach (var driver in drivers) {
         driver.Describe(membersContext);
     }
     return defaultType;
 }
        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);
                            }
                        }
                    }
                });
        }