// helpers
private void MapUserGroupBasic(UserGroupBasic target, IEnumerable <string> sourceAllowedSections, int?sourceStartContentId, int?sourceStartMediaId, MapperContext context)
{
var allSections = _sectionService.GetSections();
target.Sections = context.MapEnumerable <ISection, Section>(allSections.Where(x => sourceAllowedSections.Contains(x.Alias)));
if (sourceStartMediaId > 0)
{
target.MediaStartNode = context.Map <EntityBasic>(_entityService.Get(sourceStartMediaId.Value, UmbracoObjectTypes.Media));
}
else if (sourceStartMediaId == -1)
{
target.MediaStartNode = CreateRootNode(_textService.Localize("media/mediaRoot"));
}
if (sourceStartContentId > 0)
{
target.ContentStartNode = context.Map <EntityBasic>(_entityService.Get(sourceStartContentId.Value, UmbracoObjectTypes.Document));
}
else if (sourceStartContentId == -1)
{
target.ContentStartNode = CreateRootNode(_textService.Localize("content/contentRoot"));
}
if (target.Icon.IsNullOrWhiteSpace())
{
target.Icon = Constants.Icons.UserGroup;
}
}
// 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();
//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;
}
}
// Umbraco.Code.MapAll
private void Map(ContentItemDisplay source, ContentItemDisplayWithSchedule target, MapperContext context)
{
target.AllowedActions = source.AllowedActions;
target.AllowedTemplates = source.AllowedTemplates;
target.AllowPreview = source.AllowPreview;
target.ContentApps = source.ContentApps;
target.ContentDto = source.ContentDto;
target.ContentTypeAlias = source.ContentTypeAlias;
target.ContentTypeId = source.ContentTypeId;
target.ContentTypeKey = source.ContentTypeKey;
target.ContentTypeName = source.ContentTypeName;
target.DocumentType = source.DocumentType;
target.Errors = source.Errors;
target.Icon = source.Icon;
target.Id = source.Id;
target.IsBlueprint = source.IsBlueprint;
target.IsChildOfListView = source.IsChildOfListView;
target.IsContainer = source.IsContainer;
target.IsElement = source.IsElement;
target.Key = source.Key;
target.Owner = source.Owner;
target.ParentId = source.ParentId;
target.Path = source.Path;
target.PersistedContent = source.PersistedContent;
target.SortOrder = source.SortOrder;
target.TemplateAlias = source.TemplateAlias;
target.TemplateId = source.TemplateId;
target.Trashed = source.Trashed;
target.TreeNodeUrl = source.TreeNodeUrl;
target.Udi = source.Udi;
target.UpdateDate = source.UpdateDate;
target.Updater = source.Updater;
target.Urls = source.Urls;
target.Variants = context.MapEnumerable <ContentVariantDisplay, ContentVariantScheduleDisplay>(source.Variants);
}
// Umbraco.Code.MapAll -Notifications -Udi -Icon -IsCurrentUser -Trashed -ResetPasswordValue
// Umbraco.Code.MapAll -Alias -AdditionalData
private void Map(IUser source, UserDisplay target, MapperContext context)
{
target.AvailableCultures = _textService.GetSupportedCultures().ToDictionary(x => x.Name, x => x.DisplayName);
target.Avatars = source.GetUserAvatarUrls(_appCaches.RuntimeCache);
target.CalculatedStartContentIds = GetStartNodes(source.CalculateContentStartNodeIds(_entityService), UmbracoObjectTypes.Document, "content/contentRoot", context);
target.CalculatedStartMediaIds = GetStartNodes(source.CalculateMediaStartNodeIds(_entityService), UmbracoObjectTypes.Media, "media/mediaRoot", context);
target.CreateDate = source.CreateDate;
target.Culture = source.GetUserCulture(_textService, _globalSettings).ToString();
target.Email = source.Email;
target.EmailHash = source.Email.ToLowerInvariant().Trim().GenerateHash();
target.FailedPasswordAttempts = source.FailedPasswordAttempts;
target.Id = source.Id;
target.Key = source.Key;
target.LastLockoutDate = source.LastLockoutDate;
target.LastLoginDate = source.LastLoginDate == default ? null : (DateTime?)source.LastLoginDate;
target.LastPasswordChangeDate = source.LastPasswordChangeDate;
target.Name = source.Name;
target.Navigation = CreateUserEditorNavigation();
target.ParentId = -1;
target.Path = "-1," + source.Id;
target.StartContentIds = GetStartNodes(source.StartContentIds.ToArray(), UmbracoObjectTypes.Document, "content/contentRoot", context);
target.StartMediaIds = GetStartNodes(source.StartMediaIds.ToArray(), UmbracoObjectTypes.Media, "media/mediaRoot", context);
target.UpdateDate = source.UpdateDate;
target.UserGroups = context.MapEnumerable <IReadOnlyUserGroup, UserGroupBasic>(source.Groups);
target.Username = source.Username;
target.UserState = source.UserState;
}
// Umbraco.Code.MapAll -AllowPreview -Errors -PersistedContent
private void Map(IContent source, ContentItemDisplay target, MapperContext context)
{
target.AllowedActions = GetActions(source);
target.AllowedTemplates = GetAllowedTemplates(source);
target.ContentApps = _commonMapper.GetContentApps(source);
target.ContentTypeId = source.ContentType.Id;
target.ContentTypeKey = source.ContentType.Key;
target.ContentTypeAlias = source.ContentType.Alias;
target.ContentTypeName = _localizedTextService.UmbracoDictionaryTranslate(source.ContentType.Name);
target.DocumentType = _commonMapper.GetContentType(source, context);
target.Icon = source.ContentType.Icon;
target.Id = source.Id;
target.IsBlueprint = source.Blueprint;
target.IsChildOfListView = DetermineIsChildOfListView(source, context);
target.IsContainer = source.ContentType.IsContainer;
target.IsElement = source.ContentType.IsElement;
target.Key = source.Key;
target.Owner = _commonMapper.GetOwner(source, context);
target.ParentId = source.ParentId;
target.Path = source.Path;
target.SortOrder = source.SortOrder;
target.TemplateAlias = GetDefaultTemplate(source);
target.TemplateId = source.TemplateId ?? default;
target.Trashed = source.Trashed;
target.TreeNodeUrl = _commonMapper.GetTreeNodeUrl <ContentTreeController>(source);
target.Udi = Udi.Create(source.Blueprint ? Constants.UdiEntityType.DocumentBlueprint : Constants.UdiEntityType.Document, source.Key);
target.UpdateDate = source.UpdateDate;
target.Updater = _commonMapper.GetCreator(source, context);
target.Urls = GetUrls(source);
target.Variants = _contentVariantMapper.Map(source, context);
target.ContentDto = new ContentPropertyCollectionDto();
target.ContentDto.Properties = context.MapEnumerable <Property, ContentPropertyDto>(source.Properties);
}
private IEnumerable <PropertyEditorBasic> MapAvailableEditors(IDataType source, MapperContext context)
{
var properties = _propertyEditors
.Where(x => !x.IsDeprecated || _contentSettings.ShowDeprecatedPropertyEditors || source.EditorAlias == x.Alias)
.OrderBy(x => x.Name);
return(context.MapEnumerable <IDataEditor, PropertyEditorBasic>(properties));
}
// no MapAll - relies on the non-generic method
private void MapTypeToDisplayBase <TSource, TSourcePropertyType, TTarget, TTargetPropertyType>(TSource source, TTarget target, MapperContext context)
where TSource : ContentTypeSave <TSourcePropertyType>
where TSourcePropertyType : PropertyTypeBasic
where TTarget : ContentTypeCompositionDisplay <TTargetPropertyType>
where TTargetPropertyType : PropertyTypeDisplay
{
MapTypeToDisplayBase(source, target);
target.Groups = context.MapEnumerable <PropertyGroupBasic <TSourcePropertyType>, PropertyGroupDisplay <TTargetPropertyType> >(source.Groups);
}
// Umbraco.Code.MapAll -AllowPreview -Errors -PersistedContent
private void Map <TVariant>(IContent source, ContentItemDisplay <TVariant> target, MapperContext context)
where TVariant : ContentVariantDisplay
{
// Both GetActions and DetermineIsChildOfListView use parent, so get it once here
// Parent might already be in context, so check there before using content service
IContent?parent;
if (context.Items.TryGetValue("Parent", out var parentObj) &&
parentObj is IContent typedParent)
{
parent = typedParent;
}
else
{
parent = _contentService.GetParent(source);
}
target.AllowedActions = GetActions(source, parent, context);
target.AllowedTemplates = GetAllowedTemplates(source);
target.ContentApps = _commonMapper.GetContentAppsForEntity(source);
target.ContentTypeId = source.ContentType.Id;
target.ContentTypeKey = source.ContentType.Key;
target.ContentTypeAlias = source.ContentType.Alias;
target.ContentTypeName =
_localizedTextService.UmbracoDictionaryTranslate(_cultureDictionary, source.ContentType.Name);
target.DocumentType = _commonMapper.GetContentType(source, context);
target.Icon = source.ContentType.Icon;
target.Id = source.Id;
target.IsBlueprint = source.Blueprint;
target.IsChildOfListView = DetermineIsChildOfListView(source, parent, context);
target.IsContainer = source.ContentType.IsContainer;
target.IsElement = source.ContentType.IsElement;
target.Key = source.Key;
target.Owner = _commonMapper.GetOwner(source, context);
target.ParentId = source.ParentId;
target.Path = source.Path;
target.SortOrder = source.SortOrder;
target.TemplateAlias = GetDefaultTemplate(source);
target.TemplateId = source.TemplateId ?? default;
target.Trashed = source.Trashed;
target.TreeNodeUrl = _commonTreeNodeMapper.GetTreeNodeUrl <ContentTreeController>(source);
target.Udi =
Udi.Create(source.Blueprint ? Constants.UdiEntityType.DocumentBlueprint : Constants.UdiEntityType.Document, source.Key);
target.UpdateDate = source.UpdateDate;
target.Updater = _commonMapper.GetCreator(source, context);
target.Urls = GetUrls(source);
target.Variants = _contentVariantMapper.Map <TVariant>(source, context);
target.ContentDto = new ContentPropertyCollectionDto
{
Properties = context.MapEnumerable <IProperty, ContentPropertyDto>(source.Properties).WhereNotNull()
};
}
private IEnumerable <ContentEditing.Language> GetLanguages(MapperContext context)
{
var allLanguages = _localizationService.GetAllLanguages().OrderBy(x => x.Id).ToList();
if (allLanguages.Count == 0)
{
// This should never happen
return(Enumerable.Empty <ContentEditing.Language>());
}
return(context.MapEnumerable <ILanguage, ContentEditing.Language>(allLanguages).WhereNotNull().ToList());
}
// 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 IEnumerable <ContentVariantDisplay> Map(IContent source, MapperContext context)
{
var result = new List <ContentVariantDisplay>();
if (!source.ContentType.VariesByCulture())
{
//this is invariant so just map the IContent instance to ContentVariationDisplay
result.Add(context.Map <ContentVariantDisplay>(source));
}
else
{
var allLanguages = _localizationService.GetAllLanguages().OrderBy(x => x.Id).ToList();
if (allLanguages.Count == 0)
{
return(Enumerable.Empty <ContentVariantDisplay>()); //this should never happen
}
var langs = context.MapEnumerable <ILanguage, Language>(allLanguages).ToList();
//create a variant for each language, then we'll populate the values
var variants = langs.Select(x =>
{
//We need to set the culture in the mapping context since this is needed to ensure that the correct property values
//are resolved during the mapping
context.SetCulture(x.IsoCode);
return(context.Map <ContentVariantDisplay>(source));
}).ToList();
for (int i = 0; i < langs.Count; i++)
{
var x = langs[i];
var variant = variants[i];
variant.Language = x;
variant.Name = source.GetCultureName(x.IsoCode);
}
//Put the default language first in the list & then sort rest by a-z
var defaultLang = variants.SingleOrDefault(x => x.Language.IsDefault);
//Remove the default language from the list for now
variants.Remove(defaultLang);
//Sort the remaining languages a-z
variants = variants.OrderBy(x => x.Name).ToList();
//Insert the default language as the first item
variants.Insert(0, defaultLang);
return(variants);
}
return(result);
}
// Umbraco.Code.MapAll -ContentTypeId -ParentTabContentTypes -ParentTabContentTypeNames
private static void Map(PropertyGroupBasic <MemberPropertyTypeBasic> source, PropertyGroupDisplay <MemberPropertyTypeDisplay> target, MapperContext context)
{
if (source.Id > 0)
{
target.Id = source.Id;
}
target.Inherited = source.Inherited;
target.Name = source.Name;
target.SortOrder = source.SortOrder;
target.Properties = context.MapEnumerable <MemberPropertyTypeBasic, MemberPropertyTypeDisplay>(source.Properties);
}
// Umbraco.Code.MapAll -ContentTypeId -ParentTabContentTypes -ParentTabContentTypeNames
private static void Map(PropertyGroupBasic <PropertyTypeBasic> source, PropertyGroupDisplay <PropertyTypeDisplay> target, MapperContext context)
{
target.Inherited = source.Inherited;
if (source.Id > 0)
{
target.Id = source.Id;
}
target.Key = source.Key;
target.Type = source.Type;
target.Name = source.Name;
target.Alias = source.Alias;
target.SortOrder = source.SortOrder;
target.Properties = context.MapEnumerable <PropertyTypeBasic, PropertyTypeDisplay>(source.Properties);
}
// Umbraco.Code.MapAll -Edited -Updater -Alias
private void Map(IMedia source, ContentItemBasic <ContentPropertyBasic> target, MapperContext context)
{
target.ContentTypeAlias = source.ContentType.Alias;
target.CreateDate = source.CreateDate;
target.Icon = source.ContentType.Icon;
target.Id = source.Id;
target.Key = source.Key;
target.Name = source.Name;
target.Owner = _commonMapper.GetOwner(source, context);
target.ParentId = source.ParentId;
target.Path = source.Path;
target.Properties = context.MapEnumerable <Property, ContentPropertyBasic>(source.Properties);
target.SortOrder = source.SortOrder;
target.State = null;
target.Trashed = source.Trashed;
target.Udi = Udi.Create(Constants.UdiEntityType.Media, source.Key);
target.UpdateDate = source.UpdateDate;
target.VariesByCulture = source.ContentType.VariesByCulture();
}
// Umbraco.Code.MapAll -Trashed -Edited -Updater -Alias -VariesByCulture
private void Map(IMember source, MemberBasic target, MapperContext context)
{
target.ContentTypeAlias = source.ContentType.Alias;
target.CreateDate = source.CreateDate;
target.Email = source.Email;
target.Icon = source.ContentType.Icon;
target.Id = int.MaxValue;
target.Key = source.Key;
target.Name = source.Name;
target.Owner = _commonMapper.GetOwner(source, context);
target.ParentId = source.ParentId;
target.Path = source.Path;
target.Properties = context.MapEnumerable <Property, ContentPropertyBasic>(source.Properties);
target.SortOrder = source.SortOrder;
target.State = null;
target.Udi = Udi.Create(Constants.UdiEntityType.Member, source.Key);
target.UpdateDate = source.UpdateDate;
target.Username = source.Username;
}
// Umbraco.Code.MapAll -Notifications -IsCurrentUser -Udi -Icon -Trashed -Alias -AdditionalData
private void Map(IUser source, UserBasic target, MapperContext context)
{
//Loading in the user avatar's requires an external request if they don't have a local file avatar, this means that initial load of paging may incur a cost
//Alternatively, if this is annoying the back office UI would need to be updated to request the avatars for the list of users separately so it doesn't look
//like the load time is waiting.
target.Avatars = source.GetUserAvatarUrls(_appCaches.RuntimeCache);
target.Culture = source.GetUserCulture(_textService, _globalSettings).ToString();
target.Email = source.Email;
target.EmailHash = source.Email.ToLowerInvariant().Trim().ToMd5();
target.Id = source.Id;
target.Key = source.Key;
target.LastLoginDate = source.LastLoginDate == default ? null : (DateTime?)source.LastLoginDate;
target.Name = source.Name;
target.ParentId = -1;
target.Path = "-1," + source.Id;
target.UserGroups = context.MapEnumerable <IReadOnlyUserGroup, UserGroupBasic>(source.Groups);
target.Username = source.Username;
target.UserState = source.UserState;
}
private IEnumerable <DataTypeConfigurationFieldDisplay> MapPreValues(IDataType dataType, MapperContext context)
{
// in v7 it was apparently fine to have an empty .EditorAlias here, in which case we would map onto
// an empty fields list, which made no sense since there would be nothing to map to - and besides,
// a datatype without an editor alias is a serious issue - v8 wants an editor here
if (string.IsNullOrWhiteSpace(dataType.EditorAlias) || !_propertyEditors.TryGet(dataType.EditorAlias, out var editor))
{
throw new InvalidOperationException($"Could not find a property editor with alias \"{dataType.EditorAlias}\".");
}
var configurationEditor = editor.GetConfigurationEditor();
var fields = context.MapEnumerable <ConfigurationField, DataTypeConfigurationFieldDisplay>(configurationEditor.Fields);
var configurationDictionary = configurationEditor.ToConfigurationEditor(dataType.Configuration);
MapConfigurationFields(dataType, fields, configurationDictionary);
return(fields);
}
private IEnumerable <DataTypeConfigurationFieldDisplay> MapPreValues(IDataEditor source, MapperContext context)
{
// this is a new data type, initialize default configuration
// get the configuration editor,
// get the configuration fields and map to UI,
// get the configuration default values and map to UI
var configurationEditor = source.GetConfigurationEditor();
var fields = context.MapEnumerable <ConfigurationField, DataTypeConfigurationFieldDisplay>(configurationEditor.Fields);
var defaultConfiguration = configurationEditor.DefaultConfiguration;
if (defaultConfiguration != null)
{
MapConfigurationFields(null, fields, defaultConfiguration);
}
return(fields);
}
private static void Map(IEnumerable <ILanguage> source, IEnumerable <ContentEditing.Language> target, MapperContext context)
{
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
if (!(target is List <ContentEditing.Language> list))
{
throw new NotSupportedException($"{nameof(target)} must be a List<Language>.");
}
var temp = context.MapEnumerable <ILanguage, ContentEditing.Language>(source);
//Put the default language first in the list & then sort rest by a-z
var defaultLang = temp.SingleOrDefault(x => x.IsDefault);
// insert default lang first, then remaining language a-z
list.Add(defaultLang);
list.AddRange(temp.Where(x => x != defaultLang).OrderBy(x => x.Name));
}
// Umbraco.Code.MapAll -Alias
private void Map(IContent source, ContentItemBasic <ContentPropertyBasic> target, MapperContext context)
{
target.ContentTypeAlias = source.ContentType.Alias;
target.CreateDate = source.CreateDate;
target.Edited = source.Edited;
target.Icon = source.ContentType.Icon;
target.Id = source.Id;
target.Key = source.Key;
target.Name = GetName(source, context);
target.Owner = _commonMapper.GetOwner(source, context);
target.ParentId = source.ParentId;
target.Path = source.Path;
target.Properties = context.MapEnumerable <Property, ContentPropertyBasic>(source.Properties);
target.SortOrder = source.SortOrder;
target.State = _basicStateMapper.Map(source, context);
target.Trashed = source.Trashed;
target.Udi = Udi.Create(source.Blueprint ? Constants.UdiEntityType.DocumentBlueprint : Constants.UdiEntityType.Document, source.Key);
target.UpdateDate = GetUpdateDate(source, context);
target.Updater = _commonMapper.GetCreator(source, context);
target.VariesByCulture = source.ContentType.VariesByCulture();
}
// Umbraco.Code.MapAll
private static void Map(IContent source, ContentPropertyCollectionDto target, MapperContext context)
{
target.Properties = context.MapEnumerable <Property, ContentPropertyDto>(source.Properties);
}
// Umbraco.Code.MapAll -ContentStartNode -MediaStartNode -Sections -Notifications -Udi
// Umbraco.Code.MapAll -Trashed -AdditionalData -Users -AssignedPermissions
private void Map(IUserGroup source, UserGroupDisplay target, MapperContext context)
{
target.Alias = source.Alias;
target.DefaultPermissions = MapUserGroupDefaultPermissions(source);
target.Icon = source.Icon;
target.Id = source.Id;
target.Key = source.Key;
target.Name = source.Name;
target.ParentId = -1;
target.Path = "-1," + source.Id;
target.UserCount = source.UserCount;
MapUserGroupBasic(target, source.AllowedSections, source.StartContentId, source.StartMediaId, context);
//Important! Currently we are never mapping to multiple UserGroupDisplay objects but if we start doing that
// this will cause an N+1 and we'll need to change how this works.
var users = _userService.GetAllInGroup(source.Id);
target.Users = context.MapEnumerable <IUser, UserBasic>(users);
//Deal with assigned permissions:
var allContentPermissions = _userService.GetPermissions(source, true)
.ToDictionary(x => x.EntityId, x => x);
IEntitySlim[] contentEntities;
if (allContentPermissions.Keys.Count == 0)
{
contentEntities = Array.Empty <IEntitySlim>();
}
else
{
// a group can end up with way more than 2000 assigned permissions,
// so we need to break them into groups in order to avoid breaking
// the entity service due to too many Sql parameters.
var list = new List <IEntitySlim>();
foreach (var idGroup in allContentPermissions.Keys.InGroupsOf(2000))
{
list.AddRange(_entityService.GetAll(UmbracoObjectTypes.Document, idGroup.ToArray()));
}
contentEntities = list.ToArray();
}
var allAssignedPermissions = new List <AssignedContentPermissions>();
foreach (var entity in contentEntities)
{
var contentPermissions = allContentPermissions[entity.Id];
var assignedContentPermissions = context.Map <AssignedContentPermissions>(entity);
assignedContentPermissions.AssignedPermissions = AssignedUserGroupPermissions.ClonePermissions(target.DefaultPermissions);
//since there is custom permissions assigned to this node for this group, we need to clear all of the default permissions
//and we'll re-check it if it's one of the explicitly assigned ones
foreach (var permission in assignedContentPermissions.AssignedPermissions.SelectMany(x => x.Value))
{
permission.Checked = false;
permission.Checked = contentPermissions.AssignedPermissions.Contains(permission.PermissionCode, StringComparer.InvariantCulture);
}
allAssignedPermissions.Add(assignedContentPermissions);
}
target.AssignedPermissions = allAssignedPermissions;
}
/// <summary> /// Maps a list of <see cref="Property" /> to a list of <see cref="ContentPropertyDisplay" /> /// </summary> /// <param name="content"></param> /// <param name="properties"></param> /// <param name="context"></param> /// <returns></returns> protected virtual List <ContentPropertyDisplay> MapProperties(IContentBase content, List <IProperty> properties, MapperContext context) => context.MapEnumerable <IProperty, ContentPropertyDisplay>(properties.OrderBy(x => x.PropertyType?.SortOrder)) .WhereNotNull().ToList();
/// <summary>
/// Maps a list of <see cref="Property"/> to a list of <see cref="ContentPropertyDisplay"/>
/// </summary>
/// <param name="content"></param>
/// <param name="properties"></param>
/// <param name="context"></param>
/// <returns></returns>
protected virtual List <ContentPropertyDisplay> MapProperties(IContentBase content, List <Property> properties, MapperContext context)
{
return(context.MapEnumerable <Property, ContentPropertyDisplay>(properties.OrderBy(x => x.PropertyType.SortOrder)));
}
// Umbraco.Code.MapAll
private static void Map(IMember source, ContentPropertyCollectionDto target, MapperContext context)
{
target.Properties = context.MapEnumerable <IProperty, ContentPropertyDto>(source.Properties).WhereNotNull();
}