protected void grdIndexFields_InsertCommand(object sender, GridCommandEventArgs e) { var editableItem = ((GridEditableItem)e.Item); //populate its properties Hashtable values = new Hashtable(); editableItem.ExtractValues(values); RadComboBox combo = editableItem.FindControl("ddlFormFields") as RadComboBox; string ffID = combo.SelectedValue; GRASPEntities db = new GRASPEntities(); //create new entity IndexField idx = new IndexField(); idx.FormFieldID = Convert.ToDecimal(ffID); idx.IndexID = Convert.ToInt32(grdIndex.SelectedValue.ToString()); db.IndexFields.Add(idx); try { //submit chanages to Db db.SaveChanges(); } catch(System.Exception ex) { SetMessage(ex.Message); } }
private IEnumerable <AbstractField> GetOrCreateNumericField(IndexField field, object value, Field.Store storage, Field.TermVector termVector = Field.TermVector.NO) { var fieldNameDouble = field.Name + Constants.Documents.Indexing.Fields.RangeFieldSuffixDouble; var fieldNameLong = field.Name + Constants.Documents.Indexing.Fields.RangeFieldSuffixLong; var numericFieldDouble = GetNumericFieldFromCache(fieldNameDouble, null, storage, termVector); var numericFieldLong = GetNumericFieldFromCache(fieldNameLong, null, storage, termVector); switch (BlittableNumber.Parse(value, out double doubleValue, out long longValue)) {
public void Convert_select_many_will_keep_doc_id() { var indexDefinition = new IndexDefinitionBuilder <Order> { Map = orders => from order in orders from line in order.OrderLines select new { line.ProductId } #pragma warning disable CS0618 // Type or member is obsolete }.ToIndexDefinition(new DocumentConventions { PrettifyGeneratedLinqExpressions = false }); #pragma warning restore CS0618 // Type or member is obsolete indexDefinition.Name = "Index1"; var index = IndexCompiler.Compile(indexDefinition); var map = index.Maps.Values.First().First(); using (var context = JsonOperationContext.ShortTermSingleUse()) { var results = map(new[] { GetDocumentFromString( @" { '@metadata': {'@collection': 'Orders', '@id': 1}, 'OrderLines': [{'ProductId': 2}, {'ProductId': 3}] }".Replace("\r\n", Environment.NewLine), context), GetDocumentFromString( @" { '@metadata': {'@collection': 'Orders', '@id': 2}, 'OrderLines': [{'ProductId': 5}, {'ProductId': 4}] }".Replace("\r\n", Environment.NewLine), context) }).Cast <object>().ToArray(); var fields = index.OutputFields .Select(x => IndexField.Create(x, new IndexFieldOptions(), null)) .ToList(); var converter = new AnonymousLuceneDocumentConverter(fields, false); foreach (var result in results) { using (var lazyStringValue = context.GetLazyString("docs/1")) { bool shouldSkip; converter.SetDocument(lazyStringValue, result, context, out shouldSkip); Assert.Equal("docs/1", converter.Document.Get(Constants.Documents.Indexing.Fields.DocumentIdFieldName, null)); } } } }
private IEnumerable <AbstractField> GetOrCreateNumericField(IndexField field, object value, Field.Store storage, Field.TermVector termVector = Field.TermVector.NO) { var fieldName = field.Name + Constants.Indexing.Fields.RangeFieldSuffix; var cacheKey = new FieldCacheKey(field.Name, null, storage, termVector, _multipleItemsSameFieldCount.ToArray()); NumericField numericField; CachedFieldItem <NumericField> cached; if (_numericFieldsCache.TryGetValue(cacheKey, out cached) == false) { _numericFieldsCache[cacheKey] = cached = new CachedFieldItem <NumericField> { Field = numericField = new NumericField(CreateFieldName(fieldName), storage, true) }; } else { numericField = cached.Field; } double doubleValue; long longValue; switch (BlittableNumber.Parse(value, out doubleValue, out longValue)) { case NumberParseResult.Double: if (field.SortOption == SortOptions.NumericLong) { yield return(numericField.SetLongValue((long)doubleValue)); } else { yield return(numericField.SetDoubleValue(doubleValue)); } break; case NumberParseResult.Long: if (field.SortOption == SortOptions.NumericDouble) { yield return(numericField.SetDoubleValue(longValue)); } else { yield return(numericField.SetLongValue(longValue)); } break; } }
public void IndexDoc_Security_CannotAddPasswordHash() { var passwordHashFieldName = "PasswordHash"; var passwordHashField = new IndexField(passwordHashFieldName, "31275491872354956198543", IndexingMode.NotAnalyzed, IndexStoringMode.No, IndexTermVector.No); var indexDoc = new IndexDocument { passwordHashField }; Assert.IsFalse(indexDoc.Any(f => f.Name == passwordHashFieldName)); Assert.IsNull(indexDoc.GetStringValue(passwordHashFieldName)); Assert.IsFalse(indexDoc.Fields.ContainsKey(passwordHashFieldName)); }
protected override void OnProcessOutputSchema(MutableObject newSchema) { // We don't modify the input schema in adapters... We may derive values from input schemas, but adapters always send a novel schema... var oneMutable = TurnSubmissionIntoMutable(new SubmissionScore(), new TeamScores(), Color.magenta); var mutableCollection = new List <MutableObject> { oneMutable }; ScoreTarget.SetValue(mutableCollection, newSchema); IndexField.SetValue(1, newSchema); Router.TransmitAllSchema(newSchema); }
public bool ContainsField(string field) { if (field == Constants.Indexing.Fields.DocumentIdFieldName) { return(_index.Type.IsMap()); } if (field.EndsWith(Constants.Indexing.Fields.RangeFieldSuffix)) { field = field.Substring(0, field.Length - 6); } field = IndexField.ReplaceInvalidCharactersInFieldName(field); return(_fields.ContainsKey(field)); }
public void InMemoryDatabaseGenerator_IndexField_DefaultFlags() { var field = new IndexField("FieldName", "value", IndexingMode.Analyzed, IndexStoringMode.No, IndexTermVector.No); Assert.AreEqual("FieldName:value:S", field.ToString()); var parsed = IndexField.Parse(field.ToString(), false); Assert.AreEqual(field.Name, parsed.Name); Assert.AreEqual(field.Type, parsed.Type); Assert.AreEqual(field.ValueAsString, parsed.ValueAsString); Assert.AreEqual(IndexingMode.Default, parsed.Mode); Assert.AreEqual(IndexStoringMode.Default, parsed.Store); Assert.AreEqual(IndexTermVector.Default, parsed.TermVector); }
public void InMemoryDatabaseGenerator_IndexField_AllFlags_Stored() { var field = new IndexField("FieldName", "value", IndexingMode.No, IndexStoringMode.Yes, IndexTermVector.WithPositions); Assert.AreEqual("IM3,TV3,FieldName:value:S", field.ToString(true)); var parsed = IndexField.Parse(field.ToString(), true); Assert.AreEqual(field.Name, parsed.Name); Assert.AreEqual(field.Type, parsed.Type); Assert.AreEqual(field.ValueAsString, parsed.ValueAsString); Assert.AreEqual(field.Mode, parsed.Mode); Assert.AreEqual(field.Store, parsed.Store); Assert.AreEqual(field.TermVector, parsed.TermVector); }
private static Sort GetSort(SortedField[] sortedFields) { if (sortedFields == null || sortedFields.Length == 0) { return(null); } return(new Sort(sortedFields.Select(x => { var sortOptions = SortOptions.String; if (x.Field == Constants.Indexing.Fields.IndexFieldScoreName) { return SortField.FIELD_SCORE; } if (InvariantCompare.IsPrefix(x.Field, Constants.Indexing.Fields.AlphaNumericFieldName, CompareOptions.None)) { var customFieldName = SortFieldHelper.ExtractName(x.Field); if (customFieldName.IsNullOrWhiteSpace()) { throw new InvalidOperationException("Alphanumeric sort: cannot figure out what field to sort on!"); } var anSort = new AlphaNumericComparatorSource(); return new SortField(customFieldName, anSort, x.Descending); } if (InvariantCompare.IsPrefix(x.Field, Constants.Indexing.Fields.RandomFieldName, CompareOptions.None)) { var customFieldName = SortFieldHelper.ExtractName(x.Field); if (customFieldName.IsNullOrWhiteSpace()) // truly random { return new RandomSortField(Guid.NewGuid().ToString()); } return new RandomSortField(customFieldName); } if (InvariantCompare.IsSuffix(x.Field, Constants.Indexing.Fields.RangeFieldSuffix, CompareOptions.None)) { sortOptions = SortOptions.NumericDouble; // TODO arek - it seems to be working fine with long values as well however needs to be verified } return new SortField(IndexField.ReplaceInvalidCharactersInFieldName(x.Field), (int)sortOptions, x.Descending); }).ToArray())); }
public void IndexDoc_Security_CannotAddPassword() { var passwordFieldName = "Password"; var passwordField = new IndexField(passwordFieldName, "password123", IndexingMode.NotAnalyzed, IndexStoringMode.No, IndexTermVector.No); var indexDoc = new IndexDocument { passwordField }; Assert.IsFalse(indexDoc.Any(f => f.Name == passwordFieldName)); Assert.IsNull(indexDoc.GetStringValue(passwordFieldName)); var indexDocAcc = new ObjectAccessor(indexDoc); var fields = (Dictionary <string, IndexField>)indexDocAcc.GetFieldOrProperty("_fields"); Assert.IsFalse(fields.ContainsKey(passwordFieldName)); }
public void IndexDoc_Security_CannotAddPasswordHash() { var passwordHashFieldName = "PasswordHash"; var passwordHashField = new IndexField(passwordHashFieldName, "31275491872354956198543", IndexingMode.NotAnalyzed, IndexStoringMode.No, IndexTermVector.No); var indexDoc = new IndexDocument { passwordHashField }; Assert.IsFalse(indexDoc.Any(f => f.Name == passwordHashFieldName)); Assert.IsNull(indexDoc.GetStringValue(passwordHashFieldName)); var indexDocAcc = new PrivateObject(indexDoc); var fields = (Dictionary <string, IndexField>)indexDocAcc.GetFieldOrProperty("_fields"); Assert.IsFalse(fields.ContainsKey(passwordHashFieldName)); }
public CreateIndexParams(string indexName, DbDoc indexDefinition) { this._indexName = indexName; if (indexDefinition.values.ContainsKey("type")) { this._type = indexDefinition.values["type"].ToString(); } // Read fields from the indexDefinition object. foreach (var item in indexDefinition.values["fields"] as Object[]) { var field = item as Dictionary <string, object>; if (field == null) { continue; } var fieldValue = field["field"] is MySqlExpression ? ((MySqlExpression)field["field"]).value : field["field"].ToString(); var indexField = new IndexField() { Field = fieldValue }; if (field.ContainsKey("type")) { indexField.Type = field["type"].ToString(); } if (field.ContainsKey("required")) { indexField.Required = Convert.ToBoolean(field["required"]); } if (field.ContainsKey("options")) { indexField.Options = Convert.ToUInt32(field["options"]); } if (field.ContainsKey("srid")) { indexField.Srid = Convert.ToUInt32(field["srid"]); } _fields.Add(indexField); } }
//[TestMethod] //[TestCategory("CloudSearch")] public void TestIndexDocuments() { var domainName = generateDomainName(); var indexName = "netsdkindex" + DateTime.Now.Ticks.ToString(); Client.CreateDomain(new CreateDomainRequest { DomainName = domainName }); var indexField = new IndexField { IndexFieldName = indexName, IndexFieldType = IndexFieldType.Literal }; try { Client.DefineIndexField(new DefineIndexFieldRequest { DomainName = domainName, IndexField = indexField }); var status = Client.DescribeDomains(new DescribeDomainsRequest { DomainNames = { domainName } }).DomainStatusList[0].RequiresIndexDocuments; Assert.IsTrue(status); Client.IndexDocuments(new IndexDocumentsRequest { DomainName = domainName }); var req = new DescribeDomainsRequest { DomainNames = { domainName } }; Assert.IsTrue(Client.DescribeDomains(req).DomainStatusList[0].Processing); } finally { Client.DeleteDomain(new DeleteDomainRequest { DomainName = domainName }); } }
/// <summary>Returns with a parseable value.</summary> private string GetFieldValueAsString(IndexField field) { if (field == null) { return(null); } switch (field.Type) { case IndexValueType.String: return(field.StringValue); case IndexValueType.StringArray: throw new NotImplementedException(); case IndexValueType.Bool: return(field.BooleanValue ? IndexValue.Yes : IndexValue.No); case IndexValueType.Int: return(field.IntegerValue.ToString(CultureInfo.InvariantCulture)); case IndexValueType.IntArray: throw new NotImplementedException(); case IndexValueType.Long: return(field.LongValue.ToString(CultureInfo.InvariantCulture)); case IndexValueType.Float: return(field.SingleValue.ToString(CultureInfo.InvariantCulture)); case IndexValueType.Double: return(field.DoubleValue.ToString(CultureInfo.InvariantCulture)); case IndexValueType.DateTime: return(field.DateTimeValue.ToString("yyyy-MM-dd HH:mm:ss.ffff")); default: throw new ArgumentOutOfRangeException(); } }
private static IndexField[] GetFields(IndexDefinition definition, string[] outputFields) { IndexFieldOptions allFields; definition.Fields.TryGetValue(Constants.Indexing.Fields.AllFields, out allFields); var result = definition.Fields .Where(x => x.Key != Constants.Indexing.Fields.AllFields) .Select(x => IndexField.Create(x.Key, x.Value, allFields)).ToList(); foreach (var outputField in outputFields) { if (definition.Fields.ContainsKey(outputField)) { continue; } result.Add(IndexField.Create(outputField, new IndexFieldOptions(), allFields)); } return(result.ToArray()); }
protected LuceneDocumentConverterBase(ICollection <IndexField> fields, bool reduceOutput = false) { var dictionary = new Dictionary <string, IndexField>(fields.Count, default(OrdinalStringStructComparer)); foreach (var field in fields) { dictionary[field.Name] = field; } _fields = dictionary; if (_fields.TryGetValue(Constants.Documents.Indexing.Fields.AllFields, out _allFields) == false) { _allFields = new IndexField(); } _reduceOutput = reduceOutput; if (reduceOutput) { _reduceValueBuffer = new byte[0]; } }
protected IEnumerable <AbstractField> CreateField(string name, object value, CreateFieldOptions options) { // IMPORTANT: Do not delete this method, it is used by the indexes code when using CreateField options = options ?? CreateFieldOptions.Default; IndexFieldOptions allFields = null; var scope = CurrentIndexingScope.Current; if (scope.IndexDefinition is MapIndexDefinition mapIndexDefinition) { mapIndexDefinition.IndexDefinition.Fields.TryGetValue(Constants.Documents.Indexing.Fields.AllFields, out allFields); } var field = IndexField.Create(name, new IndexFieldOptions { Storage = options.Storage, TermVector = options.TermVector, Indexing = options.Indexing }, allFields); if (scope.DynamicFields == null) { scope.DynamicFields = new Dictionary <string, FieldIndexing>(); } scope.DynamicFields[name] = field.Indexing; if (scope.CreateFieldConverter == null) { scope.CreateFieldConverter = new LuceneDocumentConverter(new IndexField[] { }); } using var i = scope.CreateFieldConverter.NestedField(scope.CreatedFieldsCount++); var result = new List <AbstractField>(); scope.CreateFieldConverter.GetRegularFields(new StaticIndexLuceneDocumentWrapper(result), field, value, CurrentIndexingScope.Current.IndexContext, out _); return(result); }
protected IEnumerable <AbstractField> CreateField(string name, object value, bool stored = false, bool?analyzed = null) { // IMPORTANT: Do not delete this method, it is used by the indexes code when using LoadDocument FieldIndexing?index; switch (analyzed) { case true: index = FieldIndexing.Search; break; case false: index = FieldIndexing.Exact; break; default: index = null; break; } var field = IndexField.Create(name, new IndexFieldOptions { Storage = stored ? FieldStorage.Yes : FieldStorage.No, TermVector = FieldTermVector.No, Indexing = index }, null); if (_createFieldsConverter == null) { _createFieldsConverter = new LuceneDocumentConverter(new IndexField[] { }); } var result = new List <AbstractField>(); _createFieldsConverter.GetRegularFields(new StaticIndexLuceneDocumentWrapper(result), field, value, CurrentIndexingScope.Current.IndexContext); return(result); }
private VisualPayload ParseData() { //var randomGen = new Random(1337); var mutablesList = new List <MutableObject>(); foreach (var team in ScoreFromJsonFilter.LoadedTeams) { //var teamColor = ColorUtility.HsvtoRgb((float)randomGen.NextDouble(), .8f, 1f); var teamColor = TeamColorPalette.ColorFromIndex(team.TeamID); foreach (var entry in team.SubmissionScores) { var newMutable = TurnSubmissionIntoMutable(entry, team, teamColor); mutablesList.Add(newMutable); } } ScoreTarget.SetValue(mutablesList, Payload.Data); var groupId = GroupId.GetFirstValue(Payload.Data); var index = (DataShare.ContainsKey(groupId) ? DataShare[groupId] : 0); if (groupId != "") { DataShare[groupId] = index + 1; } IndexField.SetValue(index, Payload.Data); return(Payload); }
/// <summary> /// Creates an <see cref="IIndexCriteria"/>. /// </summary> /// <param name="set"> /// The set. /// </param> /// <param name="indexFieldNames"> /// The index field names. /// </param> /// <param name="indexFieldPolicies"> /// The index field policies. /// </param> /// <returns> /// The <see cref="IIndexCriteria"/>. /// </returns> internal static IIndexCriteria ToIndexCriteria(this IndexSet set, IEnumerable<string> indexFieldNames, IEnumerable<StaticField> indexFieldPolicies) { if (set.IndexAttributeFields.Count == 0) { foreach (var fn in indexFieldNames) { var field = new IndexField() {Name = fn}; var policy = indexFieldPolicies.FirstOrDefault(x => x.Name == fn); if (policy != null) { field.Type = policy.Type; field.EnableSorting = policy.EnableSorting; } set.IndexAttributeFields.Add(field); } } return new IndexCriteria( set.IndexAttributeFields.Cast<IIndexField>().ToArray(), set.IndexUserFields.Cast<IIndexField>().ToArray(), set.IncludeNodeTypes.ToList().Select(x => x.Name).ToArray(), set.ExcludeNodeTypes.ToList().Select(x => x.Name).ToArray(), set.IndexParentId); }
private static Analyzer GetAnalyzer(string name, IndexField field, bool forQuerying) { if (string.IsNullOrWhiteSpace(field.Analyzer)) { return(null); } var analyzerInstance = IndexingExtensions.CreateAnalyzerInstance(name, field.Analyzer); if (forQuerying) { var analyzerType = analyzerInstance.GetType(); var notForQuerying = NotForQuerying .GetOrAdd(analyzerType, t => analyzerInstance.GetType().GetTypeInfo().GetCustomAttributes <NotForQueryingAttribute>(false).Any()); if (notForQuerying) { return(null); } } return(analyzerInstance); }
/// <summary> /// Ensures that the'_searchEmail' is added to the user fields so that it is indexed - without having to modify the config /// </summary> /// <param name="indexSet"></param> /// <returns></returns> protected override IIndexCriteria GetIndexerData(IndexSet indexSet) { if (CanInitialize()) { //Add a custom _searchEmail to the index criteria no matter what is in config var field = new IndexField { Name = "_searchEmail" }; StaticField policy; if (IndexFieldPolicies.TryGetValue("_searchEmail", out policy)) { field.Type = policy.Type; field.EnableSorting = policy.EnableSorting; } return(indexSet.ToIndexCriteria(DataService, IndexFieldPolicies, //add additional explicit fields new [] { field })); } else { return(base.GetIndexerData(indexSet)); } }
public static IndexField IsRetrievable(this IndexField field, bool value = true) { field.Retrievable = value; return(field); }
public static IndexField IsKey(this IndexField field, bool value = true) { field.Key = value; return(field); }
public static IndexField IsFacetable(this IndexField field, bool value = true) { field.Facetable = value; return(field); }
private static JsValue TryDetectDynamicFieldCreation(string property, ObjectInstance valueAsObject, IndexField field) { //We have a field creation here _ = {"$value":val, "$name","$options":{...}} if (!valueAsObject.HasOwnProperty(CreatedFieldValuePropertyName) || !valueAsObject.HasOwnProperty(CreatedFieldNamePropertyName)) { return(null); } var value = valueAsObject.GetOwnProperty(CreatedFieldValuePropertyName).Value; var fieldNameObj = valueAsObject.GetOwnProperty(CreatedFieldNamePropertyName).Value; if (fieldNameObj.IsString() == false) { throw new ArgumentException($"Dynamic field {property} is expected to have a string {CreatedFieldNamePropertyName} property but got {fieldNameObj}"); } field.Name = fieldNameObj.AsString(); if (valueAsObject.HasOwnProperty(CreatedFieldOptionsPropertyName)) { var options = valueAsObject.GetOwnProperty(CreatedFieldOptionsPropertyName).Value; if (options.IsObject() == false) { throw new ArgumentException($"Dynamic field {property} is expected to contain an object with three properties " + $"{CreatedFieldOptionsPropertyName}, {CreatedFieldNamePropertyName} and {CreatedFieldOptionsPropertyName} the later should be a valid IndexFieldOptions object."); } var optionObj = options.AsObject(); foreach (var kvp in optionObj.GetOwnProperties()) { var optionValue = kvp.Value.Value; if (optionValue.IsUndefined() || optionValue.IsNull()) { continue; } var propertyName = kvp.Key; if (string.Equals(propertyName, nameof(CreateFieldOptions.Indexing), StringComparison.OrdinalIgnoreCase)) { field.Indexing = GetEnum <FieldIndexing>(optionValue, propertyName); continue; } if (string.Equals(propertyName, nameof(CreateFieldOptions.Storage), StringComparison.OrdinalIgnoreCase)) { if (optionValue.IsBoolean()) { field.Storage = optionValue.AsBoolean() ? FieldStorage.Yes : FieldStorage.No; } else { field.Storage = GetEnum <FieldStorage>(optionValue, propertyName); } continue; } if (string.Equals(propertyName, nameof(CreateFieldOptions.TermVector), StringComparison.OrdinalIgnoreCase)) { field.TermVector = GetEnum <FieldTermVector>(optionValue, propertyName); continue; } } } return(value); TEnum GetEnum <TEnum>(JsValue optionValue, string propertyName) { if (optionValue.IsString() == false) { throw new ArgumentException($"Could not parse dynamic field option property '{propertyName}' value ('{optionValue}') because it is not a string."); } var optionValueAsString = optionValue.AsString(); if (Enum.TryParse(typeof(TEnum), optionValueAsString, true, out var enumValue) == false) { throw new ArgumentException($"Could not parse dynamic field option property '{propertyName}' value ('{optionValueAsString}') into '{typeof(TEnum).Name}' enum."); } return((TEnum)enumValue); } }
protected override int GetFields <T>(T instance, LazyStringValue key, object document, JsonOperationContext indexContext, IWriteOperationBuffer writeBuffer) { if (!(document is ObjectInstance documentToProcess)) { return(0); } int newFields = 0; if (key != null) { instance.Add(GetOrCreateKeyField(key)); newFields++; } if (_reduceOutput) { var reduceResult = JsBlittableBridge.Translate(indexContext, documentToProcess.Engine, documentToProcess); instance.Add(GetReduceResultValueField(reduceResult, writeBuffer)); newFields++; } foreach (var(property, propertyDescriptor) in documentToProcess.GetOwnProperties()) { if (_fields.TryGetValue(property, out var field) == false) { field = _fields[property] = IndexField.Create(property, new IndexFieldOptions(), _allFields); } object value; var actualValue = propertyDescriptor.Value; if (actualValue.IsObject() && actualValue.IsArray() == false) { //In case TryDetectDynamicFieldCreation finds a dynamic field it will populate 'field.Name' with the actual property name //so we must use field.Name and not property from this point on. var val = TryDetectDynamicFieldCreation(property, actualValue.AsObject(), field); if (val != null) { if (val.IsObject() && val.AsObject().TryGetValue("$spatial", out _)) { actualValue = val; //Here we populate the dynamic spatial field that will be handled below. } else { value = TypeConverter.ToBlittableSupportedType(val, flattenArrays: false, forIndexing: true, engine: documentToProcess.Engine, context: indexContext); newFields += GetRegularFields(instance, field, value, indexContext, out _); continue; } } var objectValue = actualValue.AsObject(); if (objectValue.HasOwnProperty("$spatial") && objectValue.TryGetValue("$spatial", out var inner)) { SpatialField spatialField; IEnumerable <AbstractField> spatial; if (inner.IsString()) { spatialField = StaticIndexBase.GetOrCreateSpatialField(field.Name); spatial = StaticIndexBase.CreateSpatialField(spatialField, inner.AsString()); } else if (inner.IsObject()) { var innerObject = inner.AsObject(); if (innerObject.HasOwnProperty("Lat") && innerObject.HasOwnProperty("Lng") && innerObject.TryGetValue("Lat", out var lat) && lat.IsNumber() && innerObject.TryGetValue("Lng", out var lng) && lng.IsNumber()) { spatialField = StaticIndexBase.GetOrCreateSpatialField(field.Name); spatial = StaticIndexBase.CreateSpatialField(spatialField, lat.AsNumber(), lng.AsNumber()); } else { continue; //Ignoring bad spatial field } } else { continue; //Ignoring bad spatial field } newFields += GetRegularFields(instance, field, spatial, indexContext, out _); continue; } } value = TypeConverter.ToBlittableSupportedType(propertyDescriptor.Value, flattenArrays: false, forIndexing: true, engine: documentToProcess.Engine, context: indexContext); newFields += GetRegularFields(instance, field, value, indexContext, out _); if (value is IDisposable toDispose) { // the value was converted to a lucene field and isn't needed anymore toDispose.Dispose(); } } return(newFields); }
/// <summary> /// This method generate the fields for indexing documents in lucene from the values. /// Given a name and a value, it has the following behavior: /// * If the value is enumerable, index all the items in the enumerable under the same field name /// * If the value is null, create a single field with the supplied name with the unanalyzed value 'NULL_VALUE' /// * If the value is string or was set to not analyzed, create a single field with the supplied name /// * If the value is date, create a single field with millisecond precision with the supplied name /// * If the value is numeric (int, long, double, decimal, or float) will create two fields: /// 1. with the supplied name, containing the numeric value as an unanalyzed string - useful for direct queries /// 2. with the name: name +'_Range', containing the numeric value in a form that allows range queries /// </summary> public int GetRegularFields<T>(T instance, IndexField field, object value, JsonOperationContext indexContext, out bool shouldSkip, bool nestedArray = false) where T : ILuceneDocumentWrapper { var path = field.Name; var valueType = GetValueType(value); Field.Index defaultIndexing; switch (valueType) { case ValueType.LazyString: case ValueType.LazyCompressedString: case ValueType.String: case ValueType.Enum: defaultIndexing = Field.Index.ANALYZED; break; case ValueType.DateTime: case ValueType.DateTimeOffset: case ValueType.TimeSpan: case ValueType.Boolean: case ValueType.Double: case ValueType.Null: case ValueType.DynamicNull: case ValueType.EmptyString: case ValueType.Numeric: case ValueType.BlittableJsonObject: case ValueType.DynamicJsonObject: defaultIndexing = Field.Index.NOT_ANALYZED_NO_NORMS; break; default: defaultIndexing = Field.Index.ANALYZED_NO_NORMS; break; } var indexing = field.Indexing.GetLuceneValue(field.Analyzer, @default: defaultIndexing); var storage = field.Storage.GetLuceneValue(); var termVector = field.TermVector.GetLuceneValue(); shouldSkip = false; int newFields = 0; if (_reduceOutput && indexing == Field.Index.NO && storage == Field.Store.NO) return newFields; if (valueType == ValueType.Null) { instance.Add(GetOrCreateField(path, Constants.Documents.Indexing.Fields.NullValue, null, null, storage, Field.Index.NOT_ANALYZED_NO_NORMS, Field.TermVector.NO)); newFields++; return newFields; } if (valueType == ValueType.DynamicNull) { var dynamicNull = (DynamicNullObject)value; if (dynamicNull.IsExplicitNull || _indexImplicitNull) { instance.Add(GetOrCreateField(path, Constants.Documents.Indexing.Fields.NullValue, null, null, storage, Field.Index.NOT_ANALYZED_NO_NORMS, Field.TermVector.NO)); newFields++; } shouldSkip = newFields == 0; return newFields; } if (valueType == ValueType.EmptyString) { instance.Add(GetOrCreateField(path, Constants.Documents.Indexing.Fields.EmptyString, null, null, storage, Field.Index.NOT_ANALYZED_NO_NORMS, Field.TermVector.NO)); newFields++; return newFields; } if (valueType == ValueType.String) { string stringValue = value as string ?? value.ToString(); instance.Add(GetOrCreateField(path, stringValue, null, null, storage, indexing, termVector)); newFields++; return newFields; } if (valueType == ValueType.LazyString || valueType == ValueType.LazyCompressedString) { LazyStringValue lazyStringValue; if (valueType == ValueType.LazyCompressedString) lazyStringValue = ((LazyCompressedStringValue)value).ToLazyStringValue(); else lazyStringValue = (LazyStringValue)value; instance.Add(GetOrCreateField(path, null, lazyStringValue, null, storage, indexing, termVector)); newFields++; return newFields; } if (valueType == ValueType.Enum) { instance.Add(GetOrCreateField(path, value.ToString(), null, null, storage, indexing, termVector)); newFields++; return newFields; } if (valueType == ValueType.Boolean) { instance.Add(GetOrCreateField(path, (bool)value ? TrueString : FalseString, null, null, storage, indexing, termVector)); newFields++; return newFields; } if (valueType == ValueType.DateTime) { var dateTime = (DateTime)value; var dateAsString = dateTime.GetDefaultRavenFormat(isUtc: dateTime.Kind == DateTimeKind.Utc); instance.Add(GetOrCreateField(path, dateAsString, null, null, storage, indexing, termVector)); newFields++; return newFields; } if (valueType == ValueType.DateTimeOffset) { var dateTimeOffset = (DateTimeOffset)value; string dateAsString; if (field.Indexing != FieldIndexing.Default && (indexing == Field.Index.NOT_ANALYZED || indexing == Field.Index.NOT_ANALYZED_NO_NORMS)) dateAsString = dateTimeOffset.ToString(DefaultFormat.DateTimeOffsetFormatsToWrite, CultureInfo.InvariantCulture); else dateAsString = dateTimeOffset.UtcDateTime.GetDefaultRavenFormat(isUtc: true); instance.Add(GetOrCreateField(path, dateAsString, null, null, storage, indexing, termVector)); newFields++; return newFields; } if (valueType == ValueType.TimeSpan) { var timeSpan = (TimeSpan)value; instance.Add(GetOrCreateField(path, timeSpan.ToString("c", CultureInfo.InvariantCulture), null, null, storage, indexing, termVector)); foreach (var numericField in GetOrCreateNumericField(field, timeSpan.Ticks, storage, termVector)) { instance.Add(numericField); newFields++; } return newFields; } if (valueType == ValueType.BoostedValue) { var boostedValue = (BoostedValue)value; int boostedFields = GetRegularFields(instance, field, boostedValue.Value, indexContext, out _); newFields += boostedFields; var fields = instance.GetFields(); for (int idx = fields.Count - 1; boostedFields > 0; boostedFields--, idx--) { var fieldFromCollection = fields[idx]; fieldFromCollection.Boost = boostedValue.Boost; fieldFromCollection.OmitNorms = false; } return newFields; } int HandleArray(IEnumerable itemsToIndex) { int count = 1; if (nestedArray == false) { instance.Add(GetOrCreateField(path + IsArrayFieldSuffix, TrueString, null, null, storage, Field.Index.NOT_ANALYZED_NO_NORMS, Field.TermVector.NO)); newFields++; } foreach (var itemToIndex in itemsToIndex) { if (CanCreateFieldsForNestedArray(itemToIndex, field.Indexing) == false) continue; using var i = NestedField(count++); newFields += GetRegularFields(instance, field, itemToIndex, indexContext, out _, nestedArray: true); } return newFields; } if (valueType == ValueType.Enumerable) { return HandleArray((IEnumerable)value); } int HandleObject(BlittableJsonReaderObject val) { if (val.TryGetMember("$values", out var values) && IsArrayOfTypeValueObject(val)) { return HandleArray((IEnumerable)values); } foreach (var complexObjectField in GetComplexObjectFields(path, val, storage, indexing, termVector)) { instance.Add(complexObjectField); newFields++; } return newFields; } if (valueType == ValueType.DynamicJsonObject) { var dynamicJson = (DynamicBlittableJson)value; return HandleObject(dynamicJson.BlittableJson); } if (valueType == ValueType.BlittableJsonObject) { return HandleObject((BlittableJsonReaderObject)value); } if (valueType == ValueType.Lucene) { instance.Add((AbstractField)value); newFields++; return newFields; } if (valueType == ValueType.ConvertToJson) { var val = TypeConverter.ToBlittableSupportedType(value); if (!(val is DynamicJsonValue json)) { return GetRegularFields(instance, field, val, indexContext, out _, nestedArray); } foreach (var jsonField in GetComplexObjectFields(path, Scope.CreateJson(json, indexContext), storage, indexing, termVector)) { instance.Add(jsonField); newFields++; } return newFields; } if (valueType == ValueType.Double) { var ldv = value as LazyNumberValue; if (ldv != null) { if (TryToTrimTrailingZeros(ldv, indexContext, out var doubleAsString) == false) doubleAsString = ldv.Inner; instance.Add(GetOrCreateField(path, null, doubleAsString, null, storage, indexing, termVector)); newFields++; } else { string s = null; switch (value) { case double d: s = d.ToString("G"); break; case decimal dm: s = dm.ToString("G"); break; case float f: s = f.ToString("G"); break; } instance.Add(GetOrCreateField(path, s, null, null, storage, indexing, termVector)); newFields++; } } else if (valueType == ValueType.Convertible) // we need this to store numbers in invariant format, so JSON could read them { instance.Add(GetOrCreateField(path, ((IConvertible)value).ToString(CultureInfo.InvariantCulture), null, null, storage, indexing, termVector)); newFields++; } foreach (var numericField in GetOrCreateNumericField(field, value, storage)) { instance.Add(numericField); newFields++; } return newFields; }
public void AutoFillLinks(DataSource ds) { // Create Object's Link oLink; DataView dbLinkSchemas; Entity oTargetEntity = null; Index oTargetIndex = null; IndexField oTargetIndexField = null; LinkField oSourceLinkField = null; Boolean bIndexExists = false; Trace.Unindent(); Trace.WriteLine(String.Format("Create Links from Entity \"{0}\"", this.Name)); Trace.Indent(); // Get Schemas dbLinkSchemas = GetDBLinkSchema(ds); // Lopping on Fields foreach (EntityField tmpField in this.Fields) { // Clear Flag bIndexExists = false; if (tmpField.KeyField) // PK { Trace.WriteLine(String.Format("Parsing PK \"{0}\"", tmpField.Name)); // Filter Indexes dbLinkSchemas.RowFilter = String.Format("PK_COLUMN_NAME = '{0}' AND PK_TABLE_NAME = '{1}'", tmpField.DBColumn, this.DBEntityName); // Looping on FK's foreach (DataRowView tmpDataRowView in dbLinkSchemas) { Trace.WriteLine(String.Format("Parsing FK \"{0}\"", tmpDataRowView["FK_NAME"])); // Get Target Entity oTargetEntity = Project.CurrentProject.GetEntity(tmpDataRowView["FK_TABLE_NAME"].ToString()); if (oTargetEntity == null) { Trace.WriteLine(String.Format("Entity for Table \"{0}\" not Found.", tmpDataRowView["FK_TABLE_NAME"])); continue; } // Check if the Link Alread Exists foreach (Link tmpLink in this.Links) { if (tmpLink.Fields.Count.Equals(1) && tmpLink.Fields[0].Name.Equals(tmpDataRowView["FK_COLUMN_NAME"].ToString())) { Trace.WriteLine(String.Format("Link por Field \"{0}\" Alread Exists", tmpField.Name)); bIndexExists = true; break; } } if (bIndexExists) { break; } // Lopping on TargetEntity to Find the Correct Index foreach (Index tmpIndex in oTargetEntity.Indexes) { if (tmpIndex.Fields.Count.Equals(1) && tmpIndex.Fields[0].Name.EndsWith(tmpDataRowView["FK_COLUMN_NAME"].ToString())) { oTargetIndex = tmpIndex; break; } } // Check if Exists if (oTargetIndex == null) { Trace.WriteLine(String.Format("Creating Target Index for FK \"{0}\"", tmpDataRowView["FK_NAME"])); // Create Target Index oTargetIndex = new Index(); oTargetIndex.SelectBy = true; oTargetIndex.DeleteBy = false; oTargetIndex.Name = tmpDataRowView["FK_COLUMN_NAME"].ToString(); oTargetIndex.Unique = false; oTargetIndex.DBName = tmpDataRowView["FK_COLUMN_NAME"].ToString(); oTargetIndex.PrimaryKey = false; // Create Target Index Field oTargetIndexField = new IndexField(); oTargetIndexField.Name = tmpDataRowView["FK_COLUMN_NAME"].ToString(); oTargetIndexField.PartialTextMatch = false; // Add Target Index Field on Target Index oTargetIndex.Fields.Add(oTargetIndexField); // Add Target Index on Target Entity oTargetEntity.Indexes.Add(oTargetIndex); } // Create Link oLink = new Link(); oLink.TargetEntityName = oTargetEntity.Name; oLink.TargetIndexName = oTargetIndex.Name; oLink.IsCollection = true; oLink.IsProperty = true; oLink.ReadOnly = true; // Check if the Target Index is Unique if (oTargetIndex.Unique) // 1-N Relation { oLink.Name = oTargetEntity.Name; // N-M Relation } else { oLink.Name = oTargetEntity.PluralName; } // Check Delete Relation Action if (tmpDataRowView["DELETE_RULE"].ToString().Equals("NO ACTION")) { oLink.CascadeDelete = false; } else { oLink.CascadeUpdate = true; } // Check Update Relation Action if (tmpDataRowView["UPDATE_RULE"].ToString().Equals("NO ACTION")) { oLink.CascadeDelete = false; } else { oLink.CascadeUpdate = true; } // Create Link Field oSourceLinkField = new LinkField(); oSourceLinkField.SourceFieldName = this.Fields.GetFieldFromDBColumn(tmpDataRowView["PK_COLUMN_NAME"].ToString()).Name; oSourceLinkField.TargetFieldName = oTargetEntity.Fields.GetFieldFromDBColumn(tmpDataRowView["FK_COLUMN_NAME"].ToString()).Name; // Add Link Field on Link oLink.Fields.Add(oSourceLinkField); // Add Link on Entity this.Links.Add(oLink); } if (bIndexExists) { continue; } } } }
private void btnConfim_Click(object sender, EventArgs e) { IndexField fp = new IndexField(); fp.Name = txtName.Text; fp.Caption = txtCaption.Text; fp.Boost = (float)numBoost.Value; fp.IsTitle = radioTitle.Checked; if (txtName.Enabled ==false) fpList.RemoveAt(lbFields.SelectedIndex); fpList.Insert(lbFields.SelectedIndex, fp); UpdateListData(true); EnableControls(btnAdd, btnEdit, btnDel, btnConfim, btnCancel); EnableControls(false); }
public static Dictionary<IndexSet,Source> GetExcelSettings(string path) { if (SupportClass.FileUtil.IsFileExists(path) == false) throw new ArgumentException("path is not valid.", "path"); DataTable table = ExcelLinker.GetDataTableFromFile(path); List<Source> sourceList = new Dictionary<IndexSet, Source>(); string tableName = "",currentTableName; Source source=null; IndexSet indexSet=null; List<IndexField> fpList=new List<IndexField>(); bool change=false; foreach (DataRow row in table.Rows) { IndexField fp=new IndexField(); fp.Visible = true; fp.Order = 0; foreach (DataColumn column in table.Columns) { System.Console.Write(row[column] + "\t"); if (column.ColumnName.Equals("Table")) { currentTableName = row[column].ToString(); if (currentTableName != tableName) { if (source != null && indexSet != null) { source.Fields=fpList; if (dict.ContainsKey(indexSet) == false) { dict.Add(indexSet, source); IndexSet newIndexSet =new IndexSet(indexSet); Source newSource = new Source(source); newIndexSet.IndexName = Config.IndexPrefix + newIndexSet.IndexName; newIndexSet.SourceName = Config.SourcePrefix + newIndexSet.SourceName; newIndexSet.Type = IndexTypeEnum.Increment; newSource.SourceName = Config.SourcePrefix + newSource.SourceName; newSource.Query = newSource.Query + " where SearchLabel=1"; dict.Add(newIndexSet, newSource); } } tableName = currentTableName; fpList = new List<IndexField>(); source = new Source(); indexSet = new IndexSet(); source.SourceName = row[column].ToString(); source.Query = "select * from " + row[column].ToString(); indexSet.IndexName = row[column].ToString(); indexSet.SourceName = row[column].ToString(); indexSet.Path = @"D:\IndexData\" + indexSet.IndexName; change =true; } else { change =false; } } else if (column.ColumnName.Equals("TableCaption")) { if (change && string.IsNullOrEmpty(row[column].ToString()) == false) indexSet.Caption = row[column].ToString(); } else if (column.ColumnName.Equals("DbType")) { if (change && string.IsNullOrEmpty(row[column].ToString()) == false) source.DBType = ISUtils.Common.DbType.GetDbType(row[column].ToString()); } else if (column.ColumnName.Equals("HostName")) { if (change && string.IsNullOrEmpty(row[column].ToString()) == false) source.HostName = row[column].ToString(); } else if (column.ColumnName.Equals("DataBase")) { if (change && string.IsNullOrEmpty(row[column].ToString()) == false) source.DataBase = row[column].ToString(); } else if (column.ColumnName.Equals("UserName")) { if (change && string.IsNullOrEmpty(row[column].ToString()) == false) source.UserName = row[column].ToString(); } else if (column.ColumnName.Equals("Password")) { if (change && string.IsNullOrEmpty(row[column].ToString()) == false) source.Password = row[column].ToString(); } else if (column.ColumnName.Equals("Field")) { if (string.IsNullOrEmpty(row[column].ToString()) == false) fp.Name = row[column].ToString(); } else if (column.ColumnName.Equals("Caption")) { if (string.IsNullOrEmpty(row[column].ToString()) == false) fp.Caption = row[column].ToString(); } else if (column.ColumnName.Equals("IsTitle")) { if (string.IsNullOrEmpty(row[column].ToString()) == false) { if (row[column].Equals("标题")) { fp.IsTitle=true; } else if (row[column].Equals("内容")) { fp.IsTitle =false; } else { try { fp.IsTitle =bool.Parse(row[column].ToString()); } catch(Exception) { fp.IsTitle =false; } } } } else if (column.ColumnName.Equals("Boost")) { if (string.IsNullOrEmpty(row[column].ToString()) == false) { try { fp.Boost = float.Parse(row[column].ToString()); } catch (Exception) { fp.Boost = 1.0f; } } } else if (column.ColumnName.Equals("Order")) { if (string.IsNullOrEmpty(row[column].ToString()) == false) { try { fp.Order = int.Parse(row[column].ToString()); } catch (Exception) { fp.Order = 0; } } } else if (column.ColumnName.Equals("PK")) { if (string.IsNullOrEmpty(row[column].ToString()) == false) { try { source.PrimaryKey=row[column].ToString(); } catch (Exception) { } } } else { } } fpList.Add(fp); System.Console.WriteLine(); } if (source != null && indexSet != null) { source.Fields = fpList; if (dict.ContainsKey(indexSet) == false) { dict.Add(indexSet, source); IndexSet newIndexSet = new IndexSet(indexSet); Source newSource = new Source(source); newIndexSet.IndexName = Config.IndexPrefix + newIndexSet.IndexName; newIndexSet.SourceName = Config.SourcePrefix + newIndexSet.SourceName; newIndexSet.Type = IndexTypeEnum.Increment; newSource.SourceName = Config.SourcePrefix + newSource.SourceName; newSource.Query = newSource.Query + " where SearchLabel=1"; dict.Add(newIndexSet, newSource); } } return dict; }
public override DateTime GetDateValue(IndexField field) { DateTime date = DateTime.MinValue; try { date = DateField.StringToDate(field.Value.ToString()); } catch { } return date; }
private void RefreshIndexDBInfo(DataRowView schema, Index index, EntityField field) { IndexField indexField = null; foreach (IndexField f in index.Fields) { if (f.Name == field.Name) { indexField = f; break; } } if (indexField == null) { indexField = new IndexField(); indexField.Name = field.Name; index.Fields.Add(indexField); } index.DBName = (string)schema["INDEX_NAME"]; index.PrimaryKey = (bool)schema["PRIMARY_KEY"]; index.ForeignKey = (((string)schema["INDEX_NAME"]).Substring(0, 3) == "FK_"); index.Unique = (bool)schema["UNIQUE"]; if (index.Name == string.Empty) { if (index.PrimaryKey) { index.IsExcluded = !this.OrmConfiguration.AutoEnableMappedIndexes && !this.OrmConfiguration.AutoEnablePrimaryIndex; if (this.OrmConfiguration.RenamePrimaryIndex && this.OrmConfiguration.PrimaryIndexName != "") { index.Name = this.OrmConfiguration.PrimaryIndexName; } else { index.Name = index.DBName; } index.DeleteBy = true; } else { index.IsExcluded = !this.OrmConfiguration.AutoEnableMappedIndexes; index.Name = index.DBName; } } }
private bool SchemaContainsField(DataView schema, IndexField field, Index index) { string dbColumn = string.Empty; foreach (EntityField f in index.Entity.Fields) { if (f.Name == field.Name) { dbColumn = f.DBColumn; break; } } if (dbColumn == string.Empty) { dbColumn = field.Name; } foreach (DataRowView row in schema) { if ((string)row["TABLE_NAME"] == index.Entity.DBEntityName && (string)row["INDEX_NAME"] == index.DBName && (string)row["COLUMN_NAME"] == dbColumn) { return true; } } return false; }
public static IndexField IsSearchable(this IndexField field, bool value = true) { field.Searchable = value; return(field); }
public IRequest Marshall(DefineIndexFieldRequest defineIndexFieldRequest) { IRequest request = new DefaultRequest(defineIndexFieldRequest, "AmazonCloudSearch"); request.Parameters.Add("Action", "DefineIndexField"); request.Parameters.Add("Version", "2011-02-01"); if (defineIndexFieldRequest != null && defineIndexFieldRequest.IsSetDomainName()) { request.Parameters.Add("DomainName", StringUtils.FromString(defineIndexFieldRequest.DomainName)); } if (defineIndexFieldRequest != null) { IndexField indexField = defineIndexFieldRequest.IndexField; if (indexField != null && indexField.IsSetIndexFieldName()) { request.Parameters.Add("IndexField.IndexFieldName", StringUtils.FromString(indexField.IndexFieldName)); } if (indexField != null && indexField.IsSetIndexFieldType()) { request.Parameters.Add("IndexField.IndexFieldType", StringUtils.FromString(indexField.IndexFieldType)); } if (indexField != null) { UIntOptions uIntOptions = indexField.UIntOptions; if (uIntOptions != null && uIntOptions.IsSetDefaultValue()) { request.Parameters.Add("IndexField.UIntOptions.DefaultValue", StringUtils.FromInt(uIntOptions.DefaultValue)); } } if (indexField != null) { LiteralOptions literalOptions = indexField.LiteralOptions; if (literalOptions != null && literalOptions.IsSetDefaultValue()) { request.Parameters.Add("IndexField.LiteralOptions.DefaultValue", StringUtils.FromString(literalOptions.DefaultValue)); } if (literalOptions != null && literalOptions.IsSetSearchEnabled()) { request.Parameters.Add("IndexField.LiteralOptions.SearchEnabled", StringUtils.FromBool(literalOptions.SearchEnabled)); } if (literalOptions != null && literalOptions.IsSetFacetEnabled()) { request.Parameters.Add("IndexField.LiteralOptions.FacetEnabled", StringUtils.FromBool(literalOptions.FacetEnabled)); } if (literalOptions != null && literalOptions.IsSetResultEnabled()) { request.Parameters.Add("IndexField.LiteralOptions.ResultEnabled", StringUtils.FromBool(literalOptions.ResultEnabled)); } } if (indexField != null) { TextOptions textOptions = indexField.TextOptions; if (textOptions != null && textOptions.IsSetDefaultValue()) { request.Parameters.Add("IndexField.TextOptions.DefaultValue", StringUtils.FromString(textOptions.DefaultValue)); } if (textOptions != null && textOptions.IsSetFacetEnabled()) { request.Parameters.Add("IndexField.TextOptions.FacetEnabled", StringUtils.FromBool(textOptions.FacetEnabled)); } if (textOptions != null && textOptions.IsSetResultEnabled()) { request.Parameters.Add("IndexField.TextOptions.ResultEnabled", StringUtils.FromBool(textOptions.ResultEnabled)); } } if (indexField != null) { List <SourceAttribute> sourceAttributesList = indexField.SourceAttributes; int sourceAttributesListIndex = 1; foreach (SourceAttribute sourceAttributesListValue in sourceAttributesList) { if (sourceAttributesListValue != null && sourceAttributesListValue.IsSetSourceDataFunction()) { request.Parameters.Add("IndexField.SourceAttributes.member." + sourceAttributesListIndex + ".SourceDataFunction", StringUtils.FromString(sourceAttributesListValue.SourceDataFunction)); } if (sourceAttributesListValue != null) { SourceData sourceDataCopy = sourceAttributesListValue.SourceDataCopy; if (sourceDataCopy != null && sourceDataCopy.IsSetSourceName()) { request.Parameters.Add("IndexField.SourceAttributes.member." + sourceAttributesListIndex + ".SourceDataCopy.SourceName", StringUtils.FromString(sourceDataCopy.SourceName)); } if (sourceDataCopy != null && sourceDataCopy.IsSetDefaultValue()) { request.Parameters.Add("IndexField.SourceAttributes.member." + sourceAttributesListIndex + ".SourceDataCopy.DefaultValue", StringUtils.FromString(sourceDataCopy.DefaultValue)); } } if (sourceAttributesListValue != null) { SourceDataTrimTitle sourceDataTrimTitle = sourceAttributesListValue.SourceDataTrimTitle; if (sourceDataTrimTitle != null && sourceDataTrimTitle.IsSetSourceName()) { request.Parameters.Add("IndexField.SourceAttributes.member." + sourceAttributesListIndex + ".SourceDataTrimTitle.SourceName", StringUtils.FromString(sourceDataTrimTitle.SourceName)); } if (sourceDataTrimTitle != null && sourceDataTrimTitle.IsSetDefaultValue()) { request.Parameters.Add("IndexField.SourceAttributes.member." + sourceAttributesListIndex + ".SourceDataTrimTitle.DefaultValue", StringUtils.FromString(sourceDataTrimTitle.DefaultValue)); } if (sourceDataTrimTitle != null && sourceDataTrimTitle.IsSetSeparator()) { request.Parameters.Add("IndexField.SourceAttributes.member." + sourceAttributesListIndex + ".SourceDataTrimTitle.Separator", StringUtils.FromString(sourceDataTrimTitle.Separator)); } if (sourceDataTrimTitle != null && sourceDataTrimTitle.IsSetLanguage()) { request.Parameters.Add("IndexField.SourceAttributes.member." + sourceAttributesListIndex + ".SourceDataTrimTitle.Language", StringUtils.FromString(sourceDataTrimTitle.Language)); } } if (sourceAttributesListValue != null) { SourceDataMap sourceDataMap = sourceAttributesListValue.SourceDataMap; if (sourceDataMap != null && sourceDataMap.IsSetSourceName()) { request.Parameters.Add("IndexField.SourceAttributes.member." + sourceAttributesListIndex + ".SourceDataMap.SourceName", StringUtils.FromString(sourceDataMap.SourceName)); } if (sourceDataMap != null && sourceDataMap.IsSetDefaultValue()) { request.Parameters.Add("IndexField.SourceAttributes.member." + sourceAttributesListIndex + ".SourceDataMap.DefaultValue", StringUtils.FromString(sourceDataMap.DefaultValue)); } if (sourceDataMap != null) { if (sourceDataMap.Cases != null) { int casesListIndex = 1; foreach (string key in sourceDataMap.Cases.Keys) { string value; bool hasValue = sourceDataMap.Cases.TryGetValue(key, out value); request.Parameters.Add("sourceDataMap.entry." + casesListIndex + ".key", StringUtils.FromString(key)); if (hasValue) { request.Parameters.Add("sourceDataMap.entry." + casesListIndex + ".value", StringUtils.FromString(value)); } ++casesListIndex; } } } } sourceAttributesListIndex++; } } } return(request); }
public static IndexField SupportSuggestions(this IndexField field, bool value = true) { field.Suggestions = value; return(field); }
public void RefreshDBInfo(DataRowView schema, EntityField entityField) { IndexField indexField = null; foreach (IndexField f in this.Fields) { if (f.Name == entityField.Name) { indexField = f; break; } } if (indexField == null) { indexField = new IndexField(); indexField.Name = entityField.Name; this.Fields.Add(indexField); } this.DBName = (string)schema["INDEX_NAME"]; this.PrimaryKey = (bool)schema["PRIMARY_KEY"]; this.Unique = (bool)schema["UNIQUE"]; if (this.Name == string.Empty) { if (this.PrimaryKey) { this.Name = "PK"; this.DeleteBy = true; } else { this.Name = this.DBName; } } }