public async Task <OperationResultResponse <bool> > ExecuteAsync(UpdateRoleRightsRequest request)
{
if (!await _accessValidator.IsAdminAsync())
{
return(_responseCreator.CreateFailureResponse <bool>(HttpStatusCode.Forbidden));
}
ValidationResult validationResult = await _requestValidator.ValidateAsync(request);
if (!validationResult.IsValid)
{
return(_responseCreator.CreateFailureResponse <bool>(
HttpStatusCode.BadRequest,
validationResult.Errors.Select(validationFailure => validationFailure.ErrorMessage).ToList()));
}
OperationResultResponse <bool> response = new();
response.Body = await _roleRepository.EditRoleRightsAsync(
request.RoleId,
_dbRoleRightMapper.Map(request.RoleId, request.Rights));
await UpdateCacheAsync(request.Rights, request.RoleId);
return(response);
}
public async Task <OperationResultResponse <bool> > ExecuteAsync(Guid workspaceId, JsonPatchDocument <EditWorkspaceRequest> request)
{
DbWorkspace dbWorkspace = await _repository.GetAsync(workspaceId);
Guid editorId = _httpContextAccessor.HttpContext.GetUserId();
if (dbWorkspace.CreatedBy != editorId &&
(await _userRepository.GetAdminsAsync(workspaceId)).FirstOrDefault(wa => wa.UserId == editorId) == null &&
!await _accessValidator.IsAdminAsync())
{
return(_responseCreator.CreateFailureResponse <bool>(HttpStatusCode.Forbidden));
}
if (!_validator.ValidateCustom(request, out List <string> errors))
{
return(_responseCreator.CreateFailureResponse <bool>(HttpStatusCode.BadRequest, errors));
}
OperationResultResponse <bool> response = new();
response.Body = await _repository.EditAsync(dbWorkspace, await _mapper.MapAsync(request));
response.Status = OperationResultStatusType.FullSuccess;
if (!response.Body)
{
response = _responseCreator.CreateFailureResponse <bool>(HttpStatusCode.BadRequest);
}
return(response);
}
public async Task <OperationResultResponse <Guid> > ExecuteAsync(CreateRoleRequest request)
{
if (!await _accessValidator.IsAdminAsync())
{
return(_responseCreator.CreateFailureResponse <Guid>(HttpStatusCode.Forbidden));
}
ValidationResult validationResult = await _validator.ValidateAsync(request);
if (!validationResult.IsValid)
{
return(_responseCreator.CreateFailureResponse <Guid>(
HttpStatusCode.BadRequest,
validationResult.Errors.Select(validationFailure => validationFailure.ErrorMessage).ToList()));
}
OperationResultResponse <Guid> response = new();
response.Body = await _roleRepository.CreateAsync(_mapper.Map(request));
_httpContextAccessor.HttpContext.Response.StatusCode = (int)HttpStatusCode.Created;
await UpdateCacheAsync(request.Rights, response.Body);
return(response);
}
public async Task <OperationResultResponse <Guid?> > ExecuteAsync(CreateWorkspaceRequest request)
{
ValidationResult validationResult = await _validator.ValidateAsync(request);
if (!validationResult.IsValid)
{
return(_responseCreator.CreateFailureResponse <Guid?>(HttpStatusCode.BadRequest,
validationResult.Errors.Select(vf => vf.ErrorMessage).ToList()));
}
OperationResultResponse <Guid?> response = new();
response.Body = await _repository.CreateAsync(await _mapper.MapAsync(request));
response.Status = OperationResultStatusType.FullSuccess;
_httpContextAccessor.HttpContext.Response.StatusCode = (int)HttpStatusCode.Created;
if (response.Body is null)
{
response = _responseCreator.CreateFailureResponse <Guid?>(HttpStatusCode.BadRequest);
}
return(response);
}
public async Task <OperationResultResponse <bool> > ExecuteAsync(Guid roleLocalizationId, JsonPatchDocument <EditRoleLocalizationRequest> request)
{
if (!await _accessValidator.IsAdminAsync())
{
return(_responseCreator.CreateFailureResponse <bool>(HttpStatusCode.Forbidden));
}
if (!_validator.ValidateCustom(request, out List <string> errors))
{
return(_responseCreator.CreateFailureResponse <bool>(
HttpStatusCode.BadRequest,
errors));
}
Operation <EditRoleLocalizationRequest> isActiveOperation = request.Operations.FirstOrDefault(
o => o.path.EndsWith(nameof(EditRoleLocalizationRequest.IsActive), StringComparison.OrdinalIgnoreCase));
Operation <EditRoleLocalizationRequest> nameOperation = request.Operations.FirstOrDefault(
o => o.path.EndsWith(nameof(EditRoleLocalizationRequest.Name), StringComparison.OrdinalIgnoreCase));
DbRoleLocalization roleLocalization = await _roleLocalizationRepository.GetAsync(roleLocalizationId);
if (isActiveOperation != default)
{
bool isActive = bool.Parse(isActiveOperation.value.ToString().Trim());
if (roleLocalization.IsActive == isActive)
{
return(_responseCreator.CreateFailureResponse <bool>(
HttpStatusCode.BadRequest,
new List <string> {
"Role localization already has this status."
}));
}
if (isActive &&
await _roleLocalizationRepository.DoesLocaleExistAsync(roleLocalization.RoleId, roleLocalization.Locale))
{
return(_responseCreator.CreateFailureResponse <bool>(
HttpStatusCode.BadRequest,
new List <string> {
"Role must have only one localization per locale."
}));
}
}
if (nameOperation != default &&
await _roleLocalizationRepository.DoesNameExistAsync(roleLocalization.Locale, nameOperation.value.ToString().Trim()))
{
return(_responseCreator.CreateFailureResponse <bool>(
HttpStatusCode.BadRequest,
new List <string> {
"Name already exists."
}));
}
return(new OperationResultResponse <bool>()
{
Body = await _roleLocalizationRepository.EditRoleLocalizationAsync(roleLocalizationId, _roleLocalizationMapper.Map(request))
});
}
public async Task <OperationResultResponse <bool> > ExecuteAsync(Guid userId, IEnumerable <int> rightsIds)
{
if (!await _accessValidator.IsAdminAsync())
{
return(_responseCreator.CreateFailureResponse <bool>(HttpStatusCode.Forbidden));
}
ValidationResult validationResult = await _validator.ValidateAsync(rightsIds);
if (!validationResult.IsValid)
{
return(_responseCreator.CreateFailureResponse <bool>(HttpStatusCode.BadRequest, validationResult.Errors.Select(vf => vf.ErrorMessage).ToList()));
}
bool result = await _repository.RemoveUserRightsAsync(userId, rightsIds);
if (result)
{
await UpdateCacheAsync(userId, rightsIds);
}
return(new()
{
Status = result ? OperationResultStatusType.FullSuccess : OperationResultStatusType.Failed,
Body = result
});
}
public async Task <OperationResultResponse <WorkspaceInfo> > ExecuteAsync(GetWorkspaceFilter filter)
{
DbWorkspace dbWorkspace = await _repository.GetAsync(filter);
if (dbWorkspace is null)
{
return(_responseCreator.CreateFailureResponse <WorkspaceInfo>(HttpStatusCode.NotFound));
}
if (!dbWorkspace.Users.Select(u => u.UserId).Contains(_httpContextAccessor.HttpContext.GetUserId()))
{
return(_responseCreator.CreateFailureResponse <WorkspaceInfo>(HttpStatusCode.Forbidden));
}
OperationResultResponse <WorkspaceInfo> response = new();
List <UserData> usersData = await GetUsersAsync(dbWorkspace.Users?.Select(u => u.UserId).ToList(), response.Errors);
List <ImageInfo> imagesInfo = (await GetImagesAsync(
usersData?.Where(u => u.ImageId.HasValue).Select(u => u.ImageId.Value).ToList(),
response.Errors))
?.Select(_imageMapper.Map).ToList();
response.Status = response.Errors.Any() ? OperationResultStatusType.PartialSuccess : OperationResultStatusType.FullSuccess;
response.Body = _workspaceInfoMapper.Map(
dbWorkspace,
usersData?.Select(u => _userMapper.Map(u, imagesInfo?.FirstOrDefault(i => i.Id == u.ImageId))).ToList());
return(response);
}
public async Task <OperationResultResponse <bool> > ExecuteAsync(Guid fileId, JsonPatchDocument <EditFileRequest> request)
{
OperationResultResponse <bool> response = new();
if (!await _accessValidator.HasRightsAsync(Rights.AddEditRemoveProjects))
{
return(_responseCreator.CreateFailureResponse <bool>(HttpStatusCode.Forbidden));
}
ValidationResult result = _requestValidator.Validate(request);
if (!result.IsValid)
{
return(_responseCreator.CreateFailureResponse <bool>(HttpStatusCode.BadRequest,
result.Errors.Select(vf => vf.ErrorMessage).ToList()));
}
response.Body = await _fileRepository.EditAsync(fileId, _mapper.Map(request));
response.Status = OperationResultStatusType.FullSuccess;
if (!response.Body)
{
response = _responseCreator.CreateFailureResponse <bool>(HttpStatusCode.BadRequest);
}
return(response);
}
public async Task <OperationResultResponse <Guid?> > ExeсuteAsync(CreateChannelRequest request)
{
if (await _workspaceUserRepository
.WorkspaceUsersExist(new List <Guid>()
{
_httpContextAccessor.HttpContext.GetUserId()
}, request.WorkspaceId))
{
return(_responseCreator.CreateFailureResponse <Guid?>(HttpStatusCode.Forbidden));
}
ValidationResult validationResult = await _validator.ValidateAsync(request);
if (!validationResult.IsValid)
{
return(_responseCreator.CreateFailureResponse <Guid?>(HttpStatusCode.BadRequest,
validationResult.Errors.Select(vf => vf.ErrorMessage).ToList()));
}
OperationResultResponse <Guid?> response = new();
response.Body = await _channelRepository.CreateAsync(await _channelMapper.MapAsync(request));
_httpContextAccessor.HttpContext.Response.StatusCode = (int)HttpStatusCode.Created;
response.Status = OperationResultStatusType.FullSuccess;
if (response.Body is null)
{
response = _responseCreator.CreateFailureResponse <Guid?>(HttpStatusCode.BadRequest);
}
return(response);
}
public async Task <OperationResultResponse <bool> > ExecuteAsync(Guid userId, IEnumerable <int> rightsIds)
{
if (!await _accessValidator.IsAdminAsync())
{
return(_responseCreator.CreateFailureResponse <bool>(HttpStatusCode.Forbidden));
}
ValidationResult validationResult = await _validator.ValidateAsync(rightsIds);
List <string> errors = validationResult.Errors.Select(vf => vf.ErrorMessage).ToList();
if (!validationResult.IsValid && !await CheckUserExistenceAsync(userId, errors))
{
return(_responseCreator.CreateFailureResponse <bool>(HttpStatusCode.BadRequest, errors));
}
await _repository.AddUserRightsAsync(userId, rightsIds);
_httpContextAccessor.HttpContext.Response.StatusCode = (int)HttpStatusCode.Created;
await UpdateCacheAsync(userId, rightsIds);
return(new OperationResultResponse <bool>
{
Body = true,
Status = OperationResultStatusType.FullSuccess
});
}
public async Task <OperationResultResponse <ChannelInfo> > ExeсuteAsync(GetChannelFilter filter)
{
if (!_baseFindValidator.ValidateCustom(filter, out List <string> errors))
{
return(_responseCreator.CreateFailureResponse <ChannelInfo>(HttpStatusCode.BadRequest, errors));
}
DbChannel dbChannel = await _repository.GetAsync(filter);
Guid requestUserId = _httpContextAccessor.HttpContext.GetUserId();
if (dbChannel is null)
{
return(_responseCreator.CreateFailureResponse <ChannelInfo>(HttpStatusCode.NotFound));
}
if ((dbChannel.IsPrivate &&
!dbChannel.Users.Select(cu => cu.UserId).Contains(requestUserId)) ||
!dbChannel.Workspace.Users.Select(wu => wu.UserId).Contains(requestUserId))
{
return(_responseCreator.CreateFailureResponse <ChannelInfo>(HttpStatusCode.Forbidden));
}
OperationResultResponse <ChannelInfo> response = new();
List <Guid> usersIds = dbChannel.Users.Select(cu => cu.UserId).ToList();
usersIds.AddRange(dbChannel.Messages.Select(m => m.CreatedBy).Distinct().ToList());
List <UserData> usersData = await GetUsersAsync(usersIds, response.Errors);
List <Guid> imagesIds = usersData?.Where(u => u.ImageId.HasValue)?.Select(u => u.ImageId.Value).ToList();
//add messages immages to image service
List <ImageInfo> imagesInfo = (await GetImagesAsync(imagesIds, response.Errors))
?.Select(_imageMapper.Map).ToList();
List <UserInfo> usersInfo = usersData
?.Select(u =>
_userMapper.Map(u, imagesInfo?.FirstOrDefault(i => i.Id == u.ImageId))).ToList();
response.Body = _channelMapper.Map(
dbChannel,
dbChannel.Messages.Select(
m => _messageMapper.Map(
m,
usersInfo?.FirstOrDefault(u => u.Id == m.CreatedBy),
imagesInfo?.Where(i => m.Images.Select(mi => mi.ImageId).Contains(i.Id)).ToList())).ToList(),
usersInfo?.Where(u => dbChannel.Users.Select(u => u.UserId).Contains(u.Id)).ToList());
response.Status = OperationResultStatusType.FullSuccess;
return(response);
}
public async Task <OperationResultResponse <StatusType> > ExecuteAsync(CreateMessageRequest request)
{
ValidationResult validationResult = await _validator.ValidateAsync(request);
if (!validationResult.IsValid)
{
return(_responseCreator.CreateFailureResponse <StatusType>(
HttpStatusCode.BadRequest,
validationResult.Errors.Select(vf => vf.ErrorMessage).ToList()));
}
OperationResultResponse <StatusType> response = new();
DbMessage message = await _repository.CreateAsync(_mapper.Map(request));
try
{
await _chatHub.Clients.Group(request.ChannelId.ToString()).SendAsync(
"ReceiveMessage",
new MessageInfo()
{
Id = message.Id,
Content = message.Content,
Status = message.Status,
ThreadMessagesCount = message.ThreadMessagesCount,
CreatedBy = await GetUserAsync(response.Errors),
CreatedAtUtc = message.CreatedAtUtc,
FilesIds = null, //to do
Images = null //to do
});
response.Body = StatusType.Sent;
response.Status = OperationResultStatusType.FullSuccess;
_httpContextAccessor.HttpContext.Response.StatusCode = (int)HttpStatusCode.Created;
}
catch (Exception ex)
{
_logger.LogError("Can't send message.", ex);
response = _responseCreator.CreateFailureResponse <StatusType>(HttpStatusCode.InternalServerError);
}
return(response);
}
public async Task <OperationResultResponse <List <RightInfo> > > ExecuteAsync(string locale)
{
if (!await _accessValidator.IsAdminAsync())
{
return(_responseCreator.CreateFailureResponse <List <RightInfo> >(HttpStatusCode.Forbidden));
}
return(new()
{
Status = Kernel.Enums.OperationResultStatusType.FullSuccess,
Body = (await _repository.GetRightsListAsync(locale))?.Select(right => _mapper.Map(right)).ToList()
});
}
public async Task <OperationResultResponse <Guid?> > ExecuteAsync(CreateRoleLocalizationRequest request)
{
if (!await _accessValidator.IsAdminAsync())
{
return(_responseCreator.CreateFailureResponse <Guid?>(HttpStatusCode.Forbidden));
}
if (!request.RoleId.HasValue)
{
return(_responseCreator.CreateFailureResponse <Guid?>(
HttpStatusCode.BadRequest,
new List <string> {
"RoleId can't be empty."
}));
}
ValidationResult validationResult = await _requestValidator.ValidateAsync(request);
if (!validationResult.IsValid)
{
return(_responseCreator.CreateFailureResponse <Guid?>(
HttpStatusCode.BadRequest,
validationResult.Errors.Select(validationFailure => validationFailure.ErrorMessage).ToList()));
}
OperationResultResponse <Guid?> response = new();
response.Body = await _roleLocalizationRepository.CreateAsync(_roleLocalizationMapper.Map(request));
response.Status = response.Body != null
? OperationResultStatusType.FullSuccess
: OperationResultStatusType.Failed;
_httpContextAccessor.HttpContext.Response.StatusCode = response.Body != null
? (int)HttpStatusCode.Created
: (int)HttpStatusCode.BadRequest;
return(response);
}
public async Task <OperationResultResponse <bool> > ExecuteAsync(Guid roleId, bool isActive)
{
if (!await _accessValidator.IsAdminAsync())
{
return(_responseCreator.CreateFailureResponse <bool>(HttpStatusCode.Forbidden));
}
DbRole role = await _roleRepository.GetAsync(roleId);
if (role == null)
{
return(_responseCreator.CreateFailureResponse <bool>(
HttpStatusCode.NotFound,
new List <string> {
"Role doesn't exist."
}));
}
(bool isSuccess, string error)check = await CheckEnablePossibilityAsync(role, isActive);
if (!check.isSuccess)
{
return(_responseCreator.CreateFailureResponse <bool>(
HttpStatusCode.Conflict,
new List <string> {
check.error
}));
}
OperationResultResponse <bool> response = new();
response.Body = await _roleRepository.EditStatusAsync(roleId, isActive);
await UpdateCacheAsync(roleId, isActive);
return(response);
}
