public async Task <ActionResult> UpdatePermission([FromBody] UpdatePermissionDto permissionDto)
{
if (!IsAvailableOperation())
{
return(BadRequest());
}
var result = await _fileStorageService.UpdatePermission(permissionDto, UserId, ClientId);
AddLog(LogType.Update, LogMessage.CreatePermissionMessage(permissionDto.FileStorageId, LogMessage.UpdateVerb, UserId));
var recipient = result.Recipients.First();
var message = MessageUtil.GetUpdatePermissionMessage(permissionDto.Type, recipient, result.Storage, result.Sender);
try
{
await _emailSender.Send(EmailType.Notification, new MailAddress(recipient.Email, recipient.UserName), message.Subject, message.MessageBody);
await _notificationService.Add(recipient.Id, result.Storage.Id, message.Subject, message.MessageBody, Enums.NotificationType.Success);
}
catch (Exception)
{
await _notificationService.Add(recipient.Id, result.Storage.Id, message.Subject, message.MessageBody, Enums.NotificationType.NotSent);
}
return(Ok());
}
public virtual async Task UpdateAsync(string providerName, string providerKey, UpdateMenuGrantsDto input)
{
await CheckProviderPolicy(providerName);
foreach (var grantDto in input.Menus)
{
await _menuManager.SetAsync(grantDto.Id, providerName, providerKey, grantDto.IsGranted);
}
var permissions = _menuManager.GetPermissions(providerName);
var updatePermissionDtos = permissions
.Select(x =>
{
var menuDto = input.Menus.FirstOrDefault(y => y.PermissionKey == x.Name);
var dto = new UpdatePermissionDto
{
Name = x.Name,
IsGranted = menuDto?.IsGranted ?? false // 默认不给予授权，如果菜单与权限绑定，则以菜单的授权为主。
};
return(dto);
})
.ToArray();
await _permissionAppService.UpdateAsync(
providerName,
providerKey,
new UpdatePermissionsDto
{
Permissions = updatePermissionDtos
}
);
}
/// <summary>
/// 更新
/// </summary>
/// <param name="dto"></param>
/// <returns></returns>
public PublicResult UpdatePermission(UpdatePermissionDto dto)
{
Permission permission = null;
using (var client = DbFactory.CreateClient())
{
permission = client.Queryable <Permission>().InSingle(dto.Id);
if (permission == null)
{
return(Error("找不到该条信息"));
}
if (permission.IsSystem)
{
return(Error("内置信息不能修改"));
}
permission.Name = dto.Name;
permission.Code = dto.Code;
permission.IsActive = dto.IsActive;
permission.ParentId = dto.ParentId;
client.Updateable(permission).ExecuteCommand();
}
this.UpdatePathByPermissionId(permission.Id);
_distributedCache.Remove(CACHE_ROLE_PERMISSION_ALL_KEY);
_distributedCache.Remove(CACHE_PERMISSION_ALL_KEY);
_eventPublisher.EntityUpdated(permission);
return(Ok());
}
/// <summary>
/// 更新权限
/// </summary>
/// <param name="providerName"></param>
/// <param name="providerKey"></param>
/// <param name="input"></param>
/// <returns></returns>
public async Task UpdateAsync(string providerName, string providerKey, UpdatePermissionDto input)
{
await CheckProviderPolicy(providerName);
//foreach (var permissionDto in input.Permissions)
//{
// await _permissionManager.SetAsync(permissionDto.Name, providerName, providerKey, permissionDto.IsGranted);
//}
}
public async Task <IActionResult> UpdateAsync(Guid id, [FromBody] UpdatePermissionDto data)
{
var permission = await _permissionService.GetAsync(id);
if (permission == null)
{
return(NotFound());
}
var result = await _permissionService.UpdateAsync(id, data);
if (result == null)
{
return(BadRequest());
}
return(Ok(result));
}
// PUT: api/Permission/5 Update permission
public async Task <HandleResult> Put(string id, [FromBody] UpdatePermissionDto dto)
{
var command = new UpdatePermission(id,
dto.Name,
dto.PermissionType,
dto.ParentPermission,
dto.PermissionUrl,
dto.Sort,
dto.Describe,
dto.ReMark);
var result = await ExecuteCommandAsync(command);
if (result.IsSuccess())
{
return(HandleResult.FromSuccess("更新成功"));
}
return(HandleResult.FromFail(result.GetErrorMessage()));
}
public async Task <IActionResult> OnPostAsync()
{
updatedPermissionsDto = new UpdatePermissionsDto();
foreach (var group in permissionGroupDto)
{
foreach (var perItem in group.Permissions)
{
UpdatePermissionDto item = new UpdatePermissionDto();
item.Name = perItem.Name;
item.IsGranted = perItem.IsGranted;
updatedPermissionsDto.Permissions.Add(item);
}
}
await permissionAppService.UpdatePermissionAsync(ProviderName, ProviderKey, updatedPermissionsDto);
return(Page());
}
public async Task <IActionResult> Put(int id, UpdatePermissionDto input)
{
var permissions = await _permissionRepository.GetByIdAsync(id);
if (permissions == null)
{
throw new Exception($"Permission Not Found.");
}
else
{
permissions.Name = input.Name;
permissions.LastName = input.LastName;
permissions.TypeOfPermissionId = input.TypeOfPermissionId;
permissions.LastModified = DateTime.Now;
await _permissionRepository.UpdateAsync(permissions);
return(Ok(new Response <Permission>(permissions)));
}
}
public virtual Task UpdateAsync(string providerName, string providerKey, UpdatePermissionDto input)
{
return(PermissionAppService.UpdateAsync(providerName, providerKey, input));
}
public Task UpdateAsync(string providerName, string providerKey, UpdatePermissionDto input)
{
return(_permissionService.UpdateAsync(providerName, providerKey, input));
}
public IActionResult Update(UpdatePermissionDto dto)
{
var result = _permissionService.UpdatePermission(dto);
return(Json(result));
}
public async Task <CheckPermissionResultDto> UpdatePermission(UpdatePermissionDto permissionDto, int userId, int clientId)
{
var fileStorageRepository = DataContextManager.CreateRepository <IFileStorageRepository>();
var fileStorage = await fileStorageRepository.GetById(permissionDto.FileStorageId, userId, clientId);
var isAvailableToChange = await fileStorageRepository.IsAvailableToChange(fileStorage.Id, userId, clientId);
if (!isAvailableToChange)
{
throw new UnavailableOperationException("update permission", "Permission", fileStorage.Id, userId);
}
var sender = await _userService.GetById(userId);
var recipient = await _userService.GetById(permissionDto.RecipientId);
var fileStoragePermission = fileStorage.Permissions.FirstOrDefault(x => x.RecipientId == recipient.Id && !x.EndDate.HasValue);
if (fileStoragePermission == null)
{
throw new NotFoundException("File storage permission", fileStorage.Id, recipient.Email);
}
fileStoragePermission.Type = permissionDto.Type;
var parentFileStorages = await fileStorageRepository.GetParents(fileStorage.ParentFileStorageId, userId, clientId);
if (!fileStorage.ClientId.HasValue && !fileStorage.OwnerId.HasValue || fileStorage.ClientId.HasValue && !fileStorage.OwnerId.HasValue)
{
parentFileStorages.ToList()
.ForEach(storage =>
{
var permission = storage.Permissions.FirstOrDefault(x => x.RecipientId == recipient.Id && !x.EndDate.HasValue);
if (permission != null)
{
permission.Type = permissionDto.Type;
}
else
{
storage.Permissions.Add(new FileStoragePermission
{
RecipientId = recipient.Id,
SenderId = userId,
Type = permissionDto.Type,
StartDate = DateTime.UtcNow
});
}
});
}
await SaveChanges(fileStorageRepository, fileStorage, parentFileStorages);
return(new CheckPermissionResultDto
{
Storage = MapperFactory.CreateMapper <IFileStorageMapper>().MapToModel(fileStorage),
Sender = sender,
Recipients = new List <CheckPermissionResultDto.RecipientDto>
{
new CheckPermissionResultDto.RecipientDto
{
Id = recipient.Id,
UserName = recipient.UserName,
Email = recipient.Email,
Type = CheckPermissionResultDto.UpdateType.Update
}
}
});
}
