public async Task <VmUser> UpdateUserDetails(VmUser userDets)
{
VmUser result = null;
if (userDets.UserEmail == null && userDets.DecryptedUserEmail != null)
{
userDets.UserEmail = userDets.DecryptedUserEmail;
}
if (!string.IsNullOrEmpty(userDets.UserEmail))
{
var existingUser = await _dbContext.User.AsNoTracking().Where(x => x.user_email == userDets.UserEmail).FirstOrDefaultAsync();
User entity = new User()
{
id = existingUser.id,
user_email = existingUser.user_email,
user_contact = userDets.UserContact,
user_name = userDets.UserName,
user_encryptedkey = existingUser.user_encryptedkey,
user_encryptedmessage = existingUser.user_encryptedmessage,
modified_date = DateTime.Now
};
var execResult = _dbContext.User.Update(entity);
await _dbContext.SaveChangesAsync();
result = new VmUser(execResult.Entity);
result.DecryptedUserEmail = result.UserEmail;
result.UserEmail = _encryption.EncryptText(result.DecryptedUserEmail, ATMConstants.emailEncKey);
}
return(result);
}
public async Task GetPageForNewUserTest()
{
//Arrange
var vmUser = new VmUser
{
LastName = "New",
FirstName = "New",
Email = "New@New",
UserName = "******"
};
var vmNewUser = await _usersService.Create(vmUser, "new12345!");
var newUser = new VmUserConverter().ToModel(vmNewUser);
var pageOptions = new PageOptions
{
PageNumber = 0,
PageSize = 10,
};
//Act
var goals = (await _service.GetPage(newUser, null, pageOptions)).ToArray();
//Assert
Assert.AreEqual(0, goals.Length);
}
private async Task <VmUser> GetUserProfile(string userEmail)
{
ModelState.Clear();
VmUser user = await _userService.GetUserProfile(userEmail);
return(user);
}
public async Task <IActionResult> UpdateUserDetail(VmUser userDets)
{
ModelState.Clear();
var result = await _userService.UpdateUserDetails(userDets);
return(View("LoginUser", result));
}
public IActionResult Index()
{
ModelState.Clear();
VmUser user = new VmUser();
return(View(user));
}
public IActionResult Details(long?id)
{
if (id == null)
{
return(NotFound());
}
User obj = _userRepository.FindByID(id.Value);
if (obj == null)
{
return(NotFound());
}
var model = new VmUser()
{
FirstName = obj.FirstName,
SecondName = obj.SecondName,
MiddleName = obj.MiddleName,
BirthDay = obj.BirthDay,
Sex = obj.Sex,
Snils = obj.Snils
};
return(View(model));
}
public async Task <IActionResult> CreateUser([FromBody] VmUserCreate vmUserCreate)
{
if (ModelState.IsValid)
{
try
{
User createdUser = await _userService.CreateUser(vmUserCreate);
VmUser vmUser = _mapper.Map <VmUser>(createdUser);
return(Ok(DataMessage.Data(vmUser)));
}
catch (AppException ex)
{
return(BadRequest(ex.ReturnBadRequest()));
}
catch (Exception ex)
{
return(BadRequest(AppException.ReturnBadRequest(ex.Message)));
}
}
else
{
return(BadRequest(AppException.ReturnBadRequest(ModelState)));
}
}
public async Task <VmUser> UpdatePassword(VmUser userDets)
{
VmUser result = null;
if (userDets.UserEmail == null && userDets.DecryptedUserEmail != null)
{
userDets.UserEmail = userDets.DecryptedUserEmail;
}
if (!string.IsNullOrEmpty(userDets.UserEmail))
{
var existingUser = await _dbContext.User.AsNoTracking().Where(x => x.user_email == userDets.UserEmail).FirstOrDefaultAsync();
var newKey = _encryption.EncryptText(userDets.UserEncyryptedKey, userDets.UserEncryptionMessage);
var masterKey = userDets.UserEmail.Substring(2, 4);
var newMessage = _encryption.EncryptText(userDets.UserEncryptionMessage, masterKey);
existingUser.user_encryptedkey = newKey;
existingUser.user_encryptedmessage = newMessage;
var execResult = _dbContext.User.Update(existingUser);
await _dbContext.SaveChangesAsync();
result = new VmUser(execResult.Entity);
result.DecryptedUserEmail = result.UserEmail;
result.UserEmail = _encryption.EncryptText(result.DecryptedUserEmail, ATMConstants.emailEncKey);
}
return(result);
}
public async Task LoginTest()
{
//Arrange
var vmUser = new VmUser
{
UserName = "******",
Email = "*****@*****.**",
Phone = "123",
FirstName = "FirstName",
MiddleName = "MiddleName",
LastName = "LastName"
};
var user = _vmConverter.ToModel(vmUser);
await _userManager.CreateAsync(user, "Password!");
var authInput = new VmAuthInput
{
UserName = vmUser.Email,
Password = "******"
};
//Act
var authOutput = await _authenticationService.Login(authInput);
//Assert
Assert.IsNotNull(authOutput?.Token);
Assert.IsFalse(string.IsNullOrWhiteSpace(authOutput.User.Id));
Assert.AreEqual(vmUser.FirstName, authOutput.User.FirstName);
Assert.AreEqual(vmUser.MiddleName, authOutput.User.MiddleName);
Assert.AreEqual(vmUser.LastName, authOutput.User.LastName);
Assert.AreEqual(vmUser.Email, authOutput.User.Email);
Assert.AreEqual(vmUser.Phone, authOutput.User.Phone);
}
public ActionResult Update(VmUser user)
{
User usr = (User)Session["Loginer"];
//User usr = db.User.Find(user.userId);
if (usr == null)
{
return(HttpNotFound());
}
if (ModelState.IsValid)
{
if (user.Name != null)
{
usr.Name = user.Name;
}
if (user.Surname != null)
{
usr.Surname = user.Surname;
}
if (user.Phone != null)
{
usr.Phone = user.Phone;
}
if (user.Email != null)
{
usr.Email = user.Email;
}
if (user.Username != null)
{
usr.Username = user.Username;
}
if (user.ImageFile != null)
{
if (usr.Image != null)
{
string oldImagePath = Path.Combine(Server.MapPath("~/Uploads/User/"), usr.Image);
System.IO.File.Delete(oldImagePath);
string imageName = DateTime.Now.ToString("ddMMyyyyHHmmssfff") + user.ImageFile.FileName;
string imagePath = Path.Combine(Server.MapPath("~/Uploads/User/"), imageName);
user.ImageFile.SaveAs(imagePath);
usr.Image = imageName;
}
else
{
string imageName = DateTime.Now.ToString("ddMMyyyyHHmmssfff") + user.ImageFile.FileName;
string imagePath = Path.Combine(Server.MapPath("~/Uploads/User/"), imageName);
user.ImageFile.SaveAs(imagePath);
usr.Image = imageName;
}
}
db.Entry(usr).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(user));
}
public async Task <IActionResult> UpdateUserPassword(VmUser userDets)
{
ModelState.Clear();
var result = await _userService.UpdatePassword(userDets);
result.UserEmail = result.DecryptedUserEmail;
return(View("Index", result));
}
public IActionResult RegisterProfile(VmUser u)
{
ApplicationDbContext database = new ApplicationDbContext();
string currentUser = User.Identity.Name;
var qUser = database.Users.Where(c => (c.Id == u.UserId || c.UserName == currentUser) && c.EmailConfirmed == true).FirstOrDefault();
if (qUser == null)
{
return(Redirect(nameof(AccountController.Profile)));
}
string CurrentMobile = u.Mobile;
if (qUser.Mobile == CurrentMobile)
{
qUser.FirstName = u.FirstName;
qUser.LastName = u.LastName;
database.Users.Attach(qUser);
database.Entry(qUser).State = EntityState.Modified;
database.SaveChanges();
return(Redirect(nameof(AccountController.Profile)));
}
else
{
bool isExistMob = database.Users.ToList().Exists(c => c.Mobile == u.Mobile);
if (isExistMob == true) // اگر پیدا شد
{
TempData["Style"] = "alert alert-warning text-center";
TempData["Message"] = "شماره موبایل وارد شده از قبل در سیستم وجود دارد";
return(Redirect(nameof(AccountController.Profile)));
}
else
{
qUser.FirstName = u.FirstName;
qUser.LastName = u.LastName;
qUser.Mobile = u.Mobile;
database.Users.Attach(qUser);
database.Entry(qUser).State = EntityState.Modified;
database.SaveChanges();
return(Redirect(nameof(AccountController.Profile)));
}
}
//bool isExistMob = database.Users.ToList().Exists(c => c.Mobile == u.Mobile);
//if (isExistMob == true) // اگر پیدا شد
//{
// TempData["Style"] = "alert alert-warning text-center";
// TempData["Message"] = "شماره موبایل وارد شده از قبل در سیستم وجود دارد";
// return Redirect(nameof(AccountController.Profile));
//}
//else
//{
//}
}
public async Task <VmUser> GetUserProfile(string user_email)
{
var entity = await _dbContext.User.AsNoTracking().Where(x => x.user_email == user_email).FirstOrDefaultAsync();
var retUser = new VmUser(entity);
retUser.DecryptedUserEmail = retUser.UserEmail;
retUser.UserEmail = _encryption.EncryptText(retUser.DecryptedUserEmail, ATMConstants.emailEncKey);
return(retUser);
}
private async Task LoadAsync(VmUser user)
{
var email = await _userManager.GetEmailAsync(user);
Email = email;
Input = new InputModel
{
NewEmail = email,
};
IsEmailConfirmed = await _userManager.IsEmailConfirmedAsync(user);
}
public async Task <VmUser> AddNewUser(VmUser userInput)
{
VmUser retUser = null;
if (!string.IsNullOrEmpty(userInput.UserEmail) && !(string.IsNullOrEmpty(userInput.UserEncyryptedKey)))
{
var checkUserExists = await _dbContext.User.AsNoTracking().Where(x => x.user_email == userInput.UserEmail).FirstOrDefaultAsync();
if (checkUserExists != null)
{
retUser = new VmUser(checkUserExists);
retUser.Message = "User with same email id exists";
return(retUser);
}
else
{
var masterKey = userInput.UserEmail.Substring(2, 4);
User entity = new User()
{
user_email = userInput.UserEmail,
user_contact = userInput.UserContact,
user_encryptedkey = _encryption.EncryptText(userInput.UserEncyryptedKey, userInput.UserEncryptionMessage),
user_encryptedmessage = _encryption.EncryptText(userInput.UserEncryptionMessage, masterKey),
user_name = userInput.UserName
};
var execResult = await _dbContext.User.AddAsync(entity);
await _dbContext.SaveChangesAsync();
if (execResult.Entity != null)
{
retUser = new VmUser(execResult.Entity);
retUser.DecryptedUserEmail = retUser.UserEmail;
retUser.UserEmail = _encryption.EncryptText(retUser.DecryptedUserEmail, ATMConstants.emailEncKey);
retUser.Message = "User Added Successfully";
return(retUser);
}
}
}
else
{
retUser = new VmUser();
retUser.Message = "User Email and password cannot be blank";
return(retUser);
}
return(retUser);
}
private async Task LoadAsync(VmUser user)
{
// var userName = await _userManager.GetUserNameAsync(user);
var usr = await _userManager.GetUserAsync(User);
Username = usr.UserName;
Input = new InputModel
{
PhoneNumber = usr.PhoneNumber,
FirstName = usr.FirstName,
LastName = usr.LastName
};
}
public async Task <IActionResult> LoginUser(VmUser userLogin)
{
ModelState.Clear();
var lResult = await _userService.ValidateUserLogin(userLogin);
if (string.IsNullOrEmpty(lResult.Message))
{
return(View(lResult));
}
else
{
return(View("Index", lResult));
}
}
public async Task <IActionResult> RegisterNewUser(VmUser userDets)
{
ModelState.Clear();
var result = await _userService.AddNewUser(userDets);
if (!string.IsNullOrEmpty(result.Message))
{
return(View("Index", result));
}
else
{
return(View("LoginUser", result));
}
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new VmUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code, returnUrl = returnUrl },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email,
_htmlPageLoc["Confirm your email"].Value,
_htmlPageLoc["Please confirm your account by", HtmlEncoder.Default.Encode(callbackUrl)].Value
);
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public IActionResult CheckoutSendType(decimal FinalPrice)
{
ApplicationDbContext database = new ApplicationDbContext();
if (User.Identity.IsAuthenticated)
{
string currentUser = User.Identity.Name;//get Username
var qUser = database.Users.Where(c => c.UserName == currentUser).FirstOrDefault();
if (qUser == null)
{
return(null);
}
if (string.IsNullOrEmpty(qUser.FirstName) || string.IsNullOrEmpty(qUser.LastName) || string.IsNullOrEmpty(qUser.Mobile))
{
TempData["Style"] = "alert alert-warning text-center";
TempData["Msg"] = "جهت ادامه خرید شما باید اطلاعات کاربری خود را تکمیل نمایید";
return(RedirectToAction(nameof(AccountController.Profile), "Account"));
}
if (string.IsNullOrEmpty(qUser.PostalCode) || string.IsNullOrEmpty(qUser.City) || string.IsNullOrEmpty(qUser.Address))
{
TempData["Style"] = "alert alert-warning text-center";
TempData["Msg"] = "جهت ادامه خرید شما باید اطلاعات محل سکونت خود را تکمیل نمایید";
return(RedirectToAction(nameof(AccountController.PostInfo), "Account"));
}
VmUser vm = new VmUser();
vm.Address = qUser.Address;
vm.City = qUser.City;
vm.Email = qUser.Email;
vm.FirstName = qUser.FirstName;
vm.LastName = qUser.LastName;
vm.Mobile = qUser.Mobile;
vm.PhoneNumber = qUser.PhoneNumber;
vm.PostalCode = qUser.PostalCode;
vm.Province = qUser.Province;
vm.UserId = qUser.Id;
vm.Username = qUser.UserName;
ViewBag.FinalPrice = FinalPrice;
return(View(vm));
}
else
{
return(RedirectToAction(nameof(AccountController.Login), "Account"));
}
}
public static List <VmKoOrder> GetOrdersList(truckloadEntities db, VmUser currentUser, long?orderId = null, string orderNumberFilter = "", long?loadId = null)
{
var isSingleOrder = orderId != null;
var isByLoadId = loadId != null;
var query = from h in db.Orders select h;
if (isSingleOrder)
{
query = query.Where(o => o.OrderId == orderId);
}
query = isByLoadId ?
query.Where(o => o.LoadId == loadId) :
query.Where(o => o.LoadId == null);
if (!orderNumberFilter.IsNullOrEmpty())
{
query = query.Where(o => o.OrderNumber.Contains(orderNumberFilter));
}
var orders = query.Select(d => new VmKoOrder()
{
OrderId = d.OrderId,
OrderNumber = d.OrderNumber,
CustomerName = d.CustomerName,
CustomerAddress = d.CustAddress,
UserName = d.UserLogin1.UserName ?? d.UserLogin.UserName,
LastChangeDate = d.ModifiedDate ?? d.CreatedDate,
UnitDescription = "" + d.Volume + " " + d.UnitOfMeasure.Description + " / " + d.WeightKg + "KG",
PickupDate = d.PickupDate,
DeliveryDate = d.DeliveryDate,
WarehouseDescription = d.Warehouse.Description,
IsCustomerPickup = d.IsCustomerPickup,
IsDangerousGoods = d.IsDangerousGoods,
IsDraggable = currentUser.UserLevel > 1,
LoadSort = d.LoadSort ?? 0,
WarehouseId = d.WarehouseId,
UnitOfMeasureId = d.UnitOfMeasureId,
Destination = d.Destination,
Notes = d.Notes,
Volume = d.Volume ?? 0,
WeightKg = d.WeightKg
}).ToList();
return(orders);
}
public ActionResult DeleteUser(VmUser user)
{
User usr = db.User.Find(user.userId);
if (usr == null)
{
return(HttpNotFound());
}
if (usr.ImageFile != null)
{
string imgPath = Path.Combine(Server.MapPath("~/Uploads/Partner/"), usr.Image);
System.IO.File.Delete(imgPath);
}
db.User.Remove(usr);
db.SaveChanges();
return(RedirectToAction("Login", "User"));
}
public IActionResult Edit(VmUser model)
{
if (ModelState.IsValid)
{
var obj = _userRepository.FindByID(model.Id);
obj.FirstName = model.FirstName;
obj.FirstName = model.FirstName;
obj.SecondName = model.SecondName;
obj.MiddleName = model.MiddleName;
obj.BirthDay = model.BirthDay;
obj.Sex = model.Sex;
obj.Snils = getSnils(model.Snils);
_userRepository.Update(obj);
return(RedirectToAction("Index"));
}
return(View(model));
}
public IActionResult Create(VmUser model)
{
if (ModelState.IsValid)
{
var consult = new User()
{
FirstName = model.FirstName,
SecondName = model.SecondName,
MiddleName = model.MiddleName,
BirthDay = model.BirthDay,
Sex = model.Sex,
Snils = getSnils(model.Snils)
};
_userRepository.Add(consult);
return(RedirectToAction("Index"));
}
return(View(model));
}
private async Task LoadSharedKeyAndQrCodeUriAsync(VmUser user)
{
// Load the authenticator key & QR code URI to display on the form
var unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
if (string.IsNullOrEmpty(unformattedKey))
{
await _userManager.ResetAuthenticatorKeyAsync(user);
unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
}
SharedKey = FormatKey(unformattedKey);
var email = await _userManager.GetEmailAsync(user);
AuthenticatorUri = GenerateQrCodeUri(email, unformattedKey);
}
public IActionResult PostInfo(string UserId = "")
{
ApplicationDbContext database = new ApplicationDbContext();
string currentUser = User.Identity.Name;
var qUser = database.Users.Where(c => (c.Id == UserId || c.UserName == currentUser) && c.EmailConfirmed == true).FirstOrDefault();
VmUser vm = new VmUser();
vm.Email = qUser.Email;
vm.UserId = qUser.Id;
vm.FirstName = qUser.FirstName;
vm.LastName = qUser.LastName;
vm.Address = qUser.Address == null ? null : qUser.Address;
vm.City = qUser.City == null ? null : qUser.City;
vm.Province = qUser.Province == null ? null : qUser.Province;
vm.PostalCode = qUser.PostalCode == null ? null : qUser.PostalCode;
return(View(vm ?? null));
}
public async Task <VmUser> ValidateUserLogin(VmUser userLogin)
{
VmUser vUser = null;
if (!string.IsNullOrEmpty(userLogin.UserEmail) && !string.IsNullOrEmpty(userLogin.UserEncyryptedKey))
{
var userDetails = await _dbContext.User.AsNoTracking().Where(x => x.user_email == userLogin.UserEmail).FirstOrDefaultAsync();
if (userDetails != null)
{
var masterKey = userDetails.user_email.Substring(2, 4);
var message = _encryption.DecryptText(userDetails.user_encryptedmessage, masterKey);
var newMessage = _encryption.EncryptText(userLogin.UserEncyryptedKey, message);
var result = _encryption.CompareStrings(userDetails.user_encryptedkey, newMessage, message);
if (result)
{
vUser = new VmUser(userDetails);
vUser.DecryptedUserEmail = vUser.UserEmail;
vUser.UserEmail = _encryption.EncryptText(vUser.DecryptedUserEmail, ATMConstants.emailEncKey);
return(vUser);
}
else
{
vUser = new VmUser();
vUser.Message = "Invalid email/password";
}
}
else
{
vUser = new VmUser();
vUser.Message = "User not found";
}
}
else
{
vUser = new VmUser();
vUser.Message = "Invalid email/password";
}
return(vUser);
}
public async Task LoginUser_success()
{
//arrange
VmUser user = new VmUser
{
UserName = "******",
UserContact = "123",
UserEmail = "test123",
UserEncryptionMessage = "test",
UserEncyryptedKey = "test"
};
_userService.Setup(x => x.ValidateUserLogin(It.IsAny <VmUser>())).Returns(Task.FromResult(user));
//act
var result = await controller.LoginUser(user) as ViewResult;
//assert
Assert.NotNull(result.Model);
}
public IActionResult RegisterUserPostInfo(VmUser u)
{
ApplicationDbContext database = new ApplicationDbContext();
string currentUser = User.Identity.Name;
var qUser = database.Users.Where(c => c.UserName == currentUser && c.EmailConfirmed == true && c.Id == u.UserId).FirstOrDefault();
if (qUser == null)
{
return(Redirect(nameof(AccountController.PostInfo)));
}
qUser.PostalCode = u.PostalCode;
qUser.City = u.City;
qUser.Province = u.Province;
qUser.Address = u.Address;
database.Update(qUser);
database.SaveChanges();
return(Redirect(nameof(AccountController.PostInfo)));
}
public async Task UpdateUserPasswordView_success()
{
//arrange
VmUser user = new VmUser
{
UserName = "******",
UserContact = "123",
UserEmail = "test123",
UserEncryptionMessage = "test",
UserEncyryptedKey = "test"
};
_userService.Setup(x => x.GetUserProfile(It.IsAny <string>())).Returns(Task.FromResult(user));
var userEmailEnc = EncryptedUserEmail();
//act
var result = await controller.UpdateUserPasswordView(userEmailEnc) as ViewResult;
//Assert
Assert.NotNull(result);
}
