private void DeleteEntity(EntityContextInfo entityInfo)
{
var elasticSearchMapping =
_elasticSerializerConfiguration.ElasticMappingResolver.GetElasticSearchMapping(entityInfo.EntityType);
elasticSearchMapping.TraceProvider = _traceProvider;
elasticSearchMapping.SaveChildObjectsAsWellAsParent =
_elasticSerializerConfiguration.SaveChildObjectsAsWellAsParent;
elasticSearchMapping.ProcessChildDocumentsAsSeparateChildIndex = _elasticSerializerConfiguration
.ProcessChildDocumentsAsSeparateChildIndex;
_elasticCrudJsonWriter.JsonWriter.WriteStartObject();
_elasticCrudJsonWriter.JsonWriter.WritePropertyName("delete");
// Write the batch "index" operation header
_elasticCrudJsonWriter.JsonWriter.WriteStartObject();
WriteValue("_index", elasticSearchMapping.GetIndexForType(entityInfo.EntityType));
WriteValue("_type", elasticSearchMapping.GetDocumentType(entityInfo.EntityType));
WriteValue("_id", entityInfo.Id);
if (entityInfo.RoutingDefinition.ParentId != null &&
_elasticSerializerConfiguration.ProcessChildDocumentsAsSeparateChildIndex)
{
WriteValue("_parent", entityInfo.RoutingDefinition.ParentId);
}
if (entityInfo.RoutingDefinition.RoutingId != null &&
_elasticSerializerConfiguration.ProcessChildDocumentsAsSeparateChildIndex &&
_elasticSerializerConfiguration.UserDefinedRouting)
{
WriteValue("_routing", entityInfo.RoutingDefinition.RoutingId);
}
_elasticCrudJsonWriter.JsonWriter.WriteEndObject();
_elasticCrudJsonWriter.JsonWriter.WriteEndObject();
_elasticCrudJsonWriter.JsonWriter.WriteRaw("\n");
}
private void ProcessSingleObjectAsChildDocument(EntityContextInfo entityInfo,
ElasticJsonWriter elasticCrudJsonWriter, PropertyInfo prop, bool createPropertyMappings)
{
var entity = prop.GetValue(entityInfo.Document);
CreateChildEntityForDocumentIndex(entityInfo, elasticCrudJsonWriter, entity, createPropertyMappings);
}
private void CreateChildEntityForDocumentIndex(EntityContextInfo parentEntityInfo,
ElasticJsonWriter elasticCrudJsonWriter, object entity, bool createPropertyMappings)
{
var propertyInfo = entity.GetType().GetProperties();
foreach (var property in propertyInfo)
{
//#if NET46 || NET451 || NET452
// // TODO support this property.GetCustomAttribute(typeof(KeyAttribute)) != null ||
// if ( property.GetCustomAttribute(typeof(ElasticIdAttribute)) != null)
// {
//#else
if (property.GetCustomAttribute(typeof(KeyAttribute)) != null ||
property.GetCustomAttribute(typeof(ElasticIdAttribute)) != null)
{
//#endif
var obj = property.GetValue(entity);
if (obj == null && createPropertyMappings)
{
obj = "0";
}
RoutingDefinition routingDefinition;
if (parentEntityInfo.RoutingDefinition.RoutingId != null)
{
routingDefinition =
new RoutingDefinition
{
ParentId = parentEntityInfo.Id,
RoutingId = parentEntityInfo.RoutingDefinition.RoutingId
}
}
;
else
{
routingDefinition =
new RoutingDefinition {
ParentId = parentEntityInfo.Id, RoutingId = parentEntityInfo.Id
}
};
var child = new EntityContextInfo
{
Document = entity,
RoutingDefinition = routingDefinition,
EntityType = GetEntityDocumentType(entity.GetType()),
ParentEntityType = GetEntityDocumentType(parentEntityInfo.EntityType),
DeleteDocument = parentEntityInfo.DeleteDocument,
Id = obj.ToString()
};
ChildIndexEntities.Add(child);
MapEntityValues(child, elasticCrudJsonWriter, false, createPropertyMappings);
return;
}
}
throw new ElasticException("No Key found for child object: " + parentEntityInfo.Document.GetType());
}
private void MapIEnumerableEntitiesForChildIndexes(ElasticJsonWriter elasticCrudJsonWriter,
IEnumerable ienumerable, EntityContextInfo parentEntityInfo, PropertyInfo prop, bool createPropertyMappings)
{
if (createPropertyMappings)
{
object item;
if (prop.PropertyType.GenericTypeArguments.Length == 0)
{
item = Activator.CreateInstance(prop.PropertyType.GetElementType());
}
else
{
item = Activator.CreateInstance(prop.PropertyType.GenericTypeArguments[0]);
}
CreateChildEntityForDocumentIndex(parentEntityInfo, elasticCrudJsonWriter, item, true);
}
else
{
if (ienumerable != null)
{
foreach (var item in ienumerable)
{
CreateChildEntityForDocumentIndex(parentEntityInfo, elasticCrudJsonWriter, item, false);
}
}
}
}
public void CreatePropertyMappingForTopDocument(EntityContextInfo entityInfo, MappingDefinition mappingDefinition)
{
var elasticSearchMapping = _elasticsearchSerializerConfiguration.ElasticsearchMappingResolver.GetElasticSearchMapping(entityInfo.EntityType);
elasticSearchMapping.TraceProvider = _traceProvider;
elasticSearchMapping.SaveChildObjectsAsWellAsParent = _elasticsearchSerializerConfiguration.SaveChildObjectsAsWellAsParent;
elasticSearchMapping.ProcessChildDocumentsAsSeparateChildIndex = _elasticsearchSerializerConfiguration.ProcessChildDocumentsAsSeparateChildIndex;
CreatePropertyMappingForEntityForParentDocument(entityInfo, elasticSearchMapping, mappingDefinition);
if (_elasticsearchSerializerConfiguration.ProcessChildDocumentsAsSeparateChildIndex)
{
if (elasticSearchMapping.ChildIndexEntities.Count > 0)
{
// Only save the top level items now
elasticSearchMapping.SaveChildObjectsAsWellAsParent = false;
foreach (var item in elasticSearchMapping.ChildIndexEntities)
{
CreatePropertyMappingForChildDocument(entityInfo, elasticSearchMapping, item, mappingDefinition);
}
}
}
elasticSearchMapping.ChildIndexEntities.Clear();
}
private void CreateBulkContentForParentDocument(EntityContextInfo entityInfo, ElasticMapping elasticMapping)
{
_elasticCrudJsonWriter.JsonWriter.WriteStartObject();
_elasticCrudJsonWriter.JsonWriter.WritePropertyName("index");
// Write the batch "index" operation header
_elasticCrudJsonWriter.JsonWriter.WriteStartObject();
WriteValue("_index", elasticMapping.GetIndexForType(entityInfo.EntityType));
WriteValue("_type", elasticMapping.GetDocumentType(entityInfo.EntityType));
WriteValue("_id", entityInfo.Id);
if (entityInfo.RoutingDefinition.ParentId != null &&
_elasticSerializerConfiguration.ProcessChildDocumentsAsSeparateChildIndex)
{
WriteValue("_parent", entityInfo.RoutingDefinition.ParentId);
}
if (entityInfo.RoutingDefinition.RoutingId != null &&
_elasticSerializerConfiguration.UserDefinedRouting)
{
WriteValue("_routing", entityInfo.RoutingDefinition.RoutingId);
}
_elasticCrudJsonWriter.JsonWriter.WriteEndObject();
_elasticCrudJsonWriter.JsonWriter.WriteEndObject();
_elasticCrudJsonWriter.JsonWriter.WriteRaw("\n"); //ES requires this \n separator
_elasticCrudJsonWriter.JsonWriter.WriteStartObject();
elasticMapping.MapEntityValues(entityInfo, _elasticCrudJsonWriter, true);
_elasticCrudJsonWriter.JsonWriter.WriteEndObject();
_elasticCrudJsonWriter.JsonWriter.WriteRaw("\n");
}
private void ProcessArrayOrCollection(EntityContextInfo entityInfo, ElasticsearchCrudJsonWriter elasticsearchCrudJsonWriter, PropertyInfo prop, bool createPropertyMappings)
{
TraceProvider.Trace(TraceEventType.Verbose, "ElasticsearchMapping: IsPropertyACollection: {0}", prop.Name.ToLower());
if (createPropertyMappings && prop.GetValue(entityInfo.Document) == null)
{
if (prop.PropertyType.IsArray)
{
prop.SetValue(entityInfo.Document, Array.CreateInstance(prop.PropertyType.GetElementType(), 0));
}
else
{
prop.SetValue(entityInfo.Document, Activator.CreateInstance(prop.PropertyType));
}
}
if (prop.GetValue(entityInfo.Document) != null && SaveChildObjectsAsWellAsParent)
{
if (ProcessChildDocumentsAsSeparateChildIndex)
{
ProcessArrayOrCollectionAsChildDocument(entityInfo, elasticsearchCrudJsonWriter, prop, createPropertyMappings);
}
else
{
ProcessArrayOrCollectionAsNestedObject(entityInfo, elasticsearchCrudJsonWriter, prop, createPropertyMappings);
}
}
}
private void ProcessSingleObjectAsNestedObject(EntityContextInfo entityInfo, ElasticsearchCrudJsonWriter elasticsearchCrudJsonWriter, PropertyInfo prop, bool createPropertyMappings)
{
elasticsearchCrudJsonWriter.JsonWriter.WritePropertyName(prop.Name.ToLower());
elasticsearchCrudJsonWriter.JsonWriter.WriteStartObject();
if (createPropertyMappings)
{
// "properties": {
elasticsearchCrudJsonWriter.JsonWriter.WritePropertyName("properties");
elasticsearchCrudJsonWriter.JsonWriter.WriteStartObject();
}
// Do class mapping for nested type
var entity = prop.GetValue(entityInfo.Document);
var routingDefinition = new RoutingDefinition {
ParentId = entityInfo.Id
};
var child = new EntityContextInfo {
Document = entity, RoutingDefinition = routingDefinition, EntityType = entity.GetType(), DeleteDocument = entityInfo.DeleteDocument
};
MapEntityValues(child, elasticsearchCrudJsonWriter, false, createPropertyMappings);
elasticsearchCrudJsonWriter.JsonWriter.WriteEndObject();
if (createPropertyMappings)
{
elasticsearchCrudJsonWriter.JsonWriter.WriteEndObject();
}
}
private void CreateBulkContentForChildDocument(EntityContextInfo entityInfo, ElasticMapping elasticMapping,
EntityContextInfo item)
{
var childMapping =
_elasticSerializerConfiguration.ElasticMappingResolver.GetElasticSearchMapping(item.EntityType);
_elasticCrudJsonWriter.JsonWriter.WriteStartObject();
_elasticCrudJsonWriter.JsonWriter.WritePropertyName("index");
// Write the batch "index" operation header
_elasticCrudJsonWriter.JsonWriter.WriteStartObject();
// Always write to the same index
WriteValue("_index", childMapping.GetIndexForType(entityInfo.EntityType));
WriteValue("_type", childMapping.GetDocumentType(item.EntityType));
WriteValue("_id", item.Id);
WriteValue("_parent", item.RoutingDefinition.ParentId);
if (item.RoutingDefinition.RoutingId != null && _elasticSerializerConfiguration.UserDefinedRouting)
{
WriteValue("_routing", item.RoutingDefinition.RoutingId);
}
_elasticCrudJsonWriter.JsonWriter.WriteEndObject();
_elasticCrudJsonWriter.JsonWriter.WriteEndObject();
_elasticCrudJsonWriter.JsonWriter.WriteRaw("\n"); //ES requires this \n separator
_elasticCrudJsonWriter.JsonWriter.WriteStartObject();
childMapping.MapEntityValues(item, _elasticCrudJsonWriter, true);
_elasticCrudJsonWriter.JsonWriter.WriteEndObject();
_elasticCrudJsonWriter.JsonWriter.WriteRaw("\n");
}
public void CreateIndexSettingsAndMappingsForDocument(string index,
IndexSettings indexSettings,
IndexAliases indexAliases,
IndexWarmers indexWarmers,
EntityContextInfo entityInfo,
MappingDefinition mappingDefinition)
{
if (_processedItems.Contains("_index" + index))
{
return;
}
_processedItems.Add("_index" + index);
var elasticCrudJsonWriter = new ElasticJsonWriter();
elasticCrudJsonWriter.JsonWriter.WriteStartObject();
CreateIndexSettings(elasticCrudJsonWriter, indexSettings);
indexAliases.WriteJson(elasticCrudJsonWriter);
indexWarmers.WriteJson(elasticCrudJsonWriter);
IndexSettingsCreatePropertyMappingForTopDocument(entityInfo, mappingDefinition, elasticCrudJsonWriter);
elasticCrudJsonWriter.JsonWriter.WriteEndObject();
CreateIndexCommand(elasticCrudJsonWriter.GetJsonString(), index);
}
private void ProcessArrayOrCollectionAsChildDocument(EntityContextInfo entityInfo, ElasticsearchCrudJsonWriter elasticsearchCrudJsonWriter, PropertyInfo prop, bool createPropertyMappings)
{
TraceProvider.Trace(TraceEventType.Verbose, "ElasticsearchMapping: BEGIN ARRAY or COLLECTION: {0} {1}", prop.Name.ToLower(), elasticsearchCrudJsonWriter.JsonWriter.Path);
var typeOfEntity = prop.GetValue(entityInfo.Document).GetType().GetGenericArguments();
if (typeOfEntity.Length > 0)
{
var child = GetDocumentType(typeOfEntity[0]);
var parent = GetDocumentType(entityInfo.EntityType);
if (!SerializedTypes.Contains(child + parent))
{
SerializedTypes.Add(parent + child);
TraceProvider.Trace(TraceEventType.Verbose,
"ElasticsearchMapping: SerializedTypes type ok, BEGIN ARRAY or COLLECTION: {0}", typeOfEntity[0]);
TraceProvider.Trace(TraceEventType.Verbose, "ElasticsearchMapping: SerializedTypes new Type added: {0}",
GetDocumentType(typeOfEntity[0]));
MapCollectionOrArray(prop, entityInfo, elasticsearchCrudJsonWriter, createPropertyMappings);
}
}
else
{
TraceProvider.Trace(TraceEventType.Verbose, "ElasticsearchMapping: BEGIN ARRAY or COLLECTION NOT A GENERIC: {0}",
prop.Name.ToLower());
// Not a generic
MapCollectionOrArray(prop, entityInfo, elasticsearchCrudJsonWriter, createPropertyMappings);
}
}
private void AddUpdateEntity(EntityContextInfo entityInfo)
{
var elasticSearchMapping =
_elasticSerializerConfiguration.ElasticMappingResolver.GetElasticSearchMapping(entityInfo.EntityType);
elasticSearchMapping.TraceProvider = _traceProvider;
elasticSearchMapping.SaveChildObjectsAsWellAsParent =
_elasticSerializerConfiguration.SaveChildObjectsAsWellAsParent;
elasticSearchMapping.ProcessChildDocumentsAsSeparateChildIndex = _elasticSerializerConfiguration
.ProcessChildDocumentsAsSeparateChildIndex;
CreateBulkContentForParentDocument(entityInfo, elasticSearchMapping);
if (_elasticSerializerConfiguration.ProcessChildDocumentsAsSeparateChildIndex)
{
if (elasticSearchMapping.ChildIndexEntities.Count > 0)
{
// Only save the top level items now
elasticSearchMapping.SaveChildObjectsAsWellAsParent = false;
foreach (var item in elasticSearchMapping.ChildIndexEntities)
{
CreateBulkContentForChildDocument(entityInfo, elasticSearchMapping, item);
}
}
}
elasticSearchMapping.ChildIndexEntities.Clear();
}
private void ProcessSingleObject(EntityContextInfo entityInfo, ElasticsearchCrudJsonWriter elasticsearchCrudJsonWriter, PropertyInfo prop, bool createPropertyMappings)
{
TraceProvider.Trace(TraceEventType.Verbose, "ElasticsearchMapping: Property is an Object: {0}", prop.ToString());
// This is a single object and not a reference to it's parent
if (createPropertyMappings && prop.GetValue(entityInfo.Document) == null)
{
prop.SetValue(entityInfo.Document, Activator.CreateInstance(prop.PropertyType));
}
if (prop.GetValue(entityInfo.Document) != null && SaveChildObjectsAsWellAsParent)
{
var child = GetDocumentType(prop.GetValue(entityInfo.Document).GetType());
var parent = GetDocumentType(entityInfo.EntityType);
if (!SerializedTypes.Contains(child + parent))
{
SerializedTypes.Add(parent + child);
if (ProcessChildDocumentsAsSeparateChildIndex)
{
ProcessSingleObjectAsChildDocument(entityInfo, elasticsearchCrudJsonWriter, prop, createPropertyMappings);
}
else
{
ProcessSingleObjectAsNestedObject(entityInfo, elasticsearchCrudJsonWriter, prop, createPropertyMappings);
}
}
}
}
private void BeginNewEntityToDocumentMapping(EntityContextInfo entityInfo, bool beginMappingTree)
{
if (beginMappingTree)
{
SerializedTypes = new HashSet <string>();
TraceProvider.Trace(TraceEventType.Verbose, "ElasticsearchMapping: Serialize BEGIN for Type: {0}", entityInfo.Document.GetType());
}
}
private void ProccessPropertyMappingsWithoutTypeName(ElasticJsonWriter elasticCrudJsonWriter,
EntityContextInfo entityInfo, ElasticMapping elasticMapping)
{
//"properties": {
elasticCrudJsonWriter.JsonWriter.WritePropertyName("properties");
elasticCrudJsonWriter.JsonWriter.WriteStartObject();
elasticMapping.MapEntityValues(entityInfo, elasticCrudJsonWriter, true, CreatePropertyMappings);
elasticCrudJsonWriter.JsonWriter.WriteEndObject();
}
/// <summary>
/// Here you can do any type of entity mapping
/// </summary>
public override void MapEntityValues(EntityContextInfo entityInfo, ElasticsearchCrudJsonWriter elasticsearchCrudJsonWriter, bool beginMappingTree = false, bool createPropertyMappings = false)
{
var propertyInfo = entityInfo.Document.GetType().GetProperties();
foreach (var prop in propertyInfo)
{
MapValue(prop.Name, prop.GetValue(entityInfo.Document), elasticsearchCrudJsonWriter.JsonWriter);
}
}
/// <summary>
/// Only required if you have some special mapping or want to remove some properties or use attributes..
/// </summary>
/// <param name="entity"></param>
public override void MapEntityValues(EntityContextInfo entityInfo, ElasticsearchCrudJsonWriter elasticsearchCrudJsonWriter, bool beginMappingTree = false, bool createPropertyMappings = false)
{
Skill skillEntity = entityInfo.Document as Skill;
MapValue("id", skillEntity.Id, elasticsearchCrudJsonWriter.JsonWriter);
MapValue("name", skillEntity.Name, elasticsearchCrudJsonWriter.JsonWriter);
MapValue("description", skillEntity.Description, elasticsearchCrudJsonWriter.JsonWriter);
MapValue("created", skillEntity.Created.UtcDateTime, elasticsearchCrudJsonWriter.JsonWriter);
MapValue("updated", skillEntity.Updated.UtcDateTime, elasticsearchCrudJsonWriter.JsonWriter);
}
/// <summary>
/// Create a new index for the parent document
/// </summary>
/// <param name="entityInfo"> </param>
/// <param name="elasticMapping"> </param>
/// <param name="mappingDefinition"> mapping definitions for the index type </param>
private void IndexCreateCreatePropertyMappingForEntityForParentDocument(EntityContextInfo entityInfo,
ElasticMapping elasticMapping, MappingDefinition mappingDefinition, ElasticJsonWriter elasticCrudJsonWriter)
{
var itemType = elasticMapping.GetDocumentType(entityInfo.EntityType);
if (_processedItems.Contains("_mapping" + itemType))
{
return;
}
_processedItems.Add("_mapping" + itemType);
//elasticCrudJsonWriter.JsonWriter.WriteStartObject();
elasticCrudJsonWriter.JsonWriter.WritePropertyName("mappings");
elasticCrudJsonWriter.JsonWriter.WriteStartObject();
elasticCrudJsonWriter.JsonWriter.WritePropertyName(itemType);
elasticCrudJsonWriter.JsonWriter.WriteStartObject();
mappingDefinition.Source.WriteJson(elasticCrudJsonWriter);
mappingDefinition.All.WriteJson(elasticCrudJsonWriter);
if (entityInfo.RoutingDefinition.RoutingId != null && _elasticSerializerConfiguration.UserDefinedRouting)
{
CreateForceRoutingMappingForDocument(elasticCrudJsonWriter);
}
if (entityInfo.RoutingDefinition.ParentId != null)
{
CreateParentMappingForDocument(
elasticCrudJsonWriter,
elasticMapping.GetDocumentType(entityInfo.ParentEntityType));
}
ProccessPropertyMappingsWithoutTypeName(elasticCrudJsonWriter, entityInfo, elasticMapping);
elasticCrudJsonWriter.JsonWriter.WriteEndObject();
if (_elasticSerializerConfiguration.ProcessChildDocumentsAsSeparateChildIndex)
{
if (elasticMapping.ChildIndexEntities.Count > 0)
{
elasticMapping.SaveChildObjectsAsWellAsParent = false;
foreach (var item in elasticMapping.ChildIndexEntities)
{
IndexCreateCreatePropertyMappingForChildDocument(elasticCrudJsonWriter, entityInfo,
elasticMapping, item, mappingDefinition);
}
}
}
elasticCrudJsonWriter.JsonWriter.WriteEndObject();
//elasticCrudJsonWriter.JsonWriter.WriteEndObject();
//CreateMappingCommandForTypeWithExistingIndex(elasticCrudJsonWriter.GetJsonString(), mappingDefinition.Index, itemType);
}
/// <summary>
/// Only required if you have some special mapping or want to remove some properties or use attributes..
/// </summary>
/// <param name="entity"></param>
public override void MapEntityValues(EntityContextInfo entityInfo, ElasticsearchCrudJsonWriter elasticsearchCrudJsonWriter, bool beginMappingTree = false, bool createPropertyMappings = false)
{
AppRecord appRecord = entityInfo.Document as AppRecord;
MapValue("Id", appRecord.Id, elasticsearchCrudJsonWriter.JsonWriter);
MapValue("AppId", appRecord.AppId, elasticsearchCrudJsonWriter.JsonWriter);
MapValue("Hash", appRecord.Hash, elasticsearchCrudJsonWriter.JsonWriter);
MapValue("Url", appRecord.Url, elasticsearchCrudJsonWriter.JsonWriter);
MapValue("Title", appRecord.Title, elasticsearchCrudJsonWriter.JsonWriter);
MapValue("ShortName", appRecord.ShortName, elasticsearchCrudJsonWriter.JsonWriter);
}
private void CreateChildEntityForDocumentIndex(EntityContextInfo parentEntityInfo, ElasticsearchCrudJsonWriter elasticsearchCrudJsonWriter, object entity, bool createPropertyMappings)
{
var propertyInfo = entity.GetType().GetProperties();
foreach (var property in propertyInfo)
{
#if DNX451
if (Attribute.IsDefined(property, typeof(KeyAttribute)) || Attribute.IsDefined(property, typeof(ElasticsearchIdAttribute)))
{
#else
if (property.GetCustomAttribute(typeof(KeyAttribute)) != null || property.GetCustomAttribute(typeof(ElasticsearchIdAttribute)) != null)
{
#endif
var obj = property.GetValue(entity);
if (obj == null && createPropertyMappings)
{
obj = "0";
}
RoutingDefinition routingDefinition;
if (parentEntityInfo.RoutingDefinition.RoutingId != null)
{
// child of a child or lower...
routingDefinition = new RoutingDefinition {
ParentId = parentEntityInfo.Id, RoutingId = parentEntityInfo.RoutingDefinition.RoutingId
};
}
else
{
// This is a direct child
routingDefinition = new RoutingDefinition {
ParentId = parentEntityInfo.Id, RoutingId = parentEntityInfo.Id
};
}
var child = new EntityContextInfo
{
Document = entity,
RoutingDefinition = routingDefinition,
EntityType = GetEntityDocumentType(entity.GetType()),
ParentEntityType = GetEntityDocumentType(parentEntityInfo.EntityType),
DeleteDocument = parentEntityInfo.DeleteDocument,
Id = obj.ToString()
};
ChildIndexEntities.Add(child);
MapEntityValues(child, elasticsearchCrudJsonWriter, false, createPropertyMappings);
return;
}
}
throw new ElasticsearchCrudException("No Key found for child object: " + parentEntityInfo.Document.GetType());
}
protected internal virtual EntityContextInfo VisitEntityContextInfo(EntityContextInfo entityContext)
{
var entityId = (PrimaryKeyExpression)Visit(entityContext.EntityId);
var rowId = (PrimaryKeyExpression?)Visit(entityContext.MListRowId);
if (entityId != entityContext.EntityId || rowId != entityContext.MListRowId)
{
return(new EntityContextInfo(entityId, rowId));
}
return(entityContext);
}
/// <summary>
/// Create a new mapping for the child type in the parent document index
/// </summary>
/// <param name="entityInfo"> </param>
/// <param name="elasticMapping"> </param>
/// <param name="item"> </param>
/// <param name="mappingDefinition"> definition for the type mappings </param>
private void CreatePropertyMappingForChildDocument(EntityContextInfo entityInfo, ElasticMapping elasticMapping,
EntityContextInfo item, MappingDefinition mappingDefinition)
{
var childMapping =
_elasticSerializerConfiguration.ElasticMappingResolver.GetElasticSearchMapping(item.EntityType);
var parentMapping =
_elasticSerializerConfiguration.ElasticMappingResolver.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 ElasticException("InitMappings: Not supported, child documents can only have one parent");
}
return;
}
_processedItems.Add(childType);
CommandTypes.Add(processedId);
var elasticCrudJsonWriter = new ElasticJsonWriter();
elasticCrudJsonWriter.JsonWriter.WriteStartObject();
elasticCrudJsonWriter.JsonWriter.WritePropertyName(childType);
elasticCrudJsonWriter.JsonWriter.WriteStartObject();
mappingDefinition.Source.WriteJson(elasticCrudJsonWriter);
mappingDefinition.All.WriteJson(elasticCrudJsonWriter);
CreateParentMappingForDocument(
elasticCrudJsonWriter,
elasticMapping.GetDocumentType(item.ParentEntityType));
if (item.RoutingDefinition.RoutingId != null && _elasticSerializerConfiguration.UserDefinedRouting)
{
CreateForceRoutingMappingForDocument(elasticCrudJsonWriter);
}
ProccessPropertyMappingsWithoutTypeName(elasticCrudJsonWriter, item, childMapping);
elasticCrudJsonWriter.JsonWriter.WriteEndObject();
elasticCrudJsonWriter.JsonWriter.WriteEndObject();
CreateMappingCommandForTypeWithExistingIndex(elasticCrudJsonWriter.GetJsonString(),
elasticMapping.GetIndexForType(entityInfo.EntityType), childMapping.GetDocumentType(item.EntityType));
}
public async Task <ResultDetails <string> > CreateTypeMappingForIndexAsync <T>(MappingDefinition mappingDefinition)
{
if (mappingDefinition == null)
{
throw new ElasticException(
"CreateTypeMappingForIndexAsync: A mapping definition with the parent index is required");
}
_traceProvider.Trace(TraceEventType.Verbose, "{0}: CreateTypeMappingForIndex Elastic started",
"ElasticContextIndexMapping");
var resultDetails = new ResultDetails <string> {
Status = HttpStatusCode.InternalServerError
};
try
{
var indexMappings = new IndexMappings(_traceProvider, _elasticSerializerConfiguration);
var item = Activator.CreateInstance <T>();
var entityContextInfo = new EntityContextInfo
{
RoutingDefinition = mappingDefinition.RoutingDefinition,
Document = item,
EntityType = typeof(T),
Id = "0"
};
if (string.IsNullOrEmpty(mappingDefinition.Index))
{
var index = _elasticSerializerConfiguration.ElasticMappingResolver
.GetElasticSearchMapping(entityContextInfo.EntityType)
.GetIndexForType(entityContextInfo.EntityType);
MappingUtils.GuardAgainstBadIndexName(index);
mappingDefinition.Index = index;
}
indexMappings.CreatePropertyMappingForTopDocument(entityContextInfo, mappingDefinition);
await indexMappings.Execute(_client, _connectionString, _traceProvider, _cancellationTokenSource);
return(resultDetails);
}
catch (OperationCanceledException oex)
{
_traceProvider.Trace(TraceEventType.Warning, oex,
"{1}: CreateTypeMappingForIndexAsync Request OperationCanceledException: {0}", oex.Message,
"ElasticContextIndexMapping");
resultDetails.Description = "OperationCanceledException";
return(resultDetails);
}
}
public async Task <ResultDetails <string> > CreateIndexWithMappingAsync <T>(IndexDefinition indexDefinition)
{
if (indexDefinition == null)
{
indexDefinition = new IndexDefinition();
}
_traceProvider.Trace(TraceEventType.Verbose, "{0}: CreateIndexWithMappingAsync Elastic started",
"ElasticContextIndexMapping");
var resultDetails = new ResultDetails <string> {
Status = HttpStatusCode.InternalServerError
};
try
{
var item = Activator.CreateInstance <T>();
var entityContextInfo = new EntityContextInfo
{
RoutingDefinition = indexDefinition.Mapping.RoutingDefinition,
Document = item,
EntityType = typeof(T),
Id = "0"
};
var index =
_elasticSerializerConfiguration.ElasticMappingResolver.GetElasticSearchMapping(
entityContextInfo.EntityType)
.GetIndexForType(entityContextInfo.EntityType);
MappingUtils.GuardAgainstBadIndexName(index);
var indexMappings = new IndexMappings(_traceProvider, _elasticSerializerConfiguration);
indexMappings.CreateIndexSettingsAndMappingsForDocument(
index,
indexDefinition.IndexSettings,
indexDefinition.IndexAliases,
indexDefinition.IndexWarmers, entityContextInfo, indexDefinition.Mapping);
indexDefinition.Mapping.Index = index;
//indexMappings.CreatePropertyMappingForTopDocument(entityContextInfo, indexDefinition.Mapping);
await indexMappings.Execute(_client, _connectionString, _traceProvider, _cancellationTokenSource);
return(resultDetails);
}
catch (OperationCanceledException oex)
{
_traceProvider.Trace(TraceEventType.Warning, oex,
"{1}: CreateIndexWithMappingAsync Request OperationCanceledException: {0}", oex.Message,
"ElasticContextIndexMapping");
resultDetails.Description = "OperationCanceledException";
return(resultDetails);
}
}
// Nested
// "tags" : ["elastic", "wow"], (string array or int array)
// Nested
//"lists" : [
// {
// "name" : "prog_list",
// "description" : "programming list"
// },
protected virtual void MapCollectionOrArray(PropertyInfo prop, EntityContextInfo entityInfo,
ElasticJsonWriter elasticCrudJsonWriter, bool createPropertyMappings)
{
var type = prop.PropertyType;
if (type.HasElementType)
{
// It is a collection
var ienumerable = (Array)prop.GetValue(entityInfo.Document);
if (ProcessChildDocumentsAsSeparateChildIndex)
{
MapIEnumerableEntitiesForChildIndexes(elasticCrudJsonWriter, ienumerable, entityInfo, prop,
createPropertyMappings);
}
else
{
if (createPropertyMappings)
{
MapIEnumerableEntitiesForMapping(elasticCrudJsonWriter, entityInfo, prop, true);
}
else
{
MapIEnumerableEntities(elasticCrudJsonWriter, ienumerable, entityInfo, false);
}
}
}
else if (prop.PropertyType.GetTypeInfo().IsGenericType)
{
// It is a collection
var ienumerable = (IEnumerable)prop.GetValue(entityInfo.Document);
if (ProcessChildDocumentsAsSeparateChildIndex)
{
MapIEnumerableEntitiesForChildIndexes(elasticCrudJsonWriter, ienumerable, entityInfo, prop,
createPropertyMappings);
}
else
{
if (createPropertyMappings)
{
MapIEnumerableEntitiesForMapping(elasticCrudJsonWriter, entityInfo, prop, true);
}
else
{
MapIEnumerableEntities(elasticCrudJsonWriter, ienumerable, entityInfo, false);
}
}
}
}
internal Expression FieldExpression(Alias tableAlias, QueryBinder binder, IntervalExpression?externalPeriod, bool withRowId)
{
var rowId = RowIdExpression(tableAlias);
var parentId = new PrimaryKeyExpression(new ColumnExpression(this.BackReference.Type.Nullify(), tableAlias, this.BackReference.Name));
var entityContext = new EntityContextInfo(parentId, rowId);
var exp = Field.GetExpression(tableAlias, binder, rowId, externalPeriod, entityContext);
if (!withRowId)
{
return(exp);
}
var type = this.Field.FieldType;
var ci = typeof(MList <> .RowIdElement).MakeGenericType(type).GetConstructor(new[] { type, typeof(PrimaryKey), typeof(int?) });
var order = Order == null ? (Expression)Expression.Constant(null, typeof(int?)) : OrderExpression(tableAlias).Nullify();
return(Expression.New(ci, exp, rowId.UnNullify(), order));
}
/// <summary>
/// Create a new index for the parent document
/// </summary>
/// <param name="entityInfo"> </param>
/// <param name="elasticMapping"> </param>
/// <param name="mappingDefinition"> mapping definitions for the index type </param>
private void CreatePropertyMappingForEntityForParentDocument(EntityContextInfo entityInfo,
ElasticMapping elasticMapping, MappingDefinition mappingDefinition)
{
var itemType = elasticMapping.GetDocumentType(entityInfo.EntityType);
if (_processedItems.Contains("_mapping" + itemType))
{
return;
}
_processedItems.Add("_mapping" + itemType);
var elasticCrudJsonWriter = new ElasticJsonWriter();
elasticCrudJsonWriter.JsonWriter.WriteStartObject();
elasticCrudJsonWriter.JsonWriter.WritePropertyName(itemType);
elasticCrudJsonWriter.JsonWriter.WriteStartObject();
mappingDefinition.Source.WriteJson(elasticCrudJsonWriter);
mappingDefinition.All.WriteJson(elasticCrudJsonWriter);
if (entityInfo.RoutingDefinition.RoutingId != null && _elasticSerializerConfiguration.UserDefinedRouting)
{
CreateForceRoutingMappingForDocument(elasticCrudJsonWriter);
}
if (entityInfo.RoutingDefinition.ParentId != null)
{
CreateParentMappingForDocument(
elasticCrudJsonWriter,
elasticMapping.GetDocumentType(entityInfo.ParentEntityType));
}
ProccessPropertyMappingsWithoutTypeName(elasticCrudJsonWriter, entityInfo, elasticMapping);
elasticCrudJsonWriter.JsonWriter.WriteEndObject();
elasticCrudJsonWriter.JsonWriter.WriteEndObject();
CreateMappingCommandForTypeWithExistingIndex(elasticCrudJsonWriter.GetJsonString(), mappingDefinition.Index,
itemType);
}
internal Expression GetProjectorExpression(Alias tableAlias, QueryBinder binder)
{
Schema.Current.AssertAllowed(this.BackReference.ReferenceTable.Type, inUserInterface: false);
Type elementType = typeof(MListElement <,>).MakeGenericType(BackReference.FieldType, Field.FieldType);
var rowId = RowIdExpression(tableAlias);
IntervalExpression?period = GenerateSystemPeriod(tableAlias, binder);
var backReference = (EntityExpression)this.BackReference.GetExpression(tableAlias, binder, null !, period, null);
var entityContext = new EntityContextInfo(backReference.ExternalId, rowId);
return(new MListElementExpression(
rowId,
backReference,
this.Order == null ? null : OrderExpression(tableAlias),
this.Field.GetExpression(tableAlias, binder, rowId, period, entityContext),
period,
this,
tableAlias));
}
private void MapIEnumerableEntitiesForMapping(ElasticsearchCrudJsonWriter elasticsearchCrudJsonWriter,
EntityContextInfo parentEntityInfo, PropertyInfo prop, bool createPropertyMappings)
{
object item;
if (prop.PropertyType.FullName == "System.String[]")
{
item = string.Empty;
}
else if (prop.PropertyType.GenericTypeArguments.Length == 0)
{
item = Activator.CreateInstance(prop.PropertyType.GetElementType());
}
else if (prop.PropertyType.GenericTypeArguments[0].FullName == "System.String")
{
item = string.Empty;
}
else
{
item = Activator.CreateInstance(prop.PropertyType.GenericTypeArguments[0]);
}
var typeofArrayItem = item.GetType();
if (typeofArrayItem.GetTypeInfo().IsClass&& typeofArrayItem.FullName != "System.String" &&
typeofArrayItem.FullName != "System.Decimal")
{
// collection of Objects
elasticsearchCrudJsonWriter.JsonWriter.WriteStartObject();
//#if NET46 || NET451 || NET452
// if (prop.GetCustomAttribute(typeof(ElasticsearchCoreTypes)) != null)
// {
// var propertyName = prop.Name.ToLower();
// object[] attrs = prop.GetCustomAttributes(typeof(ElasticsearchCoreTypes), true);
// if ((attrs.FirstOrDefault() as ElasticsearchCoreTypes) != null)
// {
// elasticsearchCrudJsonWriter.JsonWriter.WritePropertyName(propertyName);
// elasticsearchCrudJsonWriter.JsonWriter.WriteRawValue((attrs.FirstOrDefault() as ElasticsearchCoreTypes).JsonString());
// }
// }
//#else
if (prop.GetCustomAttribute(typeof(ElasticsearchNestedAttribute)) != null)
{
elasticsearchCrudJsonWriter.JsonWriter.WritePropertyName("type");
elasticsearchCrudJsonWriter.JsonWriter.WriteValue("nested");
IEnumerable <Attribute> attrs = prop.GetCustomAttributes(typeof(ElasticsearchNestedAttribute), true);
if ((attrs.FirstOrDefault() as ElasticsearchNestedAttribute) != null)
{
(attrs.FirstOrDefault() as ElasticsearchNestedAttribute).WriteJson(elasticsearchCrudJsonWriter);
}
}
//#endif
// "properties": {
elasticsearchCrudJsonWriter.JsonWriter.WritePropertyName("properties");
elasticsearchCrudJsonWriter.JsonWriter.WriteStartObject();
// Do class mapping for nested type
var routingDefinition = new RoutingDefinition
{
ParentId = parentEntityInfo.Id,
RoutingId = parentEntityInfo.RoutingDefinition.RoutingId
};
var child = new EntityContextInfo
{
Document = item,
RoutingDefinition = routingDefinition,
EntityType = item.GetType(),
DeleteDocument = parentEntityInfo.DeleteDocument
};
MapEntityValues(child, elasticsearchCrudJsonWriter, false, createPropertyMappings);
elasticsearchCrudJsonWriter.JsonWriter.WriteEndObject();
elasticsearchCrudJsonWriter.JsonWriter.WriteEndObject();
}
else
{
// {"type": "ienumerable"}
// collection of simple types
elasticsearchCrudJsonWriter.JsonWriter.WriteStartObject();
elasticsearchCrudJsonWriter.JsonWriter.WritePropertyName("type");
elasticsearchCrudJsonWriter.JsonWriter.WriteValue(GetElasticsearchType(item.GetType()));
elasticsearchCrudJsonWriter.JsonWriter.WriteEndObject();
}
}
private void MapIEnumerableEntities(ElasticsearchCrudJsonWriter elasticsearchCrudJsonWriter, IEnumerable ienumerable, EntityContextInfo parentEntityInfo, bool createPropertyMappings)
{
string json = null;
bool isSimpleArrayOrCollection = true;
bool doProccessingIfTheIEnumerableHasAtLeastOneItem = false;
if (ienumerable != null)
{
var sbCollection = new StringBuilder();
sbCollection.Append("[");
foreach (var item in ienumerable)
{
doProccessingIfTheIEnumerableHasAtLeastOneItem = true;
var childElasticsearchCrudJsonWriter = new ElasticsearchCrudJsonWriter(sbCollection);
elasticsearchCrudJsonWriter.ElasticsearchCrudJsonWriterChildItem = childElasticsearchCrudJsonWriter;
var typeofArrayItem = item.GetType();
if (typeofArrayItem.GetTypeInfo().IsClass&& typeofArrayItem.FullName != "System.String" &&
typeofArrayItem.FullName != "System.Decimal")
{
isSimpleArrayOrCollection = false;
// collection of Objects
childElasticsearchCrudJsonWriter.JsonWriter.WriteStartObject();
// Do class mapping for nested type
var routingDefinition = new RoutingDefinition {
ParentId = parentEntityInfo.Id, RoutingId = parentEntityInfo.RoutingDefinition.RoutingId
};
var child = new EntityContextInfo {
Document = item, RoutingDefinition = routingDefinition, EntityType = item.GetType(), DeleteDocument = parentEntityInfo.DeleteDocument
};
MapEntityValues(child, childElasticsearchCrudJsonWriter, false, createPropertyMappings);
childElasticsearchCrudJsonWriter.JsonWriter.WriteEndObject();
// Add as separate document later
}
else
{
// collection of simple types, serialize all items in one go and break from the loop
json = JsonConvert.SerializeObject(ienumerable);
break;
}
sbCollection.Append(",");
}
if (isSimpleArrayOrCollection && doProccessingIfTheIEnumerableHasAtLeastOneItem)
{
elasticsearchCrudJsonWriter.JsonWriter.WriteRawValue(json);
}
else
{
if (doProccessingIfTheIEnumerableHasAtLeastOneItem)
{
sbCollection.Remove(sbCollection.Length - 1, 1);
}
sbCollection.Append("]");
elasticsearchCrudJsonWriter.JsonWriter.WriteRawValue(sbCollection.ToString());
}
}
else
{
elasticsearchCrudJsonWriter.JsonWriter.WriteRawValue("");
}
}
