protected virtual async Task <PermissionEntity> CreateActualEntityAsync(PermissionUpdateModel updateModel)
{
var createdEntity = CreateEntity(updateModel);
await _permissionsRepository.AddAsync(createdEntity);
return(createdEntity);
}
private static PermissionUpdateModel CreatePermission(
IntranetMemberGroup group,
Resource resource,
PermissionActionEnum action,
bool allowed = true, bool enabled = true)
{
var identity = PermissionSettingIdentity.Of(action, resource);
var settings = PermissionSettingValues.Of(allowed, enabled);
return(PermissionUpdateModel.Of(group, settings, identity));
}
public virtual GroupPermissionsViewModel Save(PermissionUpdateViewModel update)
{
var settingIdentity = PermissionSettingIdentity.Of(
_actionTypeProvider[update.ActionId],
_resourceTypeProvider[update.ResourceTypeId]);
var settingValue = PermissionSettingValues.Of(update.Allowed, update.Enabled);
var targetGroup = _intranetMemberGroupProvider[update.IntranetMemberGroupId];
var mappedUpdate = PermissionUpdateModel.Of(targetGroup, settingValue, settingIdentity);
_permissionsService.Save(mappedUpdate);
return(Get(update.IntranetMemberGroupId));
}
public async Task <GroupPermissionsViewModel> Save(PermissionUpdateViewModel update)
{
var settingIdentity = new PermissionSettingIdentity(
_actionTypeProvider[update.ActionId],
_resourceTypeProvider[update.ResourceTypeId]);
var settingValue = new PermissionSettingValues(update.Allowed, update.Enabled);
var targetGroup = _intranetMemberGroupProvider[update.IntranetMemberGroupId];
//var targetGroup = _intranetMemberGroupService.GetAll().First(x => x.Id == update.IntranetMemberGroupId);
var mappedUpdate = new PermissionUpdateModel(targetGroup, settingValue, settingIdentity);
await _permissionsService.SaveAsync(mappedUpdate);
return(await Get(update.IntranetMemberGroupId));
}
public async Task <IHttpActionResult> Update(PermissionUpdateModel model)
{
using (var uofw = CreateUnitOfWork)
{
try
{
await _accessService.UpdatePermissionForRole(uofw, model.EntityType, model.RoleID, model.Permission, model.IsEnabled);
return(Ok());
}
catch (Exception ex)
{
throw ex;
}
}
}
public async Task <PermissionModel> SaveAsync(PermissionUpdateModel update)
{
var storedEntity = await _permissionsRepository
.FindAsync(GroupIs(update.Group)
.AndAlso(ActionIs(update.SettingIdentity.Action))
.AndAlso(ActivityTypeIs(update.SettingIdentity.ResourceType)));
var actualEntity = storedEntity != null
? await GetActualEntityAsync(storedEntity, update)
: await CreateActualEntityAsync(update);
var actualMappedEntity = Map(actualEntity);
CurrentCache = null;
return(actualMappedEntity);
}
public async Task <IResultModel> Update(PermissionUpdateModel model)
{
var entity = await _repository.FirstAsync(model.Id);
if (entity == null)
{
return(ResultModel.NotExists);
}
if (await _repository.ExistsAsync(m => m.PermissionCode == model.PermissionCode && m.Id != entity.Id && m.IsDel == false))
{
return(ResultModel.HasExists);
}
_mapper.Map(model, entity);
var result = await _repository.UpdateAsync(entity);
return(ResultModel.Result(result));
}
public ExecutionResult Execute()
{
var uiUserGroup = _intranetMemberGroupProvider.All.FirstOrDefault(g => g.Name.ToLowerInvariant() == "uiuser");
if (uiUserGroup == null)
{
return(ExecutionResult.Success);
}
_permissionsService.Save(PermissionUpdateModel.Of(
uiUserGroup,
new PermissionSettingValues(false, false),
new PermissionSettingIdentity(PermissionActionEnum.CanPin, PermissionResourceTypeEnum.Events)));
_permissionsService.Save(PermissionUpdateModel.Of(
uiUserGroup,
new PermissionSettingValues(false, false),
new PermissionSettingIdentity(PermissionActionEnum.CanPin, PermissionResourceTypeEnum.News)));
return(ExecutionResult.Success);
}
public async Task <IResultModel> Update(PermissionUpdateModel model)
{
var entity = _mapper.Map <Permission>(model);
if (await _permissionRepository.Exists(entity))
{
return(ResultModel.HasExists);
}
entity = await _permissionRepository.GetAsync(model.Id);
if (entity == null)
{
return(ResultModel.NotExists);
}
entity = _mapper.Map(model, entity);
var result = await _permissionRepository.UpdateAsync(entity);
return(ResultModel.Result(result));
}
protected virtual async Task <PermissionEntity> GetActualEntityAsync(PermissionEntity entity, PermissionUpdateModel updateModel)
{
if (!updateModel.SettingValues.IsAllowed && entity.IsAllowed)
{
var descendants = GetDescendantsEntities(updateModel);
if (descendants.Length > 0)
{
await _permissionsRepository.UpdatePropertyAsync(descendants, i => i.IsAllowed);
}
}
var updatedEntity = UpdateEntity(entity, updateModel);
await _permissionsRepository.UpdateAsync(updatedEntity);
return(updatedEntity);
}
/// <summary>
/// This method is used to update existing folder permissions.
/// </summary>
/// <param name="client">Contains the <see cref="InspireClient"/> that is used for communication.</param>
/// <param name="folderId">Contains the folder identity.</param>
/// <param name="inputModel">Contains the <see cref="PermissionUpdateModel"/> input.</param>
/// <returns>Returns the updated <see cref="PermissionUpdateModel"/> object.</returns>
public static PermissionUpdateModel UpdateFolderPermissions(this InspireClient client, long folderId, PermissionUpdateModel inputModel)
{
if (inputModel == null)
{
throw new ArgumentNullException(nameof(inputModel));
}
var request = client.CreateRequest($"/Folders/{folderId}/Permissions", HttpMethod.Put);
return(client.RequestContent <PermissionUpdateModel, PermissionUpdateModel>(request, inputModel));
}
public Task <IResultModel> Update(PermissionUpdateModel model)
{
return(_service.Update(model));
}
