protected override async Task <IEnumerable <ExamResultReadModel> > ProcessAsync(ExamResultCommand <ExamResultCreateModel> message, CancellationToken cancellationToken)
{
var exam = await _dataContext.TrainingExams
.ProjectTo <TrainingExamReadModel>(_configurationProvider)
.ToListAsync(cancellationToken)
.ConfigureAwait(false);
if (exam.Count == 0)
{
throw new DomainException(422, $"Training Exam is null., Please Create question in exam module.,");
}
var dbSet = _dataContext.Set <Data.Entities.TraineeExamResult>();
foreach (var item in exam)
{
var map = _mapper.Map(item, message.Exam);
dbSet.AddIfNotExists(x => new { x.Id, x.QuestionId, x.CourseId, x.UserId }, _mapper.Map <TraineeExamResult>(map));
}
var result = await _dataContext
.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false);
var examresult = _dataContext.ExamResults.Include(x => x.Question)
.Where(x => x.UserId == message.Exam.UserId && x.CourseId == message.Exam.CourseId);
return(_mapper.Map <IEnumerable <ExamResultReadModel> >(examresult));
}
protected override async Task <UserReadModel> ProcessAsync(UserManagementCommand <UserVerifyOTPModel> message, CancellationToken cancellationToken)
{
var model = message.Model;
var user = await _dataContext.Users.GetByKeyAsync(model.Id)
.ConfigureAwait(false);
if (user == null)
{
throw new DomainException(422, $"User with Id '{model.Id}' not found.");
}
if (user.PhoneNumber != model.PhoneNumber)
{
throw new DomainException(422, $"User with phone number '{model.PhoneNumber}' not exist in system.");
}
if (user.OTP != model.OTP)
{
throw new DomainException(422, $"The '{model.OTP}' account verification number is not valid.,");
}
user.IsPhoneNumberConfirmed = true;
user.Updated = DateTimeOffset.UtcNow;
await _dataContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
var readModel = _mapper.Map <UserReadModel>(user);
return(readModel);
}
protected override async Task <UserReadModel> ProcessAsync(UserManagementCommand <UserSendOTPModel> message, CancellationToken cancellationToken)
{
var otp = GenerateRandomOTP(4, saAllowedCharacters);
var model = message.Model;
var user = await _dataContext.Users.GetByKeyAsync(model.Id)
.ConfigureAwait(false);
if (user == null)
{
throw new DomainException(422, $"User with Id '{model.Id}' not found.");
}
if (user.PhoneNumber != model.PhoneNumber)
{
throw new DomainException(422, $"User with phone number '{model.PhoneNumber}' not exist in system.");
}
var result = await _sMSTemplateService.SendOTP(user.PhoneNumber, otp).ConfigureAwait(false);
if (result == false)
{
throw new DomainException(422, $"Unable to send OTP '{model.PhoneNumber}' please try again later or contact administrator.");
}
user.OTP = otp;
user.Updated = DateTimeOffset.UtcNow;
user.IsPhoneNumberConfirmed = false;
await _dataContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
var readModel = _mapper.Map <UserReadModel>(user);
return(readModel);
}
protected override async Task <PaymentReadModel> ProcessAsync(PaymentApprovalCommand <Guid, PaymentTransaction, PaymentReadModel> message, CancellationToken cancellationToken)
{
var command = new EntityIdentifierQuery <Guid, PaymentTransaction, PaymentReadModel>(message.Id, message.Principal);
var result = await Mediator.Send(command, cancellationToken).ConfigureAwait(false);
if (result == null)
{
throw new DomainException(422, $"Payment Id '{message.Id}' not found.");
}
if (result.Status != message.PaymentStatus)
{
var commandCourse = new EntityIdentifierQuery <Guid, TrainingCourse, CourseReadModel>(result.CourseId.Value, message.Principal);
var resultCourse = await Mediator.Send(commandCourse, cancellationToken).ConfigureAwait(false);
if (resultCourse == null)
{
throw new DomainException(422, $"Course Id '{result.CourseId}' not found.");
}
if (resultCourse.MaxAttendee == resultCourse.NoAttendee)
{
throw new DomainException(422, $"Course '{resultCourse.Title}' is already full.");
}
var mapCourse = _mapper.Map <CourseUpdateModel>(resultCourse);
mapCourse.MaxAttendee = mapCourse.MaxAttendee - 1;
mapCourse.NoAttendee = mapCourse.NoAttendee + 1;
var updateCourse = new EntityUpdateCommand <Guid, TrainingCourse, CourseUpdateModel, CourseReadModel>(resultCourse.Id, mapCourse, message.Principal);
var mediatorCourse = await Mediator.Send(updateCourse, cancellationToken)
.ConfigureAwait(false);
result.Status = message.PaymentStatus;
var map = _mapper.Map <PaymentUpdateModel>(result);
var update = new EntityUpdateCommand <Guid, PaymentTransaction, PaymentUpdateModel, PaymentReadModel>(message.Id, map, message.Principal);
result = await Mediator.Send(update, cancellationToken).ConfigureAwait(false);
var history = _mapper.Map <PaymentTransactionHistory>(result);
var dbSetHistory = _dataContext.Set <Data.Entities.PaymentTransactionHistory>();
await dbSetHistory.AddAsync(history, cancellationToken).ConfigureAwait(false);
await _dataContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
var mapAttendee = _mapper.Map <TrainingBuildCoursesAttendeeCreatedModel>(result);
var courseAttendee = new EntityCreateCommand <Core.Data.Entities.TrainingBuildCourseAttendee, TrainingBuildCoursesAttendeeCreatedModel, TrainingBuildCoursesAttendeeReadModel>(mapAttendee, message.Principal);
var resultCourseAttendee = await Mediator.Send(courseAttendee, cancellationToken).ConfigureAwait(false);
}
return(result);
}
private async Task <TokenResponse> RefreshAuthenticate(AuthenticateCommand authenticateCommand)
{
var tokenRequest = authenticateCommand.TokenRequest;
var token = tokenRequest.RefreshToken;
// hash refresh_token so session can't be hijacked
var hashedToken = HashToken(token);
var refreshToken = await _dataContext.RefreshTokens
.GetByTokenHashedAsync(hashedToken)
.ConfigureAwait(false);
if (refreshToken == null)
{
Logger.LogWarning($"Refresh token not found; Token: {token}");
throw new AuthenticationException(TokenConstants.Errors.InvalidRequest, "Invalid refresh token");
}
if (DateTimeOffset.UtcNow > refreshToken.Expires)
{
Logger.LogWarning($"Refresh token expired; Token: {token}");
throw new AuthenticationException(TokenConstants.Errors.InvalidRequest, "Refresh token expired");
}
var clientId = refreshToken.ClientId;
var userName = refreshToken.UserName;
// create new token from refresh data
var result = await CreateToken(authenticateCommand.UserAgent, clientId, userName, null, false).ConfigureAwait(false);
// delete refresh token to prevent reuse
_dataContext.RefreshTokens.Remove(refreshToken);
await _dataContext.SaveChangesAsync().ConfigureAwait(false);
return(result);
}
protected override async Task <UserReadModel> ProcessAsync(UserManagementCommand <UserForgotPasswordModel> message, CancellationToken cancellationToken)
{
var model = message.Model;
// check for existing user
var user = await _dataContext.Users
.GetByEmailAddressAsync(model.EmailAddress)
.ConfigureAwait(false);
if (user == null)
{
throw new DomainException(422, $"User with email '{model.EmailAddress}' not found.");
}
var resetToken = Guid.NewGuid().ToString("N");
var resetHash = _passwordHasher.HashPassword(resetToken);
user.ResetHash = resetHash;
user.UpdatedBy = "system";
user.Updated = DateTimeOffset.UtcNow;
await _dataContext
.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false);
var emailModel = new UserResetPasswordEmail
{
EmailAddress = user.EmailAddress,
DisplayName = user.DisplayName,
ResetToken = resetToken,
UserAgent = message.UserAgent,
ResetLink = $"{_hostingOptions.Value.ClientDomain}#/reset-password/{resetToken}"
};
await _emailTemplateService.SendResetPasswordEmail(emailModel).ConfigureAwait(false);
// convert to read model
var readModel = _mapper.Map <UserReadModel>(user);
return(readModel);
}
protected override async Task <UserReadModel> ProcessAsync(UserManagementCommand <UserChangePasswordModel> message, CancellationToken cancellationToken)
{
var model = message.Model;
var userId = message.Principal.Identity.GetUserId();
var emailAddress = message.Principal.Identity.GetUserName();
// check for existing user
var user = await _dataContext.Users
.FindAsync(userId)
.ConfigureAwait(false);
if (user == null)
{
throw new DomainException(422, $"User with email '{emailAddress}' not found.");
}
if (!_passwordHasher.VerifyPassword(user.PasswordHash, model.CurrentPassword))
{
throw new DomainException(HttpStatusCode.Unauthorized, "The password is incorrect");
}
var passwordHashed = _passwordHasher
.HashPassword(model.UpdatedPassword);
user.PasswordHash = passwordHashed;
user.UpdatedBy = emailAddress;
user.Updated = DateTimeOffset.UtcNow;
await _dataContext
.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false);
// convert to read model
var readModel = _mapper.Map <UserReadModel>(user);
return(readModel);
}
protected override async Task <UserReadModel> ProcessAsync(UserManagementCommand <UserResetPasswordModel> message, CancellationToken cancellationToken)
{
var model = message.Model;
// check for existing user
var user = await _dataContext.Users
.GetByEmailAddressAsync(model.EmailAddress)
.ConfigureAwait(false);
if (user == null)
{
throw new DomainException(422, $"User with email '{model.EmailAddress}' not found.");
}
if (!_passwordHasher.VerifyPassword(user.ResetHash, model.ResetToken))
{
throw new DomainException(HttpStatusCode.Forbidden, "Invalid reset password security token.");
}
var passwordHashed = _passwordHasher
.HashPassword(model.UpdatedPassword);
user.PasswordHash = passwordHashed;
user.AccessFailedCount = 0;
user.LockoutEnabled = false;
user.LockoutEnd = null;
user.Updated = DateTimeOffset.UtcNow;
await _dataContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
// convert to read model
var readModel = _mapper.Map <UserReadModel>(user);
return(readModel);
}
protected override async Task <UserReadModel> ProcessAsync(UserManagementCommand <UserRegisterModel> message, CancellationToken cancellationToken)
{
var otp = GenerateRandomOTP(4, saAllowedCharacters);
var model = message.Model;
using (var scope = await _dataContext.Database.BeginTransactionAsync(cancellationToken).ConfigureAwait(false))
{
try
{
// check for existing user
var user = await _dataContext.Users
.GetByEmailAddressAsync(model.EmailAddress)
.ConfigureAwait(false);
if (user != null)
{
throw new DomainException(422, $"User with email '{model.EmailAddress}' already exists.");
}
var passwordHashed = _passwordHasher
.HashPassword(model.Password);
user = new Data.Entities.User
{
EmailAddress = model.EmailAddress,
DisplayName = model.DisplayName,
PasswordHash = passwordHashed,
Created = DateTimeOffset.UtcNow,
Updated = DateTimeOffset.UtcNow,
PhoneNumber = model.PhoneNumber,
OTP = otp,
IsPhoneNumberConfirmed = false,
IsGlobalAdministrator = false
};
await _dataContext.Users
.AddAsync(user, cancellationToken)
.ConfigureAwait(false);
await _dataContext
.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false);
// convert to read model
var readModel = _mapper.Map <UserReadModel>(user);
var currentUser = _mapper.Map <Data.Entities.UserProfile>(user);
var roles = await _dataContext.Roles.GetByNameAsync(Data.Constants.Role.MemberName).ConfigureAwait(false);
var defaultRoles = _mapper.Map <Data.Entities.UserRole>(user);
defaultRoles.RoleId = roles.Id;
defaultRoles.UserType = (int)Enum.Roles.Trainee;
await _dataContext.UserRoles.AddAsync(defaultRoles, cancellationToken).ConfigureAwait(false);
await _dataContext.UserProfiles.AddAsync(currentUser, cancellationToken).ConfigureAwait(false);
var status = await _dataContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
if (status != 0)
{
var result = await _sMSTemplateService.SendOTP(user.PhoneNumber, otp).ConfigureAwait(false);
if (result == false)
{
Logger.LogWarning($"Unable to send OTP '{model.PhoneNumber}' please try again later or contact administrator.");
throw new DomainException(422, $"Unable to send OTP '{model.PhoneNumber}' please try again later or contact administrator.");
}
else
{
scope.Commit();
return(readModel);
}
}
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
scope.Rollback();
throw new DomainException(422, $"Unable to Register:'{ex.Message}', Please try again.");
}
}
return(null);
}
protected override async Task <TrainingVideoReadModel> ProcessAsync(TrainingVideoCommand <TrainingVideoCreateModel> message, CancellationToken cancellationToken)
{
var records = new TrainingVideoReadModel();
var current = _mapper.Map <TrainingVideo>(message.Model);
var result = _mapper.Map <CreateResult>(_dataContext.FindFolder(new TrainingVideoPic()
{
Name = typeof(TrainingVideoPic).Name
}));
if (result == null)
{
result = _dataContext.CreateDir(new TrainingVideoPic()
{
Name = typeof(TrainingVideoPic).Name, ParentPath = null
});
}
if (message.Model.File != null)
{
if (message.Model.File.Length > 0)
{
var file = message.Model.File;
var fileName = ContentDispositionHeaderValue.Parse(file.ContentDisposition).FileName.Trim('"');
using (var ms = new MemoryStream())
{
file.CopyTo(ms);
var now = DateTimeOffset.Now;
result = _dataContext.CreateFile(new TrainingVideoPic()
{
Name = Guid.NewGuid() + "_" + message.Model.File.FileName,
File_stream = ms.ToArray(),
ParentPath = result.Path,
Creation_time = now,
Last_access_time = now,
Last_write_time = now
});
_mapper.Map(result, current);
}
}
}
if (result != null)
{
var dbSet = _dataContext.Set <TrainingVideo>();
await dbSet.AddAsync(current, cancellationToken).ConfigureAwait(false);
var status = await _dataContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
current = await _dataContext.TrainingVideo
.Where(x => x.Id == current.Id).SingleOrDefaultAsync().ConfigureAwait(false);
if (status != 0)
{
_mapper.Map(current, records);
var videofile = _dataContext.TrainingVideoPicFiletable.GetLevelVidoePicId(current.FileId);
_mapper.Map(videofile.FirstOrDefault(), records);
return(records);
}
else
{
Logger.LogWarning($"Unable to insert training video, please try again later or contact administrator.");
throw new DomainException(422, $"Unable to insert training video, please try again later or contact administrator.");
}
}
else
{
Logger.LogWarning($"Unable to insert training video, please try again later or contact administrator.");
throw new DomainException(422, $"Unable to insert training video, please try again later or contact administrator.");
}
}
protected override async Task <UserProfileReadModel> ProcessAsync(UserProfileCommand message, CancellationToken cancellationToken)
{
byte[] bytes;
if (message.UserProfile == null)
{
throw new DomainException(422, $"Unable to Register: User Profile is null , Please try again.");
}
var currentUser = await _dataContext.UserProfiles
.ByUserId(message.UserProfile.UserId)
.ConfigureAwait(false);
if (currentUser == null)
{
throw new DomainException(422, $"User profile not found, Please try again.");
}
_mapper.Map(message.UserProfile, currentUser);
var user = _dataContext.Users.Where(x => x.Id == message.UserProfile.UserId).FirstOrDefault();
if (user == null)
{
throw new DomainException(422, $"User not found, Please try again.");
}
_mapper.Map(currentUser, user);
CreateResult result = new CreateResult();
result = _mapper.Map <CreateResult>(_dataContext.FindFolder(new UserProfilePic()
{
Name = typeof(UserProfilePic).Name
}));
if (result == null)
{
result = _dataContext.CreateDir(new UserProfilePic()
{
Name = typeof(UserProfilePic).Name, ParentPath = null
});
}
if (message.UserProfile.File != null)
{
var file = message.UserProfile.File;
var fileName = ContentDispositionHeaderValue.Parse(file.ContentDisposition).FileName.Trim('"');
using (var ms = new MemoryStream())
{
file.CopyTo(ms);
var now = DateTimeOffset.Now;
var userProfilePic = new UserProfilePic()
{
Stream_id = currentUser.FileId ?? Guid.NewGuid(),
Name = Guid.NewGuid() + "_" + message.UserProfile.File.FileName,
File_stream = ms.ToArray(),
ParentPath = result.Path,
Creation_time = now,
Last_access_time = now,
Last_write_time = now
};
result = currentUser.FileId.HasValue ? _dataContext.UpdateFile(userProfilePic) : _dataContext.CreateFile(userProfilePic);
}
_mapper.Map(result, currentUser);
}
if (result != null)
{
var status = await _dataContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
if (status != 0)
{
return(_mapper.Map <UserProfileReadModel>(currentUser));
}
else
{
Logger.LogWarning($"Unable to update user profile '{currentUser.FullName }' please try again later or contact administrator.");
throw new DomainException(422, $"Unable to update user profile '{currentUser.FullName }' please try again later or contact administrator.");
}
}
else
{
Logger.LogWarning($"Unable to update user profile '{currentUser.FullName }' please try again later or contact administrator.");
throw new DomainException(422, $"Unable to update user profile '{currentUser.FullName }' please try again later or contact administrator.");
}
}
protected override async Task <TrainingVideoReadModel> ProcessAsync(TrainingVideoUpdateCommand <TrainingVideoUpdateModel, Guid> message, CancellationToken cancellationToken)
{
if (message.Id == null)
{
throw new DomainException(422, $"Id is null , Please try again.");
}
var current = await _dataContext.TrainingVideo.GetByKeyAsync
(message.Id);
current = current == null?_mapper.Map <Data.Entities.TrainingVideo>(message.TrainingVideo) :
_mapper.Map(message.TrainingVideo, current);
CreateResult result = new CreateResult();
result = _mapper.Map <CreateResult>(_dataContext.FindFolder(new PaymentTransactionPic()
{
Name = typeof(PaymentTransactionPic).Name
}));
if (result == null)
{
result = _dataContext.CreateDir(new PaymentTransactionPic()
{
Name = typeof(PaymentTransactionPic).Name, ParentPath = null
});
}
if (message.TrainingVideo.File != null)
{
if (message.TrainingVideo.File.Length > 0)
{
var file = message.TrainingVideo.File;
var fileName = ContentDispositionHeaderValue.Parse(file.ContentDisposition).FileName.Trim('"');
using (var ms = new MemoryStream())
{
file.CopyTo(ms);
var now = DateTimeOffset.Now;
var payment = new PaymentTransactionPic()
{
Name = Guid.NewGuid() + "_" + message.TrainingVideo.File.FileName,
File_stream = ms.ToArray(),
ParentPath = result.Path,
Creation_time = now,
Last_access_time = now,
Last_write_time = now,
Stream_id = current == null?Guid.NewGuid() : current.FileId
};
result = _dataContext.UpdateFile(payment);
}
_mapper.Map(result, current);
}
}
if (result != null)
{
if (current.Id == Guid.Empty)
{
var dbSet = _dataContext.Set <Data.Entities.TrainingVideo>();
await dbSet.AddAsync(current, cancellationToken).ConfigureAwait(false);
}
var status = await _dataContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
if (status != 0)
{
return(_mapper.Map <TrainingVideoReadModel>(current));
}
else
{
Logger.LogWarning($"Unable to update training video, please try again later or contact administrator.");
throw new DomainException(422, $"Unable to update training video, please try again later or contact administrator.");
}
}
else
{
Logger.LogWarning($"Unable to update training video, please try again later or contact administrator.");
throw new DomainException(422, $"Unable to update training video, please try again later or contact administrator.");
}
}
protected override async Task <PaymentReadModel> ProcessAsync(PaymentCommand message, CancellationToken cancellationToken)
{
CreateResult result = new CreateResult();
if (message.Payment.UserProfileId == null)
{
throw new DomainException(422, $"User Profile Id is null , Please try again.");
}
var current = _dataContext.PaymentTransactions
.GetByUserProfileId(message.Payment.UserProfileId.Value).Result;
if (!message.Payment.CourseId.HasValue)
{
throw new DomainException(422, $"Course is required for training registration and payments.");
}
var course = _dataContext.TrainingCourse.GetByKey(message.Payment.CourseId.Value);
if (course == null)
{
throw new DomainException(422, $"Course is not exists.");
}
if (course.NoAttendee == course.MaxAttendee)
{
throw new DomainException(422, $"Course is already full., Please select other course or contact System Administrator.");
}
if (current != null)
{
throw new DomainException(422, $"You already register to training, Please contact System Administrator.");
}
current = current == null?_mapper.Map <Data.Entities.PaymentTransaction>(message.Payment) :
_mapper.Map(message.Payment, current);
result = _mapper.Map <CreateResult>(_dataContext.FindFolder(new PaymentTransactionPic()
{
Name = typeof(PaymentTransactionPic).Name
}));
if (result == null)
{
result = _dataContext.CreateDir(new PaymentTransactionPic()
{
Name = typeof(PaymentTransactionPic).Name, ParentPath = null
});
}
if (message.Payment.File != null)
{
if (message.Payment.File.Length > 0)
{
var file = message.Payment.File;
var fileName = ContentDispositionHeaderValue.Parse(file.ContentDisposition).FileName.Trim('"');
using (var ms = new MemoryStream())
{
file.CopyTo(ms);
var now = DateTimeOffset.Now;
var payment = new PaymentTransactionPic()
{
Name = Guid.NewGuid() + "_" + message.Payment.File.FileName,
File_stream = ms.ToArray(),
ParentPath = result.Path,
Creation_time = now,
Last_access_time = now,
Last_write_time = now,
Stream_id = current.FileId ?? Guid.NewGuid()
};
result = _dataContext.CreateFile(payment);
}
_mapper.Map(result, current);
}
}
if (result != null)
{
if (current.Id == Guid.Empty)
{
var dbSet = _dataContext.Set <Data.Entities.PaymentTransaction>();
await dbSet
.AddAsync(current, cancellationToken)
.ConfigureAwait(false);
}
var status = await _dataContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
if (status != 0)
{
var msg = string.Format(@"Request for TOT payment approval. Id: {0}", current.Id);
await _sMSTemplateService.ForApproval(_smsConfiguration.Value.Admin, msg)
.ConfigureAwait(false);
var history = _mapper.Map <Data.Entities.PaymentTransactionHistory>(current);
var dbSetHistory = _dataContext.Set <Data.Entities.PaymentTransactionHistory>();
await dbSetHistory.AddAsync(history, cancellationToken).ConfigureAwait(false);
await _dataContext.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
return(_mapper.Map <PaymentReadModel>(current));
}
else
{
Logger.LogWarning($"Unable to update user your payment, please try again later or contact administrator.");
throw new DomainException(422, $"Unable to update user your payment, please try again later or contact administrator.");
}
}
else
{
Logger.LogWarning($"Unable to update user your payment, please try again later or contact administrator.");
throw new DomainException(422, $"Unable to update user your payment, please try again later or contact administrator.");
}
}
