// no MapAll - take care
private void Map(IContentType source, DocumentTypeDisplay target, MapperContext context)
{
MapTypeToDisplayBase <DocumentTypeDisplay, PropertyTypeDisplay>(source, target);
target.AllowCultureVariant = source.VariesByCulture();
target.AllowSegmentVariant = source.VariesBySegment();
target.ContentApps = _commonMapper.GetContentApps(source);
//sync templates
target.AllowedTemplates = context.MapEnumerable <ITemplate, EntityBasic>(source.AllowedTemplates);
if (source.DefaultTemplate != null)
{
target.DefaultTemplate = context.Map <EntityBasic>(source.DefaultTemplate);
}
//default listview
target.ListViewEditorName = Constants.Conventions.DataTypes.ListViewPrefix + "Content";
if (string.IsNullOrEmpty(source.Alias))
{
return;
}
var name = Constants.Conventions.DataTypes.ListViewPrefix + source.Alias;
if (_dataTypeService.GetDataType(name) != null)
{
target.ListViewEditorName = name;
}
}
// no MapAll - take care
private void Map(IContentType source, DocumentTypeDisplay target, MapperContext context)
{
MapTypeToDisplayBase <DocumentTypeDisplay, PropertyTypeDisplay>(source, target);
if (source is IContentTypeWithHistoryCleanup sourceWithHistoryCleanup)
{
target.HistoryCleanup = new HistoryCleanupViewModel
{
PreventCleanup = sourceWithHistoryCleanup.HistoryCleanup?.PreventCleanup ?? false,
KeepAllVersionsNewerThanDays =
sourceWithHistoryCleanup.HistoryCleanup?.KeepAllVersionsNewerThanDays,
KeepLatestVersionPerDayForDays =
sourceWithHistoryCleanup.HistoryCleanup?.KeepLatestVersionPerDayForDays,
GlobalKeepAllVersionsNewerThanDays =
_contentSettings.ContentVersionCleanupPolicy.KeepAllVersionsNewerThanDays,
GlobalKeepLatestVersionPerDayForDays =
_contentSettings.ContentVersionCleanupPolicy.KeepLatestVersionPerDayForDays,
GlobalEnableCleanup = _contentSettings.ContentVersionCleanupPolicy.EnableCleanup,
};
}
target.AllowCultureVariant = source.VariesByCulture();
target.AllowSegmentVariant = source.VariesBySegment();
target.ContentApps = _commonMapper.GetContentAppsForEntity(source);
// sync templates
if (source.AllowedTemplates is not null)
{
target.AllowedTemplates =
context.MapEnumerable <ITemplate, EntityBasic>(source.AllowedTemplates).WhereNotNull();
}
if (source.DefaultTemplate != null)
{
target.DefaultTemplate = context.Map <EntityBasic>(source.DefaultTemplate);
}
// default listview
target.ListViewEditorName = Constants.Conventions.DataTypes.ListViewPrefix + "Content";
if (string.IsNullOrEmpty(source.Alias))
{
return;
}
var name = Constants.Conventions.DataTypes.ListViewPrefix + source.Alias;
if (_dataTypeService.GetDataType(name) != null)
{
target.ListViewEditorName = name;
}
}
public void Can_Perform_Add_On_ContentTypeRepository_After_Model_Mapping()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
ContentTypeRepository repository = ContentTypeRepository;
// Act
var contentType = (IContentType)ContentTypeBuilder.CreateSimpleContentType2("test", "Test", propertyGroupAlias: "testGroup", propertyGroupName: "testGroup");
Assert.AreEqual(4, contentType.PropertyTypes.Count());
// remove all templates - since they are not saved, they would break the (!) mapping code
contentType.AllowedTemplates = new ITemplate[0];
// there is NO mapping from display to contentType, but only from save
// to contentType, so if we want to test, let's to it properly!
DocumentTypeDisplay display = Mapper.Map <DocumentTypeDisplay>(contentType);
DocumentTypeSave save = MapToContentTypeSave(display);
IContentType mapped = Mapper.Map <IContentType>(save);
Assert.AreEqual(4, mapped.PropertyTypes.Count());
repository.Save(mapped);
Assert.AreEqual(4, mapped.PropertyTypes.Count());
// re-get
contentType = repository.Get(mapped.Id);
Assert.AreEqual(4, contentType.PropertyTypes.Count());
// Assert
Assert.That(contentType.HasIdentity, Is.True);
Assert.That(contentType.PropertyGroups.All(x => x.HasIdentity), Is.True);
Assert.That(contentType.PropertyTypes.All(x => x.HasIdentity), Is.True);
Assert.That(contentType.Path.Contains(","), Is.True);
Assert.That(contentType.SortOrder, Is.GreaterThan(0));
Assert.That(contentType.PropertyGroups.ElementAt(0).Name == "testGroup", Is.True);
int groupId = contentType.PropertyGroups.ElementAt(0).Id;
IPropertyType[] propertyTypes = contentType.PropertyTypes.ToArray();
Assert.AreEqual("gen", propertyTypes[0].Alias); // just to be sure
Assert.IsNull(propertyTypes[0].PropertyGroupId);
Assert.IsTrue(propertyTypes.Skip(1).All(x => x.PropertyGroupId.Value == groupId));
Assert.That(propertyTypes.Single(x => x.Alias == "title").LabelOnTop, Is.True);
}
}
// this is for tests only because it makes no sense at all to have such a
// mapping defined, we only need it for the weird tests that use it
private DocumentTypeSave MapToContentTypeSave(DocumentTypeDisplay display)
{
return(new DocumentTypeSave
{
// EntityBasic
Name = display.Name,
Icon = display.Icon,
Trashed = display.Trashed,
Key = display.Key,
ParentId = display.ParentId,
//Alias = display.Alias,
Path = display.Path,
//AdditionalData = display.AdditionalData,
HistoryCleanup = display.HistoryCleanup,
// ContentTypeBasic
Alias = display.Alias,
UpdateDate = display.UpdateDate,
CreateDate = display.CreateDate,
Description = display.Description,
Thumbnail = display.Thumbnail,
// ContentTypeSave
CompositeContentTypes = display.CompositeContentTypes,
IsContainer = display.IsContainer,
AllowAsRoot = display.AllowAsRoot,
AllowedTemplates = display.AllowedTemplates.Select(x => x.Alias),
AllowedContentTypes = display.AllowedContentTypes,
DefaultTemplate = display.DefaultTemplate == null ? null : display.DefaultTemplate.Alias,
Groups = display.Groups.Select(x => new PropertyGroupBasic <PropertyTypeBasic>
{
Inherited = x.Inherited,
Id = x.Id,
Key = x.Key,
Type = x.Type,
Name = x.Name,
Alias = x.Alias,
SortOrder = x.SortOrder,
Properties = x.Properties
}).ToArray()
});
}
// no MapAll - take care
private void Map(DocumentTypeSave source, DocumentTypeDisplay target, MapperContext context)
{
MapTypeToDisplayBase <DocumentTypeSave, PropertyTypeBasic, DocumentTypeDisplay, PropertyTypeDisplay>(
source,
target,
context);
// sync templates
IEnumerable <string?> destAllowedTemplateAliases = target.AllowedTemplates.Select(x => x.Alias);
// if the dest is set and it's the same as the source, then don't change
if (source.AllowedTemplates is not null &&
destAllowedTemplateAliases.SequenceEqual(source.AllowedTemplates) == false)
{
IEnumerable <ITemplate>?templates = _fileService.GetTemplates(source.AllowedTemplates.ToArray());
target.AllowedTemplates = source.AllowedTemplates
.Select(x =>
{
ITemplate?template = templates?.SingleOrDefault(t => t.Alias == x);
return(template != null
? context.Map <EntityBasic>(template)
: null);
})
.WhereNotNull()
.ToArray();
}
if (source.DefaultTemplate.IsNullOrWhiteSpace() == false)
{
// if the dest is set and it's the same as the source, then don't change
if (target.DefaultTemplate == null || source.DefaultTemplate != target.DefaultTemplate.Alias)
{
ITemplate?template = _fileService.GetTemplate(source.DefaultTemplate);
target.DefaultTemplate = template == null ? null : context.Map <EntityBasic>(template);
}
}
else
{
target.DefaultTemplate = null;
}
}
public void Can_Perform_Update_On_ContentTypeRepository_After_Model_Mapping()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
ContentTypeRepository repository = ContentTypeRepository;
// Act
IContentType contentType = repository.Get(_textpageContentType.Id);
// there is NO mapping from display to contentType, but only from save
// to contentType, so if we want to test, let's to it properly!
DocumentTypeDisplay display = Mapper.Map <DocumentTypeDisplay>(contentType);
DocumentTypeSave save = MapToContentTypeSave(display);
// modify...
save.Thumbnail = "Doc2.png";
PropertyGroupBasic <PropertyTypeBasic> contentGroup = save.Groups.Single(x => x.Name == "Content");
contentGroup.Properties = contentGroup.Properties.Concat(new[]
{
new PropertyTypeBasic
{
Alias = "subtitle",
Label = "Subtitle",
Description = "Optional Subtitle",
Validation = new PropertyTypeValidation
{
Mandatory = false,
Pattern = string.Empty
},
SortOrder = 1,
DataTypeId = -88,
LabelOnTop = true
}
});
IContentType mapped = Mapper.Map(save, contentType);
// just making sure
Assert.AreEqual(mapped.Thumbnail, "Doc2.png");
Assert.IsTrue(mapped.PropertyTypes.Any(x => x.Alias == "subtitle"));
Assert.IsTrue(mapped.PropertyTypes.Single(x => x.Alias == "subtitle").LabelOnTop);
repository.Save(mapped);
bool dirty = mapped.IsDirty();
// re-get
contentType = repository.Get(_textpageContentType.Id);
// Assert
Assert.That(contentType.HasIdentity, Is.True);
Assert.That(dirty, Is.False);
Assert.That(contentType.Thumbnail, Is.EqualTo("Doc2.png"));
Assert.That(contentType.PropertyTypes.Any(x => x.Alias == "subtitle"), Is.True);
Assert.That(contentType.PropertyTypes.Single(x => x.Alias == "subtitle").LabelOnTop, Is.True);
foreach (IPropertyType propertyType in contentType.PropertyTypes)
{
Assert.IsTrue(propertyType.HasIdentity);
Assert.Greater(propertyType.Id, 0);
}
}
}
