private static void MapHistoryCleanup(DocumentTypeSave source, IContentTypeWithHistoryCleanup target) { // If source history cleanup is null we don't have to map all properties if (source.HistoryCleanup is null) { target.HistoryCleanup = null; return; } // We need to reset the dirty properties, because it is otherwise true, just because the json serializer has set properties target.HistoryCleanup !.ResetDirtyProperties(false); if (target.HistoryCleanup.PreventCleanup != source.HistoryCleanup.PreventCleanup) { target.HistoryCleanup.PreventCleanup = source.HistoryCleanup.PreventCleanup; } if (target.HistoryCleanup.KeepAllVersionsNewerThanDays != source.HistoryCleanup.KeepAllVersionsNewerThanDays) { target.HistoryCleanup.KeepAllVersionsNewerThanDays = source.HistoryCleanup.KeepAllVersionsNewerThanDays; } if (target.HistoryCleanup.KeepLatestVersionPerDayForDays != source.HistoryCleanup.KeepLatestVersionPerDayForDays) { target.HistoryCleanup.KeepLatestVersionPerDayForDays = source.HistoryCleanup.KeepLatestVersionPerDayForDays; } }
public ActionResult <DocumentTypeDisplay> PostSave(DocumentTypeSave contentTypeSave) { //Before we send this model into this saving/mapping pipeline, we need to do some cleanup on variations. //If the doc type does not allow content variations, we need to update all of it's property types to not allow this either //else we may end up with ysods. I'm unsure if the service level handles this but we'll make sure it is updated here if (!contentTypeSave.AllowCultureVariant) { foreach (var prop in contentTypeSave.Groups.SelectMany(x => x.Properties)) { prop.AllowCultureVariant = false; } } var savedCt = PerformPostSave <DocumentTypeDisplay, DocumentTypeSave, PropertyTypeBasic>( contentTypeSave: contentTypeSave, getContentType: i => _contentTypeService.Get(i), saveContentType: type => _contentTypeService.Save(type), beforeCreateNew: ctSave => { //create a default template if it doesn't exist -but only if default template is == to the content type if (ctSave.DefaultTemplate.IsNullOrWhiteSpace() == false && ctSave.DefaultTemplate == ctSave.Alias) { var template = CreateTemplateForContentType(ctSave.Alias, ctSave.Name); // If the alias has been manually updated before the first save, // make sure to also update the first allowed template, as the // name will come back as a SafeAlias of the document type name, // not as the actual document type alias. // For more info: http://issues.umbraco.org/issue/U4-11059 if (ctSave.DefaultTemplate != template.Alias) { var allowedTemplates = ctSave.AllowedTemplates.ToArray(); if (allowedTemplates.Any()) { allowedTemplates[0] = template.Alias; } ctSave.AllowedTemplates = allowedTemplates; } //make sure the template alias is set on the default and allowed template so we can map it back ctSave.DefaultTemplate = template.Alias; } }); if (!(savedCt.Result is null)) { return(savedCt.Result); } var display = _umbracoMapper.Map <DocumentTypeDisplay>(savedCt.Value); display.AddSuccessNotification( _localizedTextService.Localize("speechBubbles", "contentTypeSavedHeader"), string.Empty); return(display); }
// no MapAll - take care private void Map(DocumentTypeSave source, IContentType target, MapperContext context) { MapSaveToTypeBase <DocumentTypeSave, PropertyTypeBasic>(source, target, context); MapComposition(source, target, alias => _contentTypeService.Get(alias)); target.AllowedTemplates = source.AllowedTemplates .Where(x => x != null) .Select(_fileService.GetTemplate) .Where(x => x != null) .ToArray(); target.SetDefaultTemplate(source.DefaultTemplate == null ? null : _fileService.GetTemplate(source.DefaultTemplate)); }
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); } }
public DocumentTypeDisplay PostSave(DocumentTypeSave contentTypeSave) { var savedCt = PerformPostSave <IContentType, DocumentTypeDisplay, DocumentTypeSave, PropertyTypeBasic>( contentTypeSave: contentTypeSave, getContentType: i => Services.ContentTypeService.GetContentType(i), saveContentType: type => Services.ContentTypeService.Save(type), beforeCreateNew: ctSave => { //create a default template if it doesnt exist -but only if default template is == to the content type if (ctSave.DefaultTemplate.IsNullOrWhiteSpace() == false && ctSave.DefaultTemplate == ctSave.Alias) { var template = CreateTemplateForContentType(ctSave.Alias, ctSave.Name); // If the alias has been manually updated before the first save, // make sure to also update the first allowed template, as the // name will come back as a SafeAlias of the document type name, // not as the actual document type alias. // For more info: http://issues.umbraco.org/issue/U4-11059 if (ctSave.DefaultTemplate != template.Alias) { var allowedTemplates = ctSave.AllowedTemplates.ToArray(); if (allowedTemplates.Any()) { allowedTemplates[0] = template.Alias; } ctSave.AllowedTemplates = allowedTemplates; } //make sure the template alias is set on the default and allowed template so we can map it back ctSave.DefaultTemplate = template.Alias; } }); var display = Mapper.Map <DocumentTypeDisplay>(savedCt); display.AddSuccessNotification( Services.TextService.Localize("speechBubbles/contentTypeSavedHeader"), string.Empty); return(display); }
// 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 DocumentTypeDisplay PostSave(DocumentTypeSave contentTypeSave) { var savedCt = PerformPostSave <IContentType, DocumentTypeDisplay, DocumentTypeSave, PropertyTypeBasic>( contentTypeSave: contentTypeSave, getContentType: i => Services.ContentTypeService.GetContentType(i), saveContentType: type => Services.ContentTypeService.Save(type), beforeCreateNew: ctSave => { //create a default template if it doesnt exist -but only if default template is == to the content type if (ctSave.DefaultTemplate.IsNullOrWhiteSpace() == false && ctSave.DefaultTemplate == ctSave.Alias) { var template = Services.FileService.GetTemplate(ctSave.Alias); if (template == null) { var tryCreateTemplate = Services.FileService.CreateTemplateForContentType(ctSave.Alias, ctSave.Name); if (tryCreateTemplate == false) { Logger.Warn <ContentTypeController>( "Could not create a template for the Content Type: {0}, status: {1}", () => ctSave.Alias, () => tryCreateTemplate.Result.StatusType); } template = tryCreateTemplate.Result.Entity; } //make sure the template alias is set on the default and allowed template so we can map it back ctSave.DefaultTemplate = template.Alias; } }); var display = Mapper.Map <DocumentTypeDisplay>(savedCt); display.AddSuccessNotification( Services.TextService.Localize("speechBubbles/contentTypeSavedHeader"), string.Empty); return(display); }
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); } } }
public void PropertyGroupBasic_To_PropertyGroup() { var dataType = new DataType(Services.GetRequiredService <LabelPropertyEditor>(), _serializer) { Name = "TODO" }; _dataTypeService.Save(dataType); var basic = new PropertyGroupBasic <PropertyTypeBasic> { Id = 222, Alias = "group1", Name = "Group 1", SortOrder = 1, Properties = new[] { new PropertyTypeBasic { Id = 33, SortOrder = 1, Alias = "prop1", Description = "property 1", DataTypeId = dataType.Id, GroupId = 222, Label = "Prop 1", Validation = new PropertyTypeValidation { Mandatory = true, Pattern = null } }, new PropertyTypeBasic { Id = 34, SortOrder = 2, Alias = "prop2", Description = "property 2", DataTypeId = dataType.Id, GroupId = 222, Label = "Prop 2", Validation = new PropertyTypeValidation { Mandatory = false, Pattern = null } } } }; var contentType = new DocumentTypeSave { Id = 0, ParentId = -1, Alias = "alias", AllowedTemplates = Enumerable.Empty <string>(), Groups = new[] { basic } }; // proper group properties mapping takes place when mapping the content type, // not when mapping the group - because of inherited properties and such // var result = Mapper.Map<PropertyGroup>(basic); var result = _sut.Map <IContentType>(contentType).PropertyGroups[0]; Assert.AreEqual(basic.Name, result.Name); Assert.AreEqual(basic.Id, result.Id); Assert.AreEqual(basic.SortOrder, result.SortOrder); Assert.AreEqual(basic.Properties.Count(), result.PropertyTypes.Count()); }