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 EntitySnapshotToContentEditorModel(AbstractFluentMappingEngine engine) : base(engine) { MappingContext .CreateUsing(x => MappingContext.Engine.Map <Revision <TypedEntity>, TContentModel>(x.Revision)) .AfterMap( (source, dest) => { dest.UtcPublishedDate = source.PublishedDate(); }); }
public RevisionToContentEditorModel(AbstractFluentMappingEngine engine) : base(engine) { MappingContext .CreateUsing(x => { var output = MappingContext.Engine.Map <TypedEntity, TContentModel>(x.Item); output.RevisionId = x.MetaData.Id; return(output); }); }
public ContentEditorModelToRevision(AbstractFluentMappingEngine engine) : base(engine) { MappingContext .CreateUsing(x => new Revision <TypedEntity>() { Item = MappingContext.Engine.Map <TContentModel, TypedEntity>(x), //TODO: Is this correctly mapped ?? MetaData = new RevisionData(x.RevisionId, FixedStatusTypes.Draft) }); }
public DocumentTypePropertyToAttributeDefinition( AbstractFluentMappingEngine engine, MapResolverContext resolverContext, bool mapAttributeGroup = true) : base(engine) { _resolverContext = resolverContext; MappingContext .CreateUsing(x => new AttributeDefinition(x.Alias, x.Name)) .MapMemberFrom(x => x.Ordinal, x => x.SortOrder) .MapMemberUsing(x => x.AttributeType, new DocumentTypePropertyToAttributeType(engine, _resolverContext)) .MapMemberUsing(x => x.AttributeGroup, new DocumentTypePropertyToAttributeGroup(engine, _resolverContext, !mapAttributeGroup)) .ForMember(x => x.UtcModified, opt => opt.MapUsing <UtcModifiedMapper>()) .ForMember(x => x.UtcCreated, opt => opt.MapUsing <UtcCreatedMapper>()) .AfterMap((source, dest) => { if (dest.AttributeType == null) { throw new InvalidOperationException("The DataType property of the DocumentTypeProperty object cannot be null when mapping from DocumentTypeProperty -> AttributeDefinition"); } //This will check if the pre-value editor has overriding field capabilities. //If it does, it will persist these values to the RenderTypeProviderConfigOverride instead of the underlying //data type. if (source.PreValueEditor != null) { var preValueMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => source.PreValueEditor, source.GetType()); //checks if the model contains overrides var hasOverrides = preValueMetadata .Properties .Any(metaProp => metaProp.AdditionalValues.ContainsKey(RebelMetadataAdditionalInfo.AllowDocumentTypePropertyOverride.ToString())); //if this pre-value model has overrides, then persist them if (hasOverrides) { dest.RenderTypeProviderConfigOverride = source.PreValueEditor.GetSerializedValue(); } } }); }
public DataTypeToAttributeType(AbstractFluentMappingEngine engine, Action <TInput, AttributeType> additionalAfterMap = null) : base(engine) { MappingContext .CreateUsing(x => { var typeRegistry = AttributeTypeRegistry.Current; if (typeRegistry != null) { var existing = typeRegistry.TryGetAttributeType(x.Name).Result; if (existing != null) { return(existing); } } return(new AttributeType() { Id = x.Id }); }) // Ignore the Id. In the CreateUsing, we either return the AttributeType from the registry with its inferred Id, // or we set the Id there from the source. .ForMember(x => x.Id, opt => opt.Ignore()) .ForMember(x => x.UtcCreated, opt => opt.MapUsing <UtcCreatedMapper>()) .ForMember(x => x.UtcModified, opt => opt.MapUsing <UtcModifiedMapper>()) .AfterMap((source, dest) => { if (string.IsNullOrEmpty(dest.Alias)) { dest.Alias = source.Name.ToRebelAlias(); } //TODO: Detect serialization type from DataType dest.SerializationType = new LongStringSerializationType(); if (additionalAfterMap != null) { additionalAfterMap(source, dest); } }); }
public EntitySchemaToSchemaEditorModel( AbstractFluentMappingEngine engine, Func <EntitySchema, TEditorModel> createWith, Action <EntitySchema, TEditorModel> additionalAfterMap = null) : base(engine) { MappingContext .CreateUsing(createWith) .MapMemberFrom(x => x.Thumbnail, x => x.GetXmlConfigProperty("thumb")) .MapMemberFrom(x => x.AllowedChildIds, x => x.GetXmlPropertyAsList <HiveId>("allowed-children")) .MapMemberFrom(x => x.Icon, x => x.GetXmlConfigProperty("icon")) .MapMemberFrom(x => x.Thumbnail, x => x.GetXmlConfigProperty("thumb")) .MapMemberFrom(x => x.DefinedTabs, x => MappingContext.Engine.Map <IEnumerable <AttributeGroup>, HashSet <Tab> >(x.AttributeGroups.ToArray())) .MapMemberFrom(x => x.Description, x => x.GetXmlConfigProperty("description")) .MapMemberFrom(x => x.IsAbstract, x => x.GetXmlConfigProperty("is-abstract") != null && bool.Parse(x.GetXmlConfigProperty("is-abstract"))) .AfterMap((from, to) => { // Commented out the below as working on multi-inheritance and the blow assumes one parent only (MB - 2011-11-15) //var firstParentFound = //from.RelationProxies.GetParentRelations(FixedRelationTypes.DefaultRelationType). // FirstOrDefault(); //if (firstParentFound != null && !firstParentFound.Item.SourceId.IsNullValueOrEmpty()) // to.ParentId = firstParentFound.Item.SourceId; //first, map the properties from the attribute definition (but not the special fields) to.Properties.Clear(); from.AttributeDefinitions //.Where(x => !FixedAttributeDefinitionAliases.AllAliases.Contains(x.Alias)) .ForEach(y => to.Properties.Add( MappingContext.Engine.Map <AttributeDefinition, DocumentTypeProperty>(y))); //set the available tabs select list to.AvailableTabs = new List <SelectListItem>( to.DefinedTabs.Where(x => !x.Id.IsNullValueOrEmpty()).OrderBy(x => x.SortOrder) .Select(x => new SelectListItem { Text = x.Name, Value = x.Id.ToString() })) .ToArray(); //set the inherit from list to.InheritFromIds = from.RelationProxies.GetParentRelations(FixedRelationTypes.DefaultRelationType).Select( x => x.Item.SourceId); var merged = from as CompositeEntitySchema; if (merged != null) { to.InheritedProperties.Clear(); merged.InheritedAttributeDefinitions .ForEach(y => to.InheritedProperties.Add(MappingContext.Engine.Map <AttributeDefinition, DocumentTypeProperty>(y))); to.InheritedTabs = MappingContext.Engine.Map <IEnumerable <AttributeGroup>, HashSet <Tab> >( merged.InheritedAttributeGroups.ToArray()); } if (additionalAfterMap != null) { additionalAfterMap(from, to); } }); }