public async Task <bool> Handle(ExchangeRefreshTokenRequest message, IOutputPort <ExchangeRefreshTokenResponse> outputPort) { var principal = _tokenService.GetPrincipalFromToken(message.AccessToken, message.SigningKey); if (principal != null) { var id = principal.Claims.First(c => c.Type == "id"); var identityId = int.Parse(id.Value); var user = await _userRepository.FirstOrDefaultByQueryAsync(new UserQueryFilter(identityId)); if (user !.HasValidRefreshToken(message.RefreshToken)) { var refreshToken = _tokenService.GenerateToken(); var token = _tokenService.GenerateEncodedToken(user.IdentityId, user.UserName, refreshToken); user.RemoveRefreshToken(message.RefreshToken); user.AddRefreshToken(refreshToken, user.Id, ""); await _userRepository.UpdateAsync(user); outputPort.Handle(new ExchangeRefreshTokenResponse(token, true)); return(true); } } outputPort.Handle(new ExchangeRefreshTokenResponse(false, "Invalid token.")); return(false); }
public async Task <bool> Handle(CreateLockRequest message, IOutputPort <CreateLockResponse> outputPort) { var company = await _companyRepository.GetByIdAsync(message.CompanyId); if (company != null) { var entityLock = new Lock { Name = message.Name, IsLocked = true, Company = company, Created = DateTime.UtcNow, }; var dbLock = await _lockRepository.AddAsync(entityLock); outputPort.Handle(new CreateLockResponse(dbLock, true)); return(true); } outputPort.Handle(new CreateLockResponse(true, "Company does not exist.")); return(false); }
public async Task <bool> Handle(ResetPasswordRequest message, IOutputPort <ResetPasswordResponse> outputPort) { if (!string.IsNullOrEmpty(message.UserName) && !string.IsNullOrEmpty(message.Email) && !string.IsNullOrEmpty(message.PasswordResetToken)) { // ensure we have a user with the given user name and matching email var user = await _userRepository.FindByName(message.UserName); if (user != null && user.Email == message.Email) { var response = await _userRepository.ResetPassword(user, message.PasswordResetToken, message.NewPassword); if (response.Success) { // generate refresh token var refreshToken = _tokenFactory.GenerateToken(); user.AddRefreshToken(refreshToken, user.Id, message.RemoteIpAddress); await _userRepository.Update(user); // generate access token var roles = await _userRepository.GetRoles(message.UserName); outputPort.Handle(new ResetPasswordResponse(await _jwtFactory.GenerateEncodedToken(user.IdentityId, user.UserName, roles), refreshToken, true)); return(true); } } } outputPort.Handle(new ResetPasswordResponse(new[] { new Error("reset_password_failure", "Invalid userName or email.") })); return(false); }
public async Task <bool> Post(BlogPostCommentRequest request, IOutputPort <BlogPostCommentResponse> response) { if (request.BlogPostId <= 0) { response.Handle(new BlogPostCommentResponse(new[] { new Error("error", "Blog ID Is Not Null!") })); return(false); } if (string.IsNullOrWhiteSpace(request.Comment)) { response.Handle(new BlogPostCommentResponse(new[] { new Error("error", "Blog Comment Is Not Null!") })); return(false); } if (request.CreateUser <= 0) { response.Handle(new BlogPostCommentResponse(new[] { new Error("error", "Failed To Get Session Information!") })); return(false); } var row = new BlgBlogPostComment() { BlgBlogPostId = request.BlogPostId, Comment = request.Comment, CreateUser = request.CreateUser, CreateDate = request.CreateDate }; repositories.BlgBlogPostCommentRepository.Create(row); await repositories.BlgBlogPostCommentRepository.SaveChangesAsync(); response.Handle(new BlogPostCommentResponse(row, true)); return(true); }
public async Task <bool> Handle(FinishJobTaskRequest message, IOutputPort <FinishJobTaskResponse> outputPort) { var taskEntity = await jobTaskRepository .GetSingleBySpec(new GetJobTaskSpecification(message.TaskId)); bool isAssigned = await taskAssignedValidator.IsAssigned(message.CallerId, message.TaskId); if (taskEntity == null) { outputPort.Handle(new FinishJobTaskResponse(new[] { applicationErrorFactory.ResourceNotFound })); return(false); } if (!isAssigned) { outputPort.Handle(new FinishJobTaskResponse(new[] { applicationErrorFactory.ChangeNotAllowed })); return(false); } taskEntity.Finished = true; await jobTaskRepository.Update(taskEntity); outputPort.Handle(new FinishJobTaskResponse()); return(true); }
public async Task <bool> Handle(LoginRequest message, IOutputPort <LoginResponse> outputPort) { LogInResponse result = null; if (!string.IsNullOrEmpty(message.UserName) && !string.IsNullOrEmpty(message.Password)) { result = await _userRepository.CheckPassword(message.UserName, message.Password); if (result != null && result.Success && result.User != null) { // generate refresh token var refreshToken = _tokenFactory.GenerateToken(); result.User.AddRefreshToken(refreshToken, message.RemoteIpAddress); _userRepository.Update(result.User); // generate access token outputPort.Handle(new LoginResponse(await _jwtFactory.GenerateEncodedToken(result.User.IdentityId, result.User.UserName), refreshToken, true)); return(true); } } outputPort.Handle(new LoginResponse(result != null ? result.Errors : new System.Collections.Generic.List <Error>() { new Error(HttpStatusCode.BadRequest.ToString(), "Invalid username or password!") })); return(false); }
public async Task <bool> Handle(CreateJobTaskRequest message, IOutputPort <CreateJobTaskResponse> outputPort) { bool isOwner = await jobOwnerShipValidator.IsJobOwner(message.CallerId, message.JobId); var loadedJob = await jobRepository.GetById(message.JobId); if (loadedJob == null) { outputPort.Handle(new CreateJobTaskResponse(new[] { applicationErrorFactory.ResourceNotFound })); return(false); } if (!isOwner) { outputPort.Handle(new CreateJobTaskResponse(new[] { applicationErrorFactory.ResourceNotOwned })); return(false); } var taskEntity = loadedJob.AddTask(message.Name, message.Description, message.FinishDate); await jobRepository.Update(loadedJob); outputPort.Handle(new CreateJobTaskResponse(taskEntity.Id)); return(true); }
public async Task <bool> Handle(DeleteEntriesRequest message, IOutputPort <DeleteEntriesResponse> outputPort) { try { await Task.Run(() => { Guid[] uids = message.Entries.Select(o => o.Uid).ToArray(); foreach (var relation in _RelationRepo.List(o => uids.Contains(o.EntryUid)).ToArray()) { _RelationRepo.Delete(relation); } foreach (var entry in message.Entries) { _EntryRepo.Delete(entry); } }); outputPort.Handle(new DeleteEntriesResponse(true, null)); return(true); } catch (Exception ex) { outputPort.Handle(new DeleteEntriesResponse(false, ex.ToString())); return(false); } }
public async Task <bool> Handle(RefreshTokenRequest message, IOutputPort <RefreshTokenResponce> outputPort) { var principals = _jwtValidator.GetPrincipalsFromToken(message.AccessToken, message.SigningKey); if (principals != null) { var id = principals.Claims.First(c => c.Type == "id"); var user = await _userReposytory.FindOneBySpec(new UserSpecification(id.Value)); if (user.HasValidRefreshTokens(message.RefreshToken)) { var jwtToken = await _jwtFactory.GenerateEncodedToken(user.IdentityId, user.UserName); var refreshToken = _tokenFactory.GenerateToken(); user.RemoveRefreshToken(message.RefreshToken); user.AddRefreshToken(refreshToken, user.Id, ""); await _userReposytory.Update(user); outputPort.Handle(new RefreshTokenResponce(jwtToken, refreshToken, true)); return(true); } } outputPort.Handle(new RefreshTokenResponce(false, "Invalid Refresh token")); return(false); }
public async Task <bool> Handle(UnAssignJobTaskRequest message, IOutputPort <UnAssignJobTaskResponse> outputPort) { var taskEntity = await jobTaskRepository.GetSingleBySpec(new GetJobTaskSpecification(message.TaskId)); if (taskEntity == null) { outputPort.Handle(new UnAssignJobTaskResponse(new[] { applicationErrorFactory.ResourceNotFound })); return(false); } bool isOwner = await jobOwnerShipValidator.IsJobOwner(message.CallerId, taskEntity.JobEntityId); if (!isOwner) { outputPort.Handle(new UnAssignJobTaskResponse(new[] { applicationErrorFactory.ResourceNotOwned })); return(false); } taskEntity.UnAssignUser(message.AssignUsername); await jobTaskRepository.Update(taskEntity); outputPort.Handle(new UnAssignJobTaskResponse()); return(true); }
public async Task <bool> Handle(GetCategoriesRequest message, IOutputPort <GetCategoriesResponse> outputPort) { Category[] categories = null; CategoryRelation[] relations = null; try { await Task.Run(() => { categories = _CatRepo.List(message.Query).ToArray(); if (message.IncludeRelations) { Guid[] catUids = categories.Select(o => o.Uid).ToArray(); relations = _RelRepo.List(o => catUids.Contains(o.ParentUid) || catUids.Contains(o.ChildUid)).ToArray(); } }); outputPort.Handle(new GetCategoriesResponse(categories, relations, true, null)); return(true); } catch (Exception ex) { outputPort.Handle(new GetCategoriesResponse(null, null, false, ex.ToString())); return(false); } }
public async Task <bool> Handle(GetUserRequest message, IOutputPort <UserResponse> outputPort) { try { if (message.Id <= 0) { throw new ArgumentException(nameof(message.Id)); } var user = await _userRepository.GetBy(message.Id); if (user.Blocked) { throw new Exception("User is blocked. Verify your email for confirmation."); } outputPort.Handle(new UserResponse(user)); return(true); } catch (Exception ex) { outputPort.Handle(new UserResponse(new[] { new Error("createuser", ex.Message) })); return(false); } }
public async Task <bool> Handle(CreateUserRequest message, IOutputPort <UserResponse> outputPort) { try { if (string.IsNullOrWhiteSpace(message.Email)) { throw new ArgumentException(nameof(message.Email)); } if (string.IsNullOrWhiteSpace(message.PasswordHash)) { throw new ArgumentException(nameof(message.PasswordHash)); } if (await _repository.Exists(message.Email)) { throw new InvalidOperationException("Duplicate user."); } var result = await _repository.Create(new User(message.Email, message.PasswordHash)); outputPort.Handle(new UserResponse(new User(result.Id, result.Email, "", result.Blocked))); await _userEmailManager.SendConfirmationEmail(result.Id, result.Email); return(true); } catch (Exception ex) { outputPort.Handle(new UserResponse(new[] { new Error("createuser", ex.Message) })); return(false); } }
public async Task <bool> Handle(RegisterUserRequest request, IOutputPort <RegisterUserResponse> outputPort) { if (_userRepository.FindByEmail(request.Email) != null) { outputPort.Handle(new RegisterUserResponse(new[] { new Error(422, "user with this email is already exists") })); return(false); } var userInfo = new UserDto() { Name = request.Name, Email = request.Email, BirthDay = request.BirthDay, PasswordHash = request.PasswordHash, }; UserDto createdUser = _userRepository.Create(userInfo); if (request.Picture != null) { var uploadedPicture = await _uploadService.UploadFile(request.Picture, request.WebRootPath); UploadedFileDto uploadedFile = _uploadedFileRepository.Create(uploadedPicture); uploadedPicture.Id = uploadedFile.Id; ImageDto createdPicture = _imageRepository.Create(new ImageDto() { UserId = createdUser.Id }, request.WebRootPath, uploadedPicture); createdUser = _userRepository.SetUserProfilePicture(createdPicture.Id, createdUser.Id); } outputPort.Handle(new RegisterUserResponse(createdUser)); return(true); }
public async Task <bool> Handle(ReportRequest message, IOutputPort <ReportResponse> outputPort) { var articlesToReport = await _userRepository.GetReportingArticles(message.From, message.To); if (articlesToReport.Count > 0) { using (var stream = new MemoryStream()) { switch (message.FileType) { case FileType.docx: _wordFactory.CreateReport(stream, articlesToReport); stream.Position = 0; outputPort.Handle(new ReportResponse(stream.ToArray(), message.FileType, true)); return(true); case FileType.pdf: return(false); case FileType.xlsx: _excelFactory.CreateReport(stream, articlesToReport); outputPort.Handle(new ReportResponse(stream.ToArray(), message.FileType, true)); return(true); } } } return(false); }
public bool Handle(NewCommentRequest request, IOutputPort <NewCommentResponse> outputPort) { if (_userRepository.FindById(request.UserId) == null) { outputPort.Handle(new NewCommentResponse(new[] { new Error(404, "user not found") })); return(false); } if (_videoRepository.FindById(request.VideoId) == null) { outputPort.Handle(new NewCommentResponse(new[] { new Error(404, "video not found") })); return(false); } var commentInfo = new CommentDto() { PostingDate = request.PostingDate, Text = request.Text, UserId = request.UserId, VideoId = request.VideoId, }; int commentId = _commentRepository.Create(commentInfo); outputPort.Handle(new NewCommentResponse(commentId)); return(true); }
public async Task <bool> Handle(UpdateJobRequest message, IOutputPort <UpdateJobResponse> outputPort) { bool isOwner = await jobOwnerShipValidator.IsJobOwner(message.CallerUserId, message.Id); var loadedJob = await jobRepository.GetById(message.Id); if (loadedJob == null) { outputPort.Handle(new UpdateJobResponse(new[] { applicationErrorFactory.ResourceNotFound })); return(false); } if (!isOwner) { outputPort.Handle(new UpdateJobResponse(new[] { applicationErrorFactory.ResourceNotOwned })); return(false); } mapper.Map(message, loadedJob); await jobRepository.Update(loadedJob); outputPort.Handle(new UpdateJobResponse()); return(true); }
public async Task <bool> Delete(BlogPostCommentRequest request, IOutputPort <BlogPostCommentResponse> response) { if (request.BlogPostCommentId <= 0) { response.Handle(new BlogPostCommentResponse(new[] { new Error("error", "Comment ID Is Not Null!") })); return(false); } if (request.UpdateUser <= 0) { response.Handle(new BlogPostCommentResponse(new[] { new Error("error", "Failed To Get Session Information!") })); return(false); } var row = repositories.BlgBlogPostCommentRepository.FindByCondition(p => p.Id == request.BlogPostCommentId && !p.IsDeleted).Result; if (row == null) { response.Handle(new BlogPostCommentResponse(new[] { new Error("error", "Failed To Get Blog Post Information!") })); return(false); } row.IsDeleted = true; row.UpdateUser = request.UpdateUser; row.UpdateDate = request.UpdateDate; repositories.BlgBlogPostCommentRepository.Update(row); await repositories.BlgBlogPostCommentRepository.SaveChangesAsync(); response.Response(new BlogPostCommentResponse(true)); return(true); }
public async Task <bool> Handle(AddEntryRequest message, IOutputPort <AddEntryResponse> outputPort) { Entry entry = new Entry(_EntryRepo.NextIdentity()) { Price = message.Price, Date = message.Date, Comment = message.Comment }; try { await Task.Run(() => { _EntryRepo.Add(entry); foreach (Guid cat in message.Categories) { EntryCategoryRelation rel = new EntryCategoryRelation() { EntryUid = entry.Uid, CategoryUid = cat }; _RelationRepo.Add(rel); } }); outputPort.Handle(new AddEntryResponse(entry, true, null)); return(true); } catch (Exception ex) { outputPort.Handle(new AddEntryResponse(null, false, ex.ToString())); return(false); } }
public async Task HandleAsync(DeletePostRequest message, IOutputPort <GenericResponse <bool> > outputPort) { try { var isExist = await _postRepository.IsPostExist(message.Id); if (!isExist) { throw new ItemNotFoundException(); } await _postRepository.RemoveById(message.Id); outputPort.Handle(new GenericResponse <bool>(true, "")); } catch (Exception ex) { if (ex is ItemNotFoundException) { outputPort.Handle(new GenericResponse <bool>(new[] { new Error(ex.HResult.ToString(), ex.Message) })); } else { outputPort.Handle(new GenericResponse <bool>(new[] { new Error("0", "خطا در دریافت اطلاعات", ex.ToString()) })); } } }
public async Task <bool> Handle(ChangePasswordRequest message, IOutputPort <ChangePasswordResponse> outputPort) { var user = message.User; var currentPassword = message.CurrentPassword; var newPassword = message.NewPassword; var passwordValid = await _userRepository.CheckPassword(user, currentPassword); if (!passwordValid) { outputPort.Handle( new ChangePasswordResponse(new[] { new Error(Error.Codes.INVALID_CREDENTIAL, Error.Messages.INVALID_CREDENTIAL), }) ); return(false); } var response = await _userRepository.ChangePassword(user, newPassword); if (!response.Success) { outputPort.Handle(new ChangePasswordResponse(response.Errors)); } outputPort.Handle( new ChangePasswordResponse() ); return(true); }
public async Task <bool> Handle(CreateCommentRequest message, IOutputPort <CreateCommentResponse> outputPort) { var requestId = message.RequestId; var parentId = message.ParentId; var author = message.Author; var content = message.Content; var response = await _commentRepository.CreateCommentOfRequest( requestId, content, author, parentId ); if (!response.Success) { outputPort.Handle( new CreateCommentResponse(response.Errors) ); return(false); } outputPort.Handle(new CreateCommentResponse(response.Id, response.CreatedAt)); return(true); }
public async Task <bool> Handle(LoginRequest message, IOutputPort <LoginResponce> outputPort) { if (!string.IsNullOrEmpty(message.UserName) || !string.IsNullOrEmpty(message.Password)) { var user = await _userReposytory.FindByName(message.UserName); if (user != null) { if (await _userReposytory.CheckPassword(user, message.Password)) { var jwtToken = await _jwtFactory.GenerateEncodedToken(user.IdentityId, message.UserName); var refreshToken = _tokenFactory.GenerateToken(); user.AddRefreshToken(refreshToken, user.Id, message.RemoteIpAddress); await _userReposytory.Update(user); outputPort.Handle(new LoginResponce(jwtToken, refreshToken, true)); return(true); } } } outputPort.Handle(new LoginResponce(new[] { new Error("login_failure", "Wrong Username of Password") })); return(false); }
public async Task <bool> Handle(ExchangeRefreshTokenRequest message, IOutputPort <ExchangeRefreshTokenResponse> outputPort) { var cp = _jwtTokenValidator.GetPrincipalFromToken(message.AccessToken, message.SigningKey); // invalid token/signing key was passed and we can't extract user claims if (cp != null) { var id = cp.Claims.First(c => c.Type == "id"); var user = await _userRepository.GetSingleBySpec(new UserSpecification(id.Value)); if (user.HasValidRefreshToken(message.RefreshToken)) { var jwtToken = await _jwtFactory.GenerateEncodedToken(user.IdentityId, user.UserName, new List <string> { "ROLE_ADMINISTRADOR" }); var refreshToken = _tokenFactory.GenerateToken(); user.RemoveRefreshToken(message.RefreshToken); // delete the token we've exchanged user.AddRefreshToken(refreshToken, user.Id, ""); // add the new one await _userRepository.Update(user); outputPort.Handle(new ExchangeRefreshTokenResponse(jwtToken, refreshToken, true)); return(true); } } outputPort.Handle(new ExchangeRefreshTokenResponse(false, "Invalid token.")); return(false); }
public bool Handle(NewChannelRequest request, IOutputPort <NewChannelResponse> outputPort) { if (_userRepository.FindById(request.UserId) == null) { outputPort.Handle(new NewChannelResponse(new[] { new Error(404, "user not found") })); return(false); } if (_channelRepository.FindByUserId(request.UserId) != null) { outputPort.Handle(new NewChannelResponse(new[] { new Error(422, "user already have channel") })); return(false); } if (_channelRepository.FindByName(request.Name) != null) { outputPort.Handle(new NewChannelResponse(new[] { new Error(422, "channel name is busy") })); return(false); } var channelInfo = new ChannelDto() { UserId = request.UserId, RegistrationDate = request.RegistrationDate, Description = request.Description, Name = request.Name, }; ChannelDto createdChannel = _channelRepository.Create(channelInfo); outputPort.Handle(new NewChannelResponse(createdChannel)); return(true); }
public async Task <bool> Handle(GeneratePasswordResetRequest message, IOutputPort <GeneratePasswordResetResponse> outputPort) { if (!string.IsNullOrEmpty(message.UserName) && !string.IsNullOrEmpty(message.Email)) { // ensure we have a user with the given user name and matching email var user = await _userRepository.FindByName(message.UserName); if (user != null && user.Email == message.Email) { var response = await _userRepository.GeneratePasswordReset(user); var urlToken = HttpUtility.UrlEncode(response.PasswordResetToken); //send email string body = "Please Follow the link to reset your password http:\\\\localhost:4200\\reset-password\\" + urlToken; string subject = "App Security Notification"; await _messenger.SendEmail(user.Email, body, subject); outputPort.Handle(new GeneratePasswordResetResponse(response.Success)); return(response.Success); } } outputPort.Handle(new GeneratePasswordResetResponse(new[] { new Error("generate_password_reset_failure", "Invalid userName or email.") })); return(false); }
public async Task <bool> Handle(UpdateJobTaskRequest message, IOutputPort <UpdateJobTaskResponse> outputPort) { var taskEntity = await taskRepository.GetById(message.TaskId); if (taskEntity == null) { outputPort.Handle(new UpdateJobTaskResponse(new[] { applicationErrorFactory.ResourceNotFound })); return(false); } bool isOwner = await jobOwnerShipValidator.IsJobOwner(message.CallerId, taskEntity.JobEntityId); if (!isOwner) { outputPort.Handle(new UpdateJobTaskResponse(new[] { applicationErrorFactory.ResourceNotOwned })); return(false); } mapper.Map(message, taskEntity); await taskRepository.Update(taskEntity); outputPort.Handle(new UpdateJobTaskResponse()); return(true); }
public async Task <bool> Handle(PasswordResetRequest request, IOutputPort <PasswordResetResponse> outputPort) { if (!string.IsNullOrWhiteSpace(request.Email)) { // confirm we have a user with the given name var user = await _userRepository.FindByEmail(request.Email); if (user != null) { // Send password link through email var subjectLine = "Password Reset Link"; var resetLink = @"https://somedomainlink.com/password-reset/?" + user.Id; var emailBodyText = $"Hey {user.FirstName} {user.LastName}! <a href='{resetLink}' target='_blank'>click here to reset password</a>"; await _emailService.SendEmailAsync(user.Email, subjectLine, emailBodyText); outputPort.Handle(new PasswordResetResponse("Please check your email address for password reset link", true)); return(true); } } outputPort.Handle(new PasswordResetResponse(new[] { new Error("password_reset_failure", "Email address not found in our database.") })); return(false); }
public async Task <bool> Handle(LoginRequest message, IOutputPort <LoginResponse> outputPort) { if (!string.IsNullOrEmpty(message.UserName) && !string.IsNullOrEmpty(message.Password)) { // ensure we have a user with the given user name var user = await _userRepository.FindByName(message.UserName); if (user != null) { // validate password if (await _userRepository.CheckPassword(user, message.Password)) { // generate refresh token var refreshToken = _tokenFactory.GenerateToken(); user.AddRefreshToken(refreshToken, user.Id, message.RemoteIpAddress); await _userRepository.Update(user); // generate access token outputPort.Handle(new LoginResponse(await _jwtFactory.GenerateEncodedToken(user.IdentityId, user.UserName), refreshToken, true)); return(true); } } } outputPort.Handle(new LoginResponse(new[] { new Error("login_failure", "Invalid username or password.") })); return(false); }
public async Task <bool> Handle(ReadUserRequest message, IOutputPort <ReadUserResponse> outputPort) { if (message.UserId.ToString() != Guid.Empty.ToString()) { DomainEntities.User user = await _userRepository.FindById(message.UserId); if (user == null) { outputPort.Handle(new ReadUserResponse(new[] { new Error(Error.Codes.ENTITY_NOT_FOUND, Error.Messages.ENTITY_NOT_FOUND) })); } else { outputPort.Handle(new ReadUserResponse(user)); } } else { IPagedCollection <DomainEntities.User> users = _userRepository.FindAll(); var filterStr = message.FilterString; if (filterStr.Contains(",") && filterStr.Contains(":") || filterStr.Contains(":")) { var filterCriteria = filterStr.Split(","); foreach (var crit in filterCriteria) { var keyVal = crit.Split(":"); users.FilterBy(keyVal[0], keyVal[1]); } } else { users.FilterBy(u => u.FirstName.Contains(filterStr) || u.LastName.Contains(filterStr) || u.Email.Contains(filterStr) || u.Account.Username.Contains(filterStr)); } users.FilterBy(u => u.Id != _currentUser.Id); if (message.SortedBy == "Username") { users.SortBy(u => u.Account.Username, message.SortOrder); } else { users.SortBy(message.SortedBy, message.SortOrder); } var items = await users.GetItemsForPage(message.Page, message.PageSize); var pagination = new Pagination <DomainEntities.User> { Items = items, TotalItems = users.TotalItems(), TotalPages = users.TotalPages(), Page = message.Page }; outputPort.Handle(new ReadUserResponse(pagination)); } return(true); }