public TypedEntityToIndexOperation(AbstractFluentMappingEngine engine)
: base(engine)
{
MappingContext
.CreateUsing(x => new NestedHiveIndexOperation())
.ForMember(x => x.Entity, opt => opt.MapFrom(y => y))
.ForMember(x => x.OperationType, opt => opt.MapFrom(y => IndexOperationType.Add))
.ForMember(x => x.Id, opt => opt.MapFrom(y => new Lazy <string>(() => y.Id.Value.ToString())))
.ForMember(x => x.ItemCategory, opt => opt.MapFrom(y => typeof(TypedEntity).Name))
.ForMember(x => x.Fields, opt => opt.MapUsing <TypedEntityToIndexFields>())
.AfterMap((s, t) =>
{
//create sub operations for each of the children
//NOTE: we don't store TypedAttribute seperately in the index, they get stored with the TypedEntity!
//NOTE: we need to store the entity id in a seperate field to the normal id when using revisions
t.AddOrUpdateField(FixedIndexedFields.EntityId, new Lazy <string>(() => s.Id.Value.ToString()));
s.MapRelations(t, MappingContext.Engine);
t.SubIndexOperations.Add(MappingContext.Engine.Map <EntitySchema, NestedHiveIndexOperation>(s.EntitySchema));
ExamineHelper.SetTimestampsOnEntityAndIndexFields(t.Fields, s);
//ensure the IsLatest flag is set, this is only used if we're supporting Revisions. If we change
//to a NullRevisionFactory then only one TypedEntity will ever exist.
t.Fields.Add(FixedRevisionIndexFields.IsLatest, new ItemField(1)
{
DataType = FieldDataType.Int
});
});
}
public override LazyDictionary <string, ItemField> GetValue(TypedEntity source)
{
var d = new LazyDictionary <string, ItemField>();
foreach (var a in source.Attributes)
{
if (a.Values.Count == 1)
{
StoreFieldValue(a.AttributeDefinition.AttributeType.SerializationType,
FixedAttributeIndexFields.AttributePrefix + a.AttributeDefinition.Alias,
a.DynamicValue,
d);
}
else if (a.Values.Count > 1)
{
//we need to put multiple values in the index with dot notation
foreach (var val in a.Values)
{
var key = FixedAttributeIndexFields.AttributePrefix + a.AttributeDefinition.Alias + "." + val.Key;
StoreFieldValue(a.AttributeDefinition.AttributeType.SerializationType,
key,
val.Value,
d);
}
}
//put attribute alias/name/id in there
FixedAttributeIndexFields.AddAttributeAlias(d, a);
//FixedAttributeIndexFields.AddAttributeName(d, a);
FixedAttributeIndexFields.AddAttributeId(d, a);
}
//Get the parent Id.
//TODO: We should support all relation types in some magical way
foreach (var r in source.RelationProxies.GetParentRelations(FixedRelationTypes.DefaultRelationType))
{
d.AddOrUpdate(FixedIndexedFields.ParentId, new ItemField(r.Item.SourceId.Value.ToString()));
}
d.AddOrUpdate(FixedIndexedFields.SchemaId,
new Lazy <ItemField>(() => new ItemField(source.EntitySchema.Id.Value.ToString())),
(k, i) => new Lazy <ItemField>(() => new ItemField(source.EntitySchema.Id.Value.ToString())));
d.Add(FixedIndexedFields.SchemaAlias, new ItemField(source.EntitySchema.Alias));
d.AddOrUpdate(FixedIndexedFields.SchemaName, new ItemField(source.EntitySchema.Name));
d.AddOrUpdate(FixedIndexedFields.SchemaType, new ItemField(source.EntitySchema.SchemaType));
ExamineHelper.SetTimestampsOnEntityAndIndexFields(d, source);
return(d);
}
public override LazyDictionary <string, ItemField> GetValue(AttributeType source)
{
////TODO: This is purely a hack in order to get the installer working with Examine, its also a required hack until the underlying
//// issue is fixed: Currently we need to make sure that the properties of an Attribute type remain constant in the repository unless
//// that property is explicitly changed. This is mostly to do with the RenderTypeProvider property as we don't want it to be overwritten
//// with a empty value when a system attribute type is committed.
//if (!source.Id.IsNullValueOrEmpty())
//{
// var existing = _helper.PerformGet<AttributeType>(true, LuceneIndexer.IndexNodeIdFieldName, source.Id);
// var destination = existing.LastOrDefault();
// if (destination != null)
// {
// //This copies across all changed (Dirty) properties from the source to the destination except for a few of the properties
// destination.SetAllChangedProperties<AttributeType, object>(source,
// x => x.Id,
// x => x.ConcurrencyToken,
// x => x.PersistenceMetadata,
// x => x.UtcCreated,
// x => x.UtcModified,
// x => x.UtcStatusChanged);
// //now that all properties are updated that have changed, overwrite the 'source' object with the destination so it can be mapped
// //to the index fields properly to be stored.
// source = destination;
// }
//}
//convert the source to a dictionary object ignoring some of its properties
var d = source.ToDictionary <AttributeType, object, object>(
x => x.Id,
x => x.SerializationType,
x => x.ConcurrencyToken);
//add the serialization FQN so we can re-create it later
d.Add(FixedIndexedFields.SerializationType, source.SerializationType.GetType().FullName);
var output = new LazyDictionary <string, ItemField>();
foreach (var i in d)
{
output.Add(i.Key, new ItemField(i.Value));
}
ExamineHelper.SetTimestampsOnEntityAndIndexFields(output, source);
return(output);
}
public override LazyDictionary <string, ItemField> GetValue(AttributeGroup source)
{
//convert the source to a dictionary object ignoring some of its properties
var d = source.ToDictionary <AttributeGroup, object, object>(
x => x.Id,
x => x.ConcurrencyToken);
var output = new LazyDictionary <string, ItemField>();
foreach (var i in d)
{
output.Add(i.Key, new ItemField(i.Value));
}
ExamineHelper.SetTimestampsOnEntityAndIndexFields(output, source);
return(output);
}
public override LazyDictionary <string, ItemField> GetValue(AttributeDefinition source)
{
//convert the source to a dictionary object ignoring some of its properties
var d = source.ToDictionary <AttributeDefinition, object, object>(
x => x.Id,
x => x.AttributeGroup,
x => x.AttributeType,
x => x.ConcurrencyToken);
var output = new LazyDictionary <string, ItemField>();
foreach (var i in d)
{
output.Add(i.Key, new ItemField(i.Value));
}
ExamineHelper.SetTimestampsOnEntityAndIndexFields(output, source);
//add some lazy delegates for the ids of the group/attribute type
output.Add(FixedIndexedFields.GroupId, new Lazy <ItemField>(() => new ItemField(source.AttributeGroup.Id.Value)));
output.Add(FixedIndexedFields.AttributeTypeId, new Lazy <ItemField>(() => new ItemField(source.AttributeType.Id.Value)));
return(output);
}