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)); }