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