C# ElasticsearchCrudJsonWriter.GetJsonString方法代码示例

        public void SerializeAnalyzerWithAsciifoldingFilter()
        {
            const string targetJson =
                "\"analysis\":{\"filter\":{\"my_ascii_folding\":{\"type\":\"asciifolding\",\"preserve_original\":true}},\"analyzer\":{\"default\":{\"type\":\"custom\",\"tokenizer\":\"standard\",\"filter\":[\"standard\",\"my_ascii_folding\"]}}}";

            var analysis = new Analysis
            {
                Analyzer =
                {
                    Analyzers = new List<AnalyzerBase>
                    {
                        new CustomAnalyzer("default")
                        {
                            Tokenizer = DefaultTokenizers.Standard,
                            Filter = new List<string> {"standard", "my_ascii_folding"}
                        }
                    }
                },
                Filters =
                {
                    CustomFilters = new List<AnalysisFilterBase> {new AsciifoldingTokenFilter("my_ascii_folding") {PreserveOriginal = true}}
                }
            };

            var jsonWriter = new ElasticsearchCrudJsonWriter();
            analysis.WriteJson(jsonWriter);
            var result = jsonWriter.GetJsonString();
            Console.WriteLine(result);
            Assert.AreEqual(targetJson, result);
        }

 public override string ToString()
 {
     var elasticsearchCrudJsonWriter = new ElasticsearchCrudJsonWriter();
     WriteJson(elasticsearchCrudJsonWriter);
     return elasticsearchCrudJsonWriter.GetJsonString();
 }

		public void CreateIndexSettingsForDocument(string index, IndexSettings indexSettings, IndexAliases indexAliases, IndexWarmers indexWarmers)
		{
			if (_processedItems.Contains("_index" + index))
			{
				return;
			}
			_processedItems.Add("_index" + index);
			var elasticsearchCrudJsonWriter = new ElasticsearchCrudJsonWriter();
			elasticsearchCrudJsonWriter.JsonWriter.WriteStartObject();
			CreateIndexSettings(elasticsearchCrudJsonWriter, indexSettings);
			indexAliases.WriteJson(elasticsearchCrudJsonWriter);
			indexWarmers.WriteJson(elasticsearchCrudJsonWriter);
			elasticsearchCrudJsonWriter.JsonWriter.WriteEndObject();

			CreateIndexCommand(elasticsearchCrudJsonWriter.GetJsonString(), index);
		}

		/// <summary>
		/// Create a new mapping for the child type in the parent document index
		/// </summary>
		/// <param name="entityInfo"></param>
		/// <param name="elasticsearchMapping"></param>
		/// <param name="item"></param>
		/// <param name="mappingDefinition">definition for the type mappings</param>
		private void CreatePropertyMappingForChildDocument(EntityContextInfo entityInfo, ElasticsearchMapping elasticsearchMapping, EntityContextInfo item, MappingDefinition mappingDefinition)
		{
			var childMapping =
				_elasticsearchSerializerConfiguration.ElasticsearchMappingResolver.GetElasticSearchMapping(item.EntityType);

			var parentMapping =
				_elasticsearchSerializerConfiguration.ElasticsearchMappingResolver.GetElasticSearchMapping(item.ParentEntityType);

			var childType = childMapping.GetDocumentType(item.EntityType);
			var parentType = parentMapping.GetDocumentType(item.ParentEntityType);

			var processedId = childType + "_" + parentType;
			if (_processedItems.Contains(childType))
			{
				var test = CommandTypes.Find(t => t.StartsWith(childType));
				if (test != processedId)
				{
					throw new ElasticsearchCrudException("InitMappings: Not supported, child documents can only have one parent");
				}
				return;
			}
			_processedItems.Add(childType);
			CommandTypes.Add(processedId);

			var elasticsearchCrudJsonWriter = new ElasticsearchCrudJsonWriter();
			elasticsearchCrudJsonWriter.JsonWriter.WriteStartObject();

			elasticsearchCrudJsonWriter.JsonWriter.WritePropertyName(childType);
			elasticsearchCrudJsonWriter.JsonWriter.WriteStartObject();

			mappingDefinition.Source.WriteJson(elasticsearchCrudJsonWriter);
			mappingDefinition.All.WriteJson(elasticsearchCrudJsonWriter);
			mappingDefinition.Analyzer.WriteJson(elasticsearchCrudJsonWriter);

			CreateParentMappingForDocument(
				elasticsearchCrudJsonWriter,
				elasticsearchMapping.GetDocumentType(item.ParentEntityType));

			if (item.RoutingDefinition.RoutingId != null && _elasticsearchSerializerConfiguration.UserDefinedRouting)
			{
				CreateForceRoutingMappingForDocument(elasticsearchCrudJsonWriter);
			}

			ProccessPropertyMappingsWithoutTypeName(elasticsearchCrudJsonWriter, item, childMapping);
			elasticsearchCrudJsonWriter.JsonWriter.WriteEndObject();
			elasticsearchCrudJsonWriter.JsonWriter.WriteEndObject();
			CreateMappingCommandForTypeWithExistingIndex(elasticsearchCrudJsonWriter.GetJsonString(), elasticsearchMapping.GetIndexForType(entityInfo.EntityType), childMapping.GetDocumentType(item.EntityType));
		}

		/// <summary>
		/// Create a new index for the parent document
		/// </summary>
		/// <param name="entityInfo"></param>
		/// <param name="elasticsearchMapping"></param>
		/// <param name="mappingDefinition">mapping definitions for the index type</param>
		private void CreatePropertyMappingForEntityForParentDocument(EntityContextInfo entityInfo, ElasticsearchMapping elasticsearchMapping, MappingDefinition mappingDefinition)
		{
			var itemType = elasticsearchMapping.GetDocumentType(entityInfo.EntityType);
			if (_processedItems.Contains("_mapping" +itemType))
			{
				return;
			}
			_processedItems.Add("_mapping" +itemType);

			var elasticsearchCrudJsonWriter = new ElasticsearchCrudJsonWriter();
			elasticsearchCrudJsonWriter.JsonWriter.WriteStartObject();
			elasticsearchCrudJsonWriter.JsonWriter.WritePropertyName(itemType);
			elasticsearchCrudJsonWriter.JsonWriter.WriteStartObject();

			mappingDefinition.Source.WriteJson(elasticsearchCrudJsonWriter);
			mappingDefinition.All.WriteJson(elasticsearchCrudJsonWriter);
			mappingDefinition.Analyzer.WriteJson(elasticsearchCrudJsonWriter);

			if (entityInfo.RoutingDefinition.RoutingId != null && _elasticsearchSerializerConfiguration.UserDefinedRouting)
			{
				CreateForceRoutingMappingForDocument(elasticsearchCrudJsonWriter);
			}

			if (entityInfo.RoutingDefinition.ParentId != null)
			{
				CreateParentMappingForDocument(
				elasticsearchCrudJsonWriter,
				elasticsearchMapping.GetDocumentType(entityInfo.ParentEntityType));
			}

			ProccessPropertyMappingsWithoutTypeName(elasticsearchCrudJsonWriter, entityInfo, elasticsearchMapping);

			elasticsearchCrudJsonWriter.JsonWriter.WriteEndObject();
			elasticsearchCrudJsonWriter.JsonWriter.WriteEndObject();

			CreateMappingCommandForTypeWithExistingIndex(elasticsearchCrudJsonWriter.GetJsonString(), mappingDefinition.Index, itemType);
		
		}

		public void UpdateSettings(string index, IndexUpdateSettings indexUpdateSettings)
		{
			var elasticsearchCrudJsonWriter = new ElasticsearchCrudJsonWriter();
			elasticsearchCrudJsonWriter.JsonWriter.WriteStartObject();
			elasticsearchCrudJsonWriter.JsonWriter.WritePropertyName("index");
			elasticsearchCrudJsonWriter.JsonWriter.WriteStartObject();
			indexUpdateSettings.WriteJson(elasticsearchCrudJsonWriter);
			elasticsearchCrudJsonWriter.JsonWriter.WriteEndObject();
			elasticsearchCrudJsonWriter.JsonWriter.WriteEndObject();

			SettingsCommand(elasticsearchCrudJsonWriter.GetJsonString(), index);
		}

        public void SerializeAnalyzerWithEdgeNGramTokenizer()
        {
            const string targetJson =
                "\"analysis\":{\"tokenizer\":{\"my_edgengram_tokenizer\":{\"type\":\"edgeNGram\",\"min_gram\":2,\"max_gram\":4,\"token_chars\":[\"digit\",\"letter\"]}},\"analyzer\":{\"default\":{\"type\":\"custom\",\"tokenizer\":\"my_edgengram_tokenizer\"}}}";

            var analysis = new Analysis
            {
                Analyzer =
                {
                    Analyzers = new List<AnalyzerBase>
                    {
                        new CustomAnalyzer("default")
                        {
                            Tokenizer = "my_edgengram_tokenizer"
                        }
                    }
                },
                Tokenizers =
                {
                    CustomTokenizers = new List<AnalysisTokenizerBase>
                    {
                        new EdgeNGramTokenizer("my_edgengram_tokenizer")
                        {
                            MaxGram = 4,
                            MinGram = 2,
                            TokenChars = new List<TokenChar> {TokenChar.digit, TokenChar.letter}
                        }
                    }
                }
            };

            var jsonWriter = new ElasticsearchCrudJsonWriter();
            analysis.WriteJson(jsonWriter);
            var result = jsonWriter.GetJsonString();
            Console.WriteLine(result);
            Assert.AreEqual(targetJson, result);
        }

        public void SerializeBlocksAnalyzer()
        {
            const string targetJson = "\"analysis\":{\"analyzer\":{\"blocks_analyzer\":{\"type\":\"custom\",\"tokenizer\":\"whitespace\",\"filter\":[\"lowercase\",\"blocks_filter\",\"shingle\"]}}}";
            var analysis = new Analysis
            {
                Analyzer =
                {
                    Analyzers = new List<AnalyzerBase>
                    {
                        new CustomAnalyzer("blocks_analyzer")
                        {
                            Tokenizer = DefaultTokenizers.Whitespace,
                            Filter = new List<string> {"lowercase", "blocks_filter", "shingle"}
                        },

                    }
                }
            };

            var jsonWriter = new ElasticsearchCrudJsonWriter();
            analysis.WriteJson(jsonWriter);
            var result = jsonWriter.GetJsonString();
            Console.WriteLine(result);
            Assert.AreEqual(targetJson,result);
        }

        public void SerializeAnalyzerWithStandardTokenizer()
        {
            const string targetJson =
                "\"analysis\":{\"tokenizer\":{\"bigger_limit_token_count\":{\"type\":\"standard\",\"max_token_length\":360}},\"analyzer\":{\"default\":{\"type\":\"custom\",\"tokenizer\":\"bigger_limit_token_count\"}}}";

            var analysis = new Analysis
            {
                Analyzer =
                {
                    Analyzers = new List<AnalyzerBase>
                    {
                        new CustomAnalyzer("default")
                        {
                            Tokenizer = "bigger_limit_token_count"
                        }
                    }
                },
                Tokenizers =
                {
                    CustomTokenizers = new List<AnalysisTokenizerBase>
                    {
                        new StandardTokenizer("bigger_limit_token_count") {MaxTokenLength = 360}
                    }
                }
            };

            var jsonWriter = new ElasticsearchCrudJsonWriter();
            analysis.WriteJson(jsonWriter);
            var result = jsonWriter.GetJsonString();
            Console.WriteLine(result);
            Assert.AreEqual(targetJson, result);
        }