//IDictionary<cor_useraccount, IdentityResult> result = new Dictionary<cor_useraccount, IdentityResult>
// {
// { user, await _userManager.CreateAsync(user, "Password@1") },
// };
private async Task <IdentityResult> AddUpdateAsUserAsync(cor_staff item, string userId, string username)
{
IdentityResult result = new IdentityResult();
var staff = _userManager.Users.FirstOrDefault(x => x.StaffId == item.StaffId);
var user = new cor_useraccount();
if (staff == null)
{
user.PhoneNumber = item.PhoneNumber;
user.Email = item.Email;
user.IsFirstLoginAttempt = true;
user.StaffId = item.StaffId;
user.LastLoginDate = DateTime.Now;
user.Deleted = false;
user.CreatedOn = DateTime.Now;
user.IsActive = true;
user.UserName = username;
user.Active = true;
return(result = await _userManager.CreateAsync(user, "Password@1"));
}
var exUser = await _userManager.FindByIdAsync(staff.Id);
if (exUser != null)
{
exUser.PhoneNumber = item.PhoneNumber;
exUser.Email = item.Email;
exUser.UpdatedOn = DateTime.Now;
exUser.UserName = username;
result = await _userManager.UpdateAsync(exUser);
}
return(result);
}
public static Tracker CollectAsMuchAsPossible(cor_useraccount user, AuthenticationResult result, OTPLoginCommand request)
{
return(new Tracker
{
Email = user.Email
});
}
public async Task <bool> SendOTPToEmailAsync(cor_useraccount user)
{
_logger.Information("I am in SendOTPToEmailAsync ");
var newOtp = await ProduceOtpAsync(user);
await SendOTPEmailAsync(newOtp);
return(await _security.SaveChangesAsync() > 0);
}
public static Tracker CollectAsMuchAsPossible(cor_useraccount user, AuthenticationResult result, IDetectionService device)
{
var tr = new Tracker();
tr.Browser = device.Browser.Name.ToString();
tr.Device = device.Device.Type.ToString();
tr.Os = device.Engine.Name.ToString();
tr.Os_Device = device.UserAgent.ToString();
tr.Token = result.Token;
tr.UserId = user.Id;
tr.UserAgent = device.UserAgent.ToString();
tr.Email = user.Email;
return(tr);
}
private async Task CreateRolesAndAdminUser(IServiceProvider serviceProvider)
{
var RoleManager = serviceProvider.GetRequiredService <RoleManager <cor_userrole> >();
var UserManager = serviceProvider.GetRequiredService <UserManager <cor_useraccount> >();
string[] roleNames = { StaticRoles.GODP };
IdentityResult roleResult;
foreach (var roleName in roleNames)
{
var roleExist = await RoleManager.RoleExistsAsync(roleName);
if (!roleExist)
{
roleResult = await RoleManager.CreateAsync(new cor_userrole { Name = roleName });
}
}
var userSettings = new UserSettings();
Configuration.GetSection(nameof(UserSettings)).Bind(userSettings);
var adminPassword = userSettings.Password;
var adminUser = new cor_useraccount()
{
Email = userSettings.Email,
UserName = userSettings.UserName,
};
var user = await UserManager.FindByEmailAsync(userSettings.Email);
if (user == null)
{
var created = await UserManager.CreateAsync(adminUser, adminPassword);
if (created.Succeeded)
{
var added = await UserManager.AddToRolesAsync(adminUser, roleNames);
if (!added.Succeeded)
{
Console.Write(added.Errors);
}
}
}
}
private async Task <OTPTracker> ProduceOtpAsync(cor_useraccount user)
{
Random rnd = new Random();
var otp = (rnd.Next(100000, 999999)).ToString();
var newOtp = new OTPTracker
{
DateIssued = DateTime.Now,
ExpiryDate = DateTime.Now.AddMinutes(2),
OTP = otp,
UserId = user.Id,
Email = user.Email,
};
_logger.Information("I am in ProduceOtpAsync ");
await _security.OTPTracker.AddAsync(newOtp);
return(newOtp);
}
public async Task <AuthenticationResult> LoginAsync(cor_useraccount user)
{
return(await GenerateAuthenticationResultForUserAsync(user));
}
//public async Task<AuthenticationResult> RegisterAsync(UserRegistrationReqObj userRegistration)
//{
// try
// {
// var existingUser = await _userManager.FindByEmailAsync(userRegistration.Email);
// if (existingUser != null)
// {
// return new AuthenticationResult
// {
// //Errors = new[] { "" },
// Status = new APIResponseStatus
// {
// IsSuccessful = false,
// Message = new APIResponseMessage
// {
// FriendlyMessage = "User with this email address already exist"
// }
// }
// };
// }
// var user = new cor_useraccount
// {
// Email = userRegistration.Email,
// UserName = userRegistration.Email,
// };
// var createdUser = await _userManager.CreateAsync(user, "Password@1");
// if (!createdUser.Succeeded)
// {
// return new AuthenticationResult
// {
// Status = new APIResponseStatus
// {
// IsSuccessful = false,
// Message = new APIResponseMessage
// {
// FriendlyMessage = createdUser.Errors.Select(x => x.Description).FirstOrDefault(),
// }
// }
// };
// }
// return await GenerateAuthenticationResultForUserAsync(user);
// }
// catch (Exception ex)
// {
// #region Log error
// var errorCode = ErrorID.Generate(4);
// _logger.Error($"ErrorID : RegisterAsync{errorCode} Ex : {ex?.Message ?? ex?.InnerException?.Message} ErrorStack : {ex?.StackTrace}");
// return new AuthenticationResult
// {
// Status = new APIResponseStatus
// {
// Message = new APIResponseMessage
// {
// FriendlyMessage = "Error occured!! Please tyr again later",
// MessageId = errorCode,
// TechnicalMessage = $"ErrorID : RegisterAsync{errorCode} Ex : {ex?.Message ?? ex?.InnerException?.Message} ErrorStack : {ex?.StackTrace}"
// }
// }
// };
// #endregion
// }
//}
private async Task <AuthenticationResult> GenerateAuthenticationResultForUserAsync(cor_useraccount user)
{
try
{
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_jwtSettings.Secret);
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Sub, user.Email),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Email, user.Email),
new Claim("userId", user.Id),
new Claim("staffId", user.StaffId.ToString()),
};
var userClaims = await _userManager.GetClaimsAsync(user);
claims.AddRange(userClaims);
var userRoles = await _userManager.GetRolesAsync(user);
foreach (var userRole in userRoles)
{
claims.Add(new Claim(ClaimTypes.Role, userRole) ?? null);
var role = await _roleManager.FindByNameAsync(userRole);
if (role == null)
{
continue;
}
var roleClaims = await _roleManager.GetClaimsAsync(role);
foreach (var roleClaim in roleClaims)
{
if (claims.Contains(roleClaim))
{
continue;
}
claims.Add(roleClaim);
}
}
var tokenDecriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(claims),
Expires = DateTime.UtcNow.Add(_jwtSettings.TokenLifeSpan),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDecriptor);
var refreshToken = new RefreshToken
{
JwtId = token.Id,
UserId = user.Id,
CreationDate = DateTime.UtcNow,
ExpiryDate = DateTime.UtcNow.AddSeconds(6),
};
try
{
await _dataContext.RefreshTokens.AddAsync(refreshToken);
await _dataContext.SaveChangesAsync();
}
catch (Exception ex)
{
return(new AuthenticationResult
{
Status = new APIResponseStatus
{
IsSuccessful = false,
Message = new APIResponseMessage
{
FriendlyMessage = $"Something went wrong: {ex.InnerException.Message}",
}
}
});
}
return(new AuthenticationResult
{
Token = tokenHandler.WriteToken(token),
RefreshToken = refreshToken.Token,
});
}
catch (Exception ex)
{
#region Log error
var errorCode = ErrorID.Generate(4);
_logger.Error($"ErrorID : {errorCode} Ex : {ex?.Message ?? ex?.InnerException?.Message} ErrorStack : {ex?.StackTrace}");
return(new AuthenticationResult
{
Status = new APIResponseStatus
{
Message = new APIResponseMessage
{
FriendlyMessage = "Error occured!! Please tyr again later",
MessageId = errorCode,
TechnicalMessage = $"ErrorID : {errorCode} Ex : {ex?.Message ?? ex?.InnerException?.Message} ErrorStack : {ex?.StackTrace}"
}
}
});
#endregion
}
}
public async Task <bool> UploadStaffAsync(List <StaffObj> staffs, string createdBy)
{
try
{
List <cor_staff> structures = new List <cor_staff>();
if (staffs.Count > 0)
{
foreach (var item in staffs)
{
int jobTitleId = 0;
int stateId = 0;
int countryId = 0;
int staffOfficeId = 0;
if (item.JobTitleName != null)
{
jobTitleId = _dataContext.cor_jobtitles.FirstOrDefault(x => x.Name.ToLower().Contains(item.JobTitleName.ToLower())).JobTitleId;
if (jobTitleId < 1)
{
throw new Exception("Invalid Selection", new Exception("Please select a valid Jobtitle"));
}
}
if (item.CountryName != null)
{
countryId = _dataContext.cor_country.FirstOrDefault(x => x.CountryName.ToLower().Contains(item.CountryName.ToLower())).CountryId;
if (countryId < 0)
{
throw new Exception("Invalid Selection", new Exception("Please select a valid country name"));
}
}
if (item.StateName != null)
{
stateId = _dataContext.cor_state.FirstOrDefault(x => x.StateName.ToLower().Contains(item.StateName.ToLower())).StateId;
if (stateId < 0)
{
throw new Exception("Invalid Selection", new Exception("Please select a valid state name"));
}
}
if (item.StaffOfficeName != null)
{
staffOfficeId = _dataContext.cor_companystructure.FirstOrDefault(x => x.Name.ToLower().Contains(item.StaffOfficeName.ToLower())).CompanyStructureId;
if (staffOfficeId < 0)
{
throw new Exception("Invalid Selection", new Exception("Please select a valid office or company"));
}
}
if (!await StaffCodeExistAsync(item.StaffCode))
{
var structure = new cor_staff
{
StaffCode = item.StaffCode,
FirstName = item.FirstName,
LastName = item.LastName,
MiddleName = item.MiddleName,
JobTitle = jobTitleId,
PhoneNumber = item.PhoneNumber,
Email = item.Email,
Address = item.Address,
DateOfBirth = item.DateOfBirth,
Gender = item.Gender == "Male" ? "1" : "2",
StateId = stateId,
CountryId = countryId,
StaffOfficeId = staffOfficeId,
AccessLevel = null,
StaffLimit = item.StaffLimit,
CreatedBy = createdBy,
CreatedOn = DateTime.Now,
Active = true,
Deleted = false,
};
structures.Add(structure);
}
}
_dataContext.cor_staff.AddRange(structures);
}
bool response = false;
try
{
response = _dataContext.SaveChanges() > 0;
if (response)
{
try
{
foreach (var item in structures)
{
var staff = _dataContext.cor_staff.Where(x => x.StaffCode == item.StaffCode).FirstOrDefault();
if (staff != null)
{
var user = new cor_useraccount
{
UserName = item.FirstName.ToLower(),
StaffId = staff.StaffId,
Email = item.Email,
EmailConfirmed = true,
PhoneNumber = item.PhoneNumber,
PhoneNumberConfirmed = true,
TwoFactorEnabled = false,
LockoutEnabled = true,
AccessFailedCount = 0,
IsFirstLoginAttempt = true,
SecurityAnswer = "",
NextPasswordChangeDate = DateTime.Now.AddDays(30),
IsActive = true,
CreatedBy = staff.CreatedBy,
CreatedOn = DateTime.Now,
Active = true,
Deleted = false,
};
var created = await _userManager.CreateAsync(user, "Password@1");
}
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
return(response);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public Task <bool> SendOTPEmailAsync(cor_useraccount user)
{
throw new NotImplementedException();
}
private async Task <IdentityResult> AddUpdateUserRolesAsync(IEnumerable <string> UserRoleNames, cor_useraccount user)
{
var result = new IdentityResult();
if (user != null)
{
var userRoles = await _userManager.GetRolesAsync(user);
if (userRoles.Count() > 0)
{
result = await _userManager.RemoveFromRolesAsync(user, await _userManager.GetRolesAsync(user));
}
result = await _userManager.AddToRolesAsync(user, UserRoleNames);
}
return(result);
}
public async Task <StaffRegRespObj> Handle(UpdateStaffCommand request, CancellationToken cancellationToken)
{
var response = new StaffRegRespObj {
Status = new APIResponseStatus {
IsSuccessful = false, Message = new APIResponseMessage()
}
};
try
{
var userFromRepoExist = await _userManager.Users.FirstOrDefaultAsync(x => x.UserName.Trim().ToLower() == request.UserName.Trim().ToLower());
var actionTaken = request.StaffId > 0 ? "updated" : "created";
String tempUserId = String.Empty;
if (request.StaffId < 1)
{
if (userFromRepoExist != null)
{
response.Status.Message.FriendlyMessage = "Username Already assigned to a staff";
return(response);
}
}
if (request.StaffId < 1)
{
if (await _userManager.Users.AnyAsync(x => x.Email.Trim().ToLower() == request.Email.Trim().ToLower()))
{
response.Status.Message.FriendlyMessage = "Staff email already belongs to a user";
return(response);
}
}
IdentityResult AddUpdateAsUser = new IdentityResult();
using (var _transaction = await _dataContext.Database.BeginTransactionAsync())
{
var stCode = StaffCode.Generate(_dataContext.cor_staff.Where(s => s.Deleted == false).OrderBy(d => d.StaffId).LastOrDefault()?.StaffId ?? 1);
try
{
var stf = new cor_staff();
stf.AccessLevel = request.AccessLevel;
stf.Address = request.Address;
stf.CountryId = request.CountryId;
stf.PhoneNumber = request.PhoneNumber;
stf.Email = request.Email;
stf.StateId = request.StateId;
stf.DateOfBirth = request.DateOfBirth;
stf.FirstName = request.FirstName;
stf.MiddleName = request.MiddleName;
stf.Gender = request.Gender;
stf.JobTitle = request.JobTitle;
stf.LastName = request.LastName;
stf.Photo = request.Photo ?? null;
stf.StaffCode = request.StaffId > 0 ? request.StaffCode : stCode;
stf.StaffLimit = request.StaffLimit;
stf.StaffOfficeId = request.StaffOfficeId;
stf.StaffId = request.StaffId;
stf.IsHRAdmin = request.IsHRAdmin;
stf.PPEAdmin = request.PPEAdmin;
stf.IsPandPAdmin = request.IsPandPAdmin;
stf.IsCreditAdmin = request.IsCreditAdmin;
stf.IsInvestorFundAdmin = request.IsInvestorFundAdmin;
stf.IsDepositAdmin = request.IsDepositAdmin;
stf.IsTreasuryAdmin = request.IsTreasuryAdmin;
stf.IsExpenseManagementAdmin = request.IsExpenseManagementAdmin;
stf.IsFinanceAdmin = request.IsFinanceAdmin;
var staffIsCreated = await _adminRepo.AddUpdateStaffAsync(stf);
if (staffIsCreated)
{
var user = new cor_useraccount();
user.PhoneNumber = request.PhoneNumber;
user.UserName = request.UserName;
user.Email = request.Email;
user.IsFirstLoginAttempt = true;
user.Active = true;
user.Deleted = false;
user.CreatedBy = "admin";
user.CreatedOn = DateTime.Now;
user.StaffId = stf.StaffId;
user.IsActive = request.UserStatus.Trim().ToLower() == "true"? true : false;
user.LastLoginDate = DateTime.Now;
if (userFromRepoExist == null)
{
AddUpdateAsUser = await _userManager.CreateAsync(user, "Password@1");
tempUserId = user.Id;
if (!AddUpdateAsUser.Succeeded)
{
await _transaction.RollbackAsync();
response.Status.Message.FriendlyMessage = AddUpdateAsUser.Errors.FirstOrDefault().Description;
return(response);
}
}
else
{
cor_useraccount alreadExistingUser = new cor_useraccount();
alreadExistingUser = await _userManager.FindByNameAsync(userFromRepoExist.UserName);
alreadExistingUser.PhoneNumber = request.PhoneNumber;
alreadExistingUser.UserName = request.UserName;
alreadExistingUser.Email = request.Email;
alreadExistingUser.IsFirstLoginAttempt = false;
alreadExistingUser.StaffId = stf.StaffId;
tempUserId = alreadExistingUser.Id;
AddUpdateAsUser = await _userManager.UpdateAsync(alreadExistingUser);
if (!AddUpdateAsUser.Succeeded)
{
await _transaction.RollbackAsync();
response.Status.Message.FriendlyMessage = AddUpdateAsUser.Errors.FirstOrDefault().Description;
return(response);
}
}
if (AddUpdateAsUser.Succeeded)
{
if (request.UserAccessLevels.Length > 0)
{
List <cor_useraccess> useAccesses = new List <cor_useraccess>();
foreach (var acessLevelId in request.UserAccessLevels)
{
var access = new cor_useraccess();
access.AccessLevelId = acessLevelId;
access.UserId = tempUserId;
useAccesses.Add(access);
}
await _adminRepo.AddUpdateUseraccessAsync(useAccesses);
}
if (request.UserRoleNames.Length > 0)
{
if (userFromRepoExist != null)
{
var removed = await _userManager.RemoveFromRolesAsync(userFromRepoExist, await _userManager.GetRolesAsync(userFromRepoExist));
if (!removed.Succeeded)
{
await _transaction.RollbackAsync();
response.Status.Message.FriendlyMessage = removed.Errors.FirstOrDefault().Description;
return(response);
}
var updated = await _userManager.AddToRolesAsync(userFromRepoExist, request.UserRoleNames);
if (!updated.Succeeded)
{
await _transaction.RollbackAsync();
response.Status.Message.FriendlyMessage = updated.Errors.FirstOrDefault().Description;
return(response);
}
}
else
{
var UpdateUserRoles = await _userManager.AddToRolesAsync(user, request.UserRoleNames);
if (!UpdateUserRoles.Succeeded)
{
await _transaction.RollbackAsync();
response.Status.Message.FriendlyMessage = UpdateUserRoles.Errors.FirstOrDefault().Description;
return(response);
}
}
}
await SendStaffAccountDetailMail(request.Email, request.UserName, request.FirstName + " " + request.LastName, actionTaken);
await _transaction.CommitAsync();
}
}
}
catch (Exception ex)
{
await _transaction.RollbackAsync();
#region Log error to file
var errorCode = ErrorID.Generate(4);
_logger.Error($"ErrorID : {errorCode} Ex : {ex?.Message ?? ex?.InnerException?.Message} ErrorStack : {ex?.StackTrace}");
return(new StaffRegRespObj
{
Status = new APIResponseStatus
{
IsSuccessful = false,
Message = new APIResponseMessage
{
FriendlyMessage = ex?.Message,
MessageId = errorCode,
TechnicalMessage = $"ErrorID : {errorCode} Ex : {ex?.Message ?? ex?.InnerException?.Message} ErrorStack : {ex?.StackTrace}"
}
}
});
#endregion
}
finally { await _transaction.DisposeAsync(); }
return(new StaffRegRespObj
{
Status = new APIResponseStatus
{
IsSuccessful = true,
Message = new APIResponseMessage
{
FriendlyMessage = $"Staff Details have successfully been {actionTaken}",
}
}
});
}
}
catch (Exception ex)
{
#region Log error to file
var errorCode = ErrorID.Generate(4);
_logger.Error($"ErrorID : {errorCode} Ex : {ex?.Message ?? ex?.InnerException?.Message} ErrorStack : {ex?.StackTrace}");
return(new StaffRegRespObj
{
Status = new APIResponseStatus
{
IsSuccessful = false,
Message = new APIResponseMessage
{
FriendlyMessage = "Error occured!! Unable to process request",
MessageId = errorCode,
TechnicalMessage = $"ErrorID : {errorCode} Ex : {ex?.Message ?? ex?.InnerException?.Message} ErrorStack : {ex?.StackTrace}"
}
}
});
#endregion
}
}
