public UserGroupRepository(IScopeUnitOfWork work, CacheHelper cacheHelper, ILogger logger, ISqlSyntaxProvider sqlSyntax)
: base(work, cacheHelper, logger, sqlSyntax)
{
_cacheHelper = cacheHelper;
_userGroupWithUsersRepository = new UserGroupWithUsersRepository(this, work, cacheHelper, logger, sqlSyntax);
_permissionRepository = new PermissionRepository <IContent>(work, _cacheHelper, logger, sqlSyntax);
}
/// <summary>
/// Replaces the same permission set for a single user to any number of entities
/// </summary>
/// <param name="userId"></param>
/// <param name="permissions"></param>
/// <param name="entityIds"></param>
public void ReplaceUserPermissions(int userId, IEnumerable <char> permissions, params int[] entityIds)
{
var repo = new PermissionRepository <IContent>(UnitOfWork, _cacheHelper, SqlSyntax);
repo.ReplaceUserPermissions(userId, permissions, entityIds);
}
/// <summary>
/// Assigns the same permission set for a single user to any number of entities
/// </summary>
/// <param name="userId"></param>
/// <param name="permission"></param>
/// <param name="entityIds"></param>
public void AssignUserPermission(int userId, char permission, params int[] entityIds)
{
var repo = new PermissionRepository <IContent>(UnitOfWork, _cacheHelper, SqlSyntax);
repo.AssignUserPermission(userId, permission, entityIds);
}
/// <summary>
/// Returns permissions for a given user for any number of nodes
/// </summary>
/// <param name="userId"></param>
/// <param name="entityIds"></param>
/// <returns></returns>
public IEnumerable <EntityPermission> GetUserPermissionsForEntities(int userId, params int[] entityIds)
{
var repo = new PermissionRepository <IContent>(UnitOfWork, _cacheHelper, SqlSyntax);
return(repo.GetUserPermissionsForEntities(userId, entityIds));
}
public IEnumerable <EntityPermission> GetPermissionsForEntity(int entityId)
{
var repo = new PermissionRepository <IContent>(UnitOfWork, _cacheHelper, SqlSyntax);
return(repo.GetPermissionsForEntity(entityId));
}
/// <summary>
/// Assigns a single permission to the current content item for the specified user ids
/// </summary>
/// <param name="entity"></param>
/// <param name="permission"></param>
/// <param name="userIds"></param>
public void AssignEntityPermission(IContent entity, char permission, IEnumerable <int> userIds)
{
var repo = new PermissionRepository <IContent>(UnitOfWork, _cacheHelper, SqlSyntax);
repo.AssignEntityPermission(entity, permission, userIds);
}
public void ReplaceContentPermissions(EntityPermissionSet permissionSet)
{
var repo = new PermissionRepository <IContent>(UnitOfWork, _cacheHelper, SqlSyntax);
repo.ReplaceEntityPermissions(permissionSet);
}
protected override void PersistNewItem(IContent entity)
{
((Content)entity).AddingEntity();
//ensure the default template is assigned
if (entity.Template == null)
{
entity.Template = entity.ContentType.DefaultTemplate;
}
//Ensure unique name on the same level
entity.Name = EnsureUniqueNodeName(entity.ParentId, entity.Name);
//Ensure that strings don't contain characters that are invalid in XML
entity.SanitizeEntityPropertiesForXmlStorage();
var factory = new ContentFactory(NodeObjectTypeId, entity.Id);
var dto = factory.BuildDto(entity);
//NOTE Should the logic below have some kind of fallback for empty parent ids ?
//Logic for setting Path, Level and SortOrder
var parent = Database.First <NodeDto>("WHERE id = @ParentId", new { ParentId = entity.ParentId });
var level = parent.Level + 1;
var maxSortOrder = Database.ExecuteScalar <int>(
"SELECT coalesce(max(sortOrder),-1) FROM umbracoNode WHERE parentid = @ParentId AND nodeObjectType = @NodeObjectType",
new { /*ParentId =*/ entity.ParentId, NodeObjectType = NodeObjectTypeId });
var sortOrder = maxSortOrder + 1;
//Create the (base) node data - umbracoNode
var nodeDto = dto.ContentVersionDto.ContentDto.NodeDto;
nodeDto.Path = parent.Path;
nodeDto.Level = short.Parse(level.ToString(CultureInfo.InvariantCulture));
nodeDto.SortOrder = sortOrder;
var o = Database.IsNew(nodeDto) ? Convert.ToInt32(Database.Insert(nodeDto)) : Database.Update(nodeDto);
//Update with new correct path
nodeDto.Path = string.Concat(parent.Path, ",", nodeDto.NodeId);
Database.Update(nodeDto);
//Update entity with correct values
entity.Id = nodeDto.NodeId; //Set Id on entity to ensure an Id is set
entity.Path = nodeDto.Path;
entity.SortOrder = sortOrder;
entity.Level = level;
//Assign the same permissions to it as the parent node
// http://issues.umbraco.org/issue/U4-2161
var permissionsRepo = new PermissionRepository <IContent>(UnitOfWork, _cacheHelper, SqlSyntax);
var parentPermissions = permissionsRepo.GetPermissionsForEntity(entity.ParentId).ToArray();
//if there are parent permissions then assign them, otherwise leave null and permissions will become the
// user's default permissions.
if (parentPermissions.Any())
{
var userPermissions = (
from perm in parentPermissions
from p in perm.AssignedPermissions
select new EntityPermissionSet.UserPermission(perm.UserId, p)).ToList();
permissionsRepo.ReplaceEntityPermissions(new EntityPermissionSet(entity.Id, userPermissions));
//flag the entity's permissions changed flag so we can track those changes.
//Currently only used for the cache refreshers to detect if we should refresh all user permissions cache.
((Content)entity).PermissionsChanged = true;
}
//Create the Content specific data - cmsContent
var contentDto = dto.ContentVersionDto.ContentDto;
contentDto.NodeId = nodeDto.NodeId;
Database.Insert(contentDto);
//Create the first version - cmsContentVersion
//Assumes a new Version guid and Version date (modified date) has been set
var contentVersionDto = dto.ContentVersionDto;
contentVersionDto.NodeId = nodeDto.NodeId;
Database.Insert(contentVersionDto);
//Create the Document specific data for this version - cmsDocument
//Assumes a new Version guid has been generated
dto.NodeId = nodeDto.NodeId;
Database.Insert(dto);
//Create the PropertyData for this version - cmsPropertyData
var propertyFactory = new PropertyFactory(entity.ContentType.CompositionPropertyTypes.ToArray(), entity.Version, entity.Id);
var propertyDataDtos = propertyFactory.BuildDto(entity.Properties);
var keyDictionary = new Dictionary <int, int>();
//Add Properties
foreach (var propertyDataDto in propertyDataDtos)
{
var primaryKey = Convert.ToInt32(Database.Insert(propertyDataDto));
keyDictionary.Add(propertyDataDto.PropertyTypeId, primaryKey);
}
//Update Properties with its newly set Id
foreach (var property in entity.Properties)
{
property.Id = keyDictionary[property.PropertyTypeId];
}
//lastly, check if we are a creating a published version , then update the tags table
if (entity.Published)
{
UpdatePropertyTags(entity, _tagRepository);
}
// published => update published version infos, else leave it blank
if (entity.Published)
{
dto.DocumentPublishedReadOnlyDto = new DocumentPublishedReadOnlyDto
{
VersionId = dto.VersionId,
Newest = true,
NodeId = dto.NodeId,
Published = true
};
((Content)entity).PublishedVersionGuid = dto.VersionId;
}
entity.ResetDirtyProperties();
}