public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var analysisValue = (AnalysisSettings)value;
writer.WriteStartObject();
{
if (analysisValue.Analyzers.Count > 0)
{
writer.WritePropertyName("analyzer");
serializer.Serialize(writer, analysisValue.Analyzers);
}
if (analysisValue.TokenFilters.Count > 0)
{
writer.WritePropertyName("filter");
serializer.Serialize(writer, analysisValue.TokenFilters);
}
if (analysisValue.Tokenizers.Count > 0)
{
writer.WritePropertyName("tokenizer");
serializer.Serialize(writer, analysisValue.Tokenizers);
}
if (analysisValue.CharFilters.Count > 0)
{
writer.WritePropertyName("char_filter");
serializer.Serialize(writer, analysisValue.CharFilters);
}
}
writer.WriteEndObject();
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var mapping = (WarmerMapping) value;
writer.WriteStartObject();
writer.WritePropertyName("types");
serializer.Serialize(writer, mapping.Types);
writer.WritePropertyName("source");
serializer.Serialize(writer, mapping.Source);
writer.WriteEndObject();
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var f = value as ITermsBaseFilter;
if (f == null || (f.IsConditionless && !f.IsVerbatim)) return;
var contract = serializer.ContractResolver as SettingsContractResolver;
if (contract == null)
return;
var field = contract.Infer.PropertyPath(f.Field);
if (field.IsNullOrEmpty())
return;
writer.WriteStartObject();
{
var lf = f as ITermsLookupFilter;
if (lf != null)
{
writer.WritePropertyName(field);
writer.WriteStartObject();
{
WriteProperty(writer, f, "id", lf.Id);
SerializeProperty(writer, serializer, f, "type", lf.Type);
SerializeProperty(writer, serializer, f, "index", lf.Index);
SerializeProperty(writer, serializer, f, "path", lf.Path);
WriteProperty(writer, f, "routing", lf.Routing);
WriteProperty(writer, f, "cache", lf.CacheLookup);
}
writer.WriteEndObject();
}
var tf = f as ITermsFilter;
if (tf != null)
{
writer.WritePropertyName(field);
serializer.Serialize(writer, tf.Terms);
}
if (f.Execution.HasValue)
{
writer.WritePropertyName("execution");
serializer.Serialize(writer, f.Execution.Value);
}
WriteProperty(writer, f, "_cache", f.Cache);
WriteProperty(writer, f, "_cache_key", f.CacheKey);
WriteProperty(writer, f, "_name", f.FilterName);
}
writer.WriteEndObject();
}
private void WriteSettings(JsonWriter writer, JsonSerializer serializer, IndexSettings indexSettings)
{
writer.WritePropertyName("settings");
writer.WriteStartObject();
WriteIndexSettings(writer, serializer, indexSettings);
writer.WriteEndObject();
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var f = value as IGeoBoundingBoxFilter;
if (f == null || (f.IsConditionless && !f.IsVerbatim)) return;
var contract = serializer.ContractResolver as SettingsContractResolver;
if (contract == null)
return;
var field = contract.Infer.PropertyPath(f.Field);
if (field.IsNullOrEmpty())
return;
writer.WriteStartObject();
{
writer.WritePropertyName(field);
writer.WriteStartObject();
{
WriteProperty(writer, f, "top_left", f.TopLeft);
WriteProperty(writer, f, "bottom_right", f.BottomRight);
}
writer.WriteEndObject();
SerializeProperty(writer, serializer, f, "type", f.GeoExecution);
WriteProperty(writer, f, "_cache", f.Cache);
WriteProperty(writer, f, "_cache_key", f.CacheKey);
WriteProperty(writer, f, "_name", f.FilterName);
}
writer.WriteEndObject();
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var contract = serializer.ContractResolver as SettingsContractResolver;
IDictionary dictionary = (IDictionary) value;
writer.WriteStartObject();
foreach (DictionaryEntry entry in dictionary)
{
if (entry.Value == null)
continue;
string key;
var pp = entry.Key as PropertyPathMarker;
var pn = entry.Key as PropertyNameMarker;
var im = entry.Key as IndexNameMarker;
if (contract == null)
key = Convert.ToString(entry.Key, CultureInfo.InvariantCulture);
else if (pp != null)
key = contract.Infer.PropertyPath(pp);
else if (pn != null)
key = contract.Infer.PropertyName(pn);
else if (im != null)
key = contract.Infer.IndexName(im);
else
key = Convert.ToString(entry.Key, CultureInfo.InvariantCulture);
writer.WritePropertyName(key);
serializer.Serialize(writer, entry.Value);
}
writer.WriteEndObject();
}
private static void SerializeProperty(JsonWriter writer, JsonSerializer serializer , IFilter filter, string field, object value)
{
if ((field.IsNullOrEmpty() || value == null))
return;
writer.WritePropertyName(field);
serializer.Serialize(writer, value);
}
private static void WriteProperty(JsonWriter writer, IFilter filter, string field, object value)
{
if ((field.IsNullOrEmpty() || value == null))
return;
writer.WritePropertyName(field);
writer.WriteValue(value);
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var t = value as ITermsQuery;
if (t == null) return;
string field = null;
var contract = serializer.ContractResolver as SettingsContractResolver;
if (contract != null && contract.ConnectionSettings != null)
field = contract.Infer.PropertyPath(t.Field);
writer.WriteStartObject();
{
if (t.Terms.HasAny())
{
writer.WritePropertyName(field);
serializer.Serialize(writer, t.Terms);
}
else if (t.ExternalField != null)
{
writer.WritePropertyName(field);
serializer.Serialize(writer, t.ExternalField);
}
if (t.DisableCoord.HasValue)
{
writer.WritePropertyName("disable_coord");
writer.WriteValue(t.DisableCoord.Value);
}
if (!t.MinimumShouldMatch.IsNullOrEmpty())
{
writer.WritePropertyName("minimum_should_match");
writer.WriteValue(t.MinimumShouldMatch);
}
if (t.Boost.HasValue)
{
writer.WritePropertyName("boost");
writer.WriteValue(t.Boost.Value);
}
}
writer.WriteEndObject();
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var items = (IDictionary<string, CharFilterBase>)value;
writer.WriteStartObject();
foreach (var item in items)
{
writer.WritePropertyName(item.Key);
serializer.Serialize(writer, item.Value);
}
writer.WriteEndObject();
}
private void WriteSettingObject(JsonWriter writer, JObject obj)
{
writer.WriteStartObject();
foreach (var property in obj.Children<JProperty>())
{
writer.WritePropertyName(property.Name);
if (property.Value is JObject)
this.WriteSettingObject(writer, property.Value as JObject);
else
writer.WriteValue(property.Value);
}
writer.WriteEndObject();
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
writer.WriteStartArray();
var sortItems = value as IList<KeyValuePair<PropertyPathMarker, ISort>>;
foreach (var item in sortItems)
{
writer.WriteStartObject();
var contract = serializer.ContractResolver as SettingsContractResolver;
var fieldName = contract.Infer.PropertyPath(item.Key);
writer.WritePropertyName(fieldName);
serializer.Serialize(writer, item.Value);
writer.WriteEndObject();
}
writer.WriteEndArray();
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var similarityValue = (SimilaritySettings)value;
if(similarityValue.CustomSimilarities.Count > 0)
{
serializer.Serialize(writer, similarityValue.CustomSimilarities);
}
if (!string.IsNullOrEmpty(similarityValue.Default))
{
writer.WritePropertyName("similarity.default.type");
writer.WriteValue(similarityValue.Default);
}
}
private static void WriteMappings(JsonWriter writer, JsonSerializer serializer, IndexSettings indexSettings)
{
if (indexSettings.Mappings.Count <= 0) return;
var contract = serializer.ContractResolver as SettingsContractResolver;
if (contract == null || contract.ConnectionSettings == null) return;
writer.WritePropertyName("mappings");
serializer.Serialize(
writer,
indexSettings.Mappings.ToDictionary(m =>
{
var name = contract.Infer.PropertyName(m.Name);
if (name.IsNullOrEmpty())
throw new DslException("{0} should have a name!".F(m.GetType()));
return name;
})
);
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var dict = value as Dictionary<string, DynamicTemplate>;
if (dict == null || !dict.HasAny())
return;
writer.WriteStartArray();
foreach (var p in dict)
{
writer.WriteStartObject();
{
writer.WritePropertyName(p.Key);
serializer.Serialize(writer, p.Value);
}
writer.WriteEndObject();
}
writer.WriteEndArray();
}
private static void WriteAliases(JsonWriter writer, JsonSerializer serializer, IndexSettings indexSettings)
{
if (indexSettings.Aliases == null || indexSettings.Aliases.Count <= 0) return;
writer.WritePropertyName("aliases");
serializer.Serialize(writer, indexSettings.Aliases);
}
private void SerializeNode(JsonWriter writer, IXmlNode node, XmlNamespaceManager manager, bool writePropertyName)
{
switch (node.NodeType)
{
case XmlNodeType.Document:
case XmlNodeType.DocumentFragment:
SerializeGroupedNodes(writer, node, manager, writePropertyName);
break;
case XmlNodeType.Element:
if (IsArray(node) && node.ChildNodes.All(n => n.LocalName == node.LocalName) && node.ChildNodes.Count > 0)
{
SerializeGroupedNodes(writer, node, manager, false);
}
else
{
manager.PushScope();
foreach (IXmlNode attribute in node.Attributes)
{
if (attribute.NamespaceUri == "http://www.w3.org/2000/xmlns/")
{
string namespacePrefix = (attribute.LocalName != "xmlns")
? attribute.LocalName
: string.Empty;
string namespaceUri = attribute.Value;
manager.AddNamespace(namespacePrefix, namespaceUri);
}
}
if (writePropertyName)
writer.WritePropertyName(GetPropertyName(node, manager));
if (!ValueAttributes(node.Attributes).Any() && node.ChildNodes.Count == 1
&& node.ChildNodes[0].NodeType == XmlNodeType.Text)
{
// write elements with a single text child as a name value pair
writer.WriteValue(node.ChildNodes[0].Value);
}
else if (node.ChildNodes.Count == 0 && CollectionUtils.IsNullOrEmpty(node.Attributes))
{
IXmlElement element = (IXmlElement)node;
// empty element
if (element.IsEmpty)
writer.WriteNull();
else
writer.WriteValue(string.Empty);
}
else
{
writer.WriteStartObject();
for (int i = 0; i < node.Attributes.Count; i++)
{
SerializeNode(writer, node.Attributes[i], manager, true);
}
SerializeGroupedNodes(writer, node, manager, true);
writer.WriteEndObject();
}
manager.PopScope();
}
break;
case XmlNodeType.Comment:
if (writePropertyName)
writer.WriteComment(node.Value);
break;
case XmlNodeType.Attribute:
case XmlNodeType.Text:
case XmlNodeType.CDATA:
case XmlNodeType.ProcessingInstruction:
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
if (node.NamespaceUri == "http://www.w3.org/2000/xmlns/" && node.Value == JsonNamespaceUri)
return;
if (node.NamespaceUri == JsonNamespaceUri)
{
if (node.LocalName == "Array")
return;
}
if (writePropertyName)
writer.WritePropertyName(GetPropertyName(node, manager));
writer.WriteValue(node.Value);
break;
case XmlNodeType.XmlDeclaration:
IXmlDeclaration declaration = (IXmlDeclaration)node;
writer.WritePropertyName(GetPropertyName(node, manager));
writer.WriteStartObject();
if (!string.IsNullOrEmpty(declaration.Version))
{
writer.WritePropertyName("@version");
writer.WriteValue(declaration.Version);
}
if (!string.IsNullOrEmpty(declaration.Encoding))
{
writer.WritePropertyName("@encoding");
writer.WriteValue(declaration.Encoding);
}
if (!string.IsNullOrEmpty(declaration.Standalone))
{
writer.WritePropertyName("@standalone");
writer.WriteValue(declaration.Standalone);
}
writer.WriteEndObject();
break;
case XmlNodeType.DocumentType:
IXmlDocumentType documentType = (IXmlDocumentType)node;
writer.WritePropertyName(GetPropertyName(node, manager));
writer.WriteStartObject();
if (!string.IsNullOrEmpty(documentType.Name))
{
writer.WritePropertyName("@name");
writer.WriteValue(documentType.Name);
}
if (!string.IsNullOrEmpty(documentType.Public))
{
writer.WritePropertyName("@public");
writer.WriteValue(documentType.Public);
}
if (!string.IsNullOrEmpty(documentType.System))
{
writer.WritePropertyName("@system");
writer.WriteValue(documentType.System);
}
if (!string.IsNullOrEmpty(documentType.InternalSubset))
{
writer.WritePropertyName("@internalSubset");
writer.WriteValue(documentType.InternalSubset);
}
writer.WriteEndObject();
break;
default:
throw new JsonSerializationException("Unexpected XmlNodeType when serializing nodes: " + node.NodeType);
}
}
internal void WriteProperties(JsonWriter jsonWriter)
{
var properties = this._type.GetProperties();
foreach (var p in properties)
{
var att = ElasticAttributes.Property(p);
if (att != null && att.OptOut)
continue;
var propertyName = this.Infer.PropertyName(p);
var type = GetElasticSearchType(att, p);
if (type == null) //could not get type from attribute or infer from CLR type.
continue;
jsonWriter.WritePropertyName(propertyName);
jsonWriter.WriteStartObject();
{
if (att == null) //properties that follow can not be inferred from the CLR.
{
jsonWriter.WritePropertyName("type");
jsonWriter.WriteValue(type);
//jsonWriter.WriteEnd();
}
if (att != null)
this.WritePropertiesFromAttribute(jsonWriter, att, propertyName, type);
if (type == "object" || type == "nested")
{
var deepType = GetUnderlyingType(p.PropertyType);
var deepTypeName = this.Infer.TypeName(deepType);
var seenTypes = new ConcurrentDictionary<Type, int>(this.SeenTypes);
seenTypes.AddOrUpdate(deepType, 0, (t, i) => ++i);
var newTypeMappingWriter = new TypeMappingWriter(deepType, deepTypeName, this._connectionSettings, MaxRecursion, seenTypes);
var nestedProperties = newTypeMappingWriter.MapPropertiesFromAttributes();
jsonWriter.WritePropertyName("properties");
nestedProperties.WriteTo(jsonWriter);
}
}
jsonWriter.WriteEnd();
}
}
private static void JsonWriteProperty(JsonWriter writer, string propertyName, object value)
{
try
{
writer.WritePropertyName(propertyName);
writer.WriteValue(value);
}
catch (JsonWriterException jwe)
{
SemanticLoggingEventSource.Log.EventEntryJsonWriterFailed(jwe.ToString());
// We are in Error state so abort the write operation
throw new InvalidOperationException(
string.Format(CultureInfo.CurrentCulture, Resources.JsonSerializationError, jwe.Message), jwe);
}
}
private void SerializeGroupedNodes(JsonWriter writer, IXmlNode node, XmlNamespaceManager manager, bool writePropertyName)
{
// group nodes together by name
Dictionary<string, List<IXmlNode>> nodesGroupedByName = new Dictionary<string, List<IXmlNode>>();
for (int i = 0; i < node.ChildNodes.Count; i++)
{
IXmlNode childNode = node.ChildNodes[i];
string nodeName = GetPropertyName(childNode, manager);
List<IXmlNode> nodes;
if (!nodesGroupedByName.TryGetValue(nodeName, out nodes))
{
nodes = new List<IXmlNode>();
nodesGroupedByName.Add(nodeName, nodes);
}
nodes.Add(childNode);
}
// loop through grouped nodes. write single name instances as normal,
// write multiple names together in an array
foreach (KeyValuePair<string, List<IXmlNode>> nodeNameGroup in nodesGroupedByName)
{
List<IXmlNode> groupedNodes = nodeNameGroup.Value;
bool writeArray;
if (groupedNodes.Count == 1)
{
writeArray = IsArray(groupedNodes[0]);
}
else
{
writeArray = true;
}
if (!writeArray)
{
SerializeNode(writer, groupedNodes[0], manager, writePropertyName);
}
else
{
string elementNames = nodeNameGroup.Key;
if (writePropertyName)
writer.WritePropertyName(elementNames);
writer.WriteStartArray();
for (int i = 0; i < groupedNodes.Count; i++)
{
SerializeNode(writer, groupedNodes[i], manager, false);
}
writer.WriteEndArray();
}
}
}
private void WriteIndexSettings(JsonWriter writer, JsonSerializer serializer, IndexSettings indexSettings)
{
writer.WritePropertyName("index");
writer.WriteStartObject();
if (indexSettings.Settings.HasAny())
{
foreach (var kv in indexSettings.Settings)
{
writer.WritePropertyName(kv.Key);
if (kv.Value is JObject)
this.WriteSettingObject(writer, kv.Value as JObject);
else
writer.WriteValue(kv.Value);
}
}
if (
indexSettings.Analysis.Analyzers.Count > 0
|| indexSettings.Analysis.TokenFilters.Count > 0
|| indexSettings.Analysis.Tokenizers.Count > 0
|| indexSettings.Analysis.CharFilters.Count > 0
)
{
writer.WritePropertyName("analysis");
serializer.Serialize(writer, indexSettings.Analysis);
}
if (
indexSettings.Similarity.CustomSimilarities.Count > 0
|| !string.IsNullOrEmpty(indexSettings.Similarity.Default)
)
{
writer.WritePropertyName("similarity");
serializer.Serialize(writer, indexSettings.Similarity);
}
writer.WriteEndObject();
}
private static void WriteWarmers(JsonWriter writer, JsonSerializer serializer, IndexSettings indexSettings)
{
if (indexSettings.Warmers.Count <= 0) return;
writer.WritePropertyName("warmers");
serializer.Serialize(writer, indexSettings.Warmers);
}