public async Task <IActionResult> ForgetPassword(ForgetPassword model) { if (ModelState.IsValid) { CommonUser user = await _commonUserSvc.CheckUser(model.Email); if (user != null) { string token = Convert.ToBase64String(Guid.NewGuid().ToByteArray()); var callbackUrl = Url.Action("ResetPassword", "User", new { code = token }); using (var tx = CommonContext.Database.BeginTransaction()) { user.Token = token; user.TokenUtc = DateTime.UtcNow; CommonContext.Users.Update(user); await CommonContext.SaveChangesAsync(); tx.Commit(); } _logger.Error($"Sending Email email:{model.Email} callback:{callbackUrl}"); bool result = await _mailSvc.SendPasswordResetEmail(model.Email, callbackUrl); _logger.Error($"Email Sent:"); } ViewBag.SucessMessage = "Please check your email for a link to reset your password"; return(View()); } return(View(model)); }
public async Task <IActionResult> Create(PartitionViewModel model) { if (ModelState.IsValid) { var nameAlreadyExists = CommonContext.Partitions.Any(x => x.Name.ToLower() == model.Name.ToLower()); if (nameAlreadyExists) { // duplicate partition name ModelState.AddModelError(string.Empty, "Name already exsits."); return(View(model)); } var partition = new Partition(); partition.Name = model.Name; partition.ConnectionString = Cryptography.Encrypt(model.ConnectionString); partition.CreateUserId = User.GetLoggedInUserId().Value; partition.UpdateUserId = partition.CreateUserId = User.GetLoggedInUserId().Value; //put dude in the database using (var tx = CommonContext.Database.BeginTransaction()) { CommonContext.Partitions.Add(partition); await CommonContext.SaveChangesAsync(); tx.Commit(); } return(RedirectToAction("Index")); } return(View(model)); }
// To protect from overposting attacks, enable the specific properties you want to bind to, for // more details, see https://aka.ms/RazorPagesCRUD. public async Task <IActionResult> OnPostAsync() { if (!ModelState.IsValid) { return(Page()); } _context.Attach(Member).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!MemberExists(Member.member_no)) { return(NotFound()); } else { throw; } } return(RedirectToPage("./Index")); }
public async Task <IActionResult> Edit(CityModel model) { if (ModelState.IsValid) { var cityExists = await CommonContext.Cities.Where(x => x.Name.ToLower() == model.Name.ToLower() && x.Id != model.Id).AnyAsync(); if (cityExists) { ModelState.AddModelError(nameof(model.Name), "This name already exists."); return(View(model)); } var city = await CommonContext.Cities.SingleAsync(m => m.Id == model.Id); city.County = model.County; city.Latitude = model.Latitude; city.Longitude = model.Longitude; city.Name = model.Name; city.State = model.State; city.StateCode = model.StateCode; city.TimeZone = model.TimeZone; city.Type = model.Type; city.UpdateUserId = User.GetLoggedInUserId().Value; CommonContext.Cities.Update(city); await CommonContext.SaveChangesAsync(); return(RedirectToAction("Index")); } return(View(model)); }
public async Task <IActionResult> ResetPassword([FromBody] ResetPasswordModel model) { var response = new APIResponse <ResetPasswordModel>() { Success = true }; try { if (ModelState.IsValid) { CommonUser user = await _commonUserSvc.CheckUser(model.Email); if (user != null) { string token = Convert.ToBase64String(Guid.NewGuid().ToByteArray()); var callbackUrl = Url.Action("ResetPassword", "User", new { code = token }); using (var tx = CommonContext.Database.BeginTransaction()) { user.Token = token; user.TokenUtc = DateTime.UtcNow; CommonContext.Users.Update(user); await CommonContext.SaveChangesAsync(); tx.Commit(); } bool result = await _mailSvc.SendPasswordResetEmail(model.Email, callbackUrl); response.Message = "Please check your email for a link to reset your password"; } else { response.Message = "Please check your email for a link to reset your password"; } } else { response.Success = false; response.Errors.AddRange(ModelState.ToErrors()); } return(Ok(response)); } catch (Exception ex) { response.Success = false; response.Message = ex.Message; return(Ok(response)); } }
// To protect from overposting attacks, enable the specific properties you want to bind to, for // more details, see https://aka.ms/RazorPagesCRUD. public async Task <IActionResult> OnPostAsync() { if (!ModelState.IsValid) { return(Page()); } _context.member.Add(Member); await _context.SaveChangesAsync(); return(RedirectToPage("./Index")); }
/// <summary> /// create new violation type /// </summary> /// <param name="violationtype"></param> /// <param name="createdById"></param> /// <returns></returns> public async Task <ServiceResponse <CommonViolationType> > CreateViolationType(CommonViolationType violationtype, Guid createdById) { var result = new ServiceResponse <CommonViolationType>(); try { using (var scope = _commonCtx.Database.BeginTransaction()) { violationtype.CreateUserId = createdById; violationtype.UpdateUserId = createdById; _commonCtx.CommonViolationTypes.Add(violationtype); await _commonCtx.SaveChangesAsync(); //Adds this newly created violation to all the account ViolationTypes. await CreateAccountViolationType(violationtype); scope.Commit(); } } catch (Exception ex) { _logger.Error(ex, "Error creating new Violation Type"); throw ex; } return(result); }
public async Task <IActionResult> Edit(AccountUserViewModelEdit model) { if (ModelState.IsValid) { var existingUser = await CommonContext.UserAccounts.Include(x => x.User) .Where(m => m.UserId == model.UserId && m.AccountId == CommonAccount.Id).SingleOrDefaultAsync(); if (existingUser == null) { throw new Exception($"User cannot be found. UserId:{model.UserId}"); } if (User.GetLoggedInUserId().Value == model.UserId && !model.Permissions.HasFlag(AccountPermissions.AccountAdministrator)) { ModelState.AddModelError(string.Empty, "You cannot remove the Account Administrator permission"); model.FirstName = existingUser.User.FirstName; model.LastName = existingUser.User.LastName; model.Email = existingUser.User.Email; return(View(model)); } if (User.GetLoggedInUserId().Value == model.UserId && model.Disabled) { ModelState.AddModelError(string.Empty, "You cannot disable your own account"); model.FirstName = existingUser.User.FirstName; model.LastName = existingUser.User.LastName; model.Email = existingUser.User.Email; return(View(model)); } existingUser.Permissions = model.Permissions; existingUser.Disabled = model.Disabled; existingUser.UpdateUserId = LoggedInUser.Id; existingUser.UpdateUtc = DateTime.UtcNow; using (var tx = CommonContext.Database.BeginTransaction()) { CommonContext.UserAccounts.Update(existingUser); await CommonContext.SaveChangesAsync(); tx.Commit(); var cacheKey = WebCacheKey.CommonUserAccount(CommonAccount.Number, existingUser.UserId.Value); await _cache.RemoveAsync(cacheKey); } return(RedirectToAction("Users")); } return(View(model)); }
public async Task <IActionResult> Register([FromBody] UserRegisterModel model) { var response = new APIResponse <TokenResponseModel>(); if (ModelState.IsValid) { var userAlreadyExists = await CommonContext.Users.AnyAsync(q => q.Email.ToLower() == model.Email.ToLower()); if (userAlreadyExists) { // This isn't a security risk because we've verified the email address already response.Success = false; response.Errors.Add(new Error { Code = Common.Enums.ErrorCode.None, Message = "A user has already verified that email address." }); } else { var user = new CommonUser(); user.Email = model.Email; user.SetPassword(model.Password); user.Permission = IsAdmin(model.Email); //put dude in the database using (var tx = CommonContext.Database.BeginTransaction()) { CommonContext.Users.Add(user); await CommonContext.SaveChangesAsync(); tx.Commit(); } //Register user device var device = await RegisterUserDevice(model, user); //Return JWT Token return(Ok(await CreateEncodedJwtToken(user))); } } else { response.Success = false; response.Errors.AddRange(ModelState.ToErrors()); } return(Ok(response)); }
public async Task <IActionResult> OnPostAsync(long?id) { if (id == null) { return(NotFound()); } Member = await _context.member.FindAsync(id); if (Member != null) { _context.member.Remove(Member); await _context.SaveChangesAsync(); } return(RedirectToPage("./Index")); }
public async Task <IActionResult> Edit(EditUserViewModel model) { if (ModelState.IsValid) { var userAlreadyExists = await CommonContext.Users.AsNoTracking().AnyAsync(q => q.Email.ToLower() == model.Email.ToLower() && q.Id != model.Id); if (userAlreadyExists) { // This isn't a security risk because we've verified the email address already ModelState.AddModelError(string.Empty, "A user has already verified that email address."); PopulateDropDownEditUsers(model); return(View(model)); } var user = await CommonContext.Users.SingleAsync(m => m.Id == model.Id); user.Email = model.Email; user.FirstName = model.FirstName; user.LastName = model.LastName; user.Permission = model.Permission; if (model.Password != null) { user.SetPassword(model.Password); } CommonContext.Users.Update(user); await CommonContext.SaveChangesAsync(); //Update user information in all other accounts await _commonAccountSvc.SaveAccountUser(user, User.GetLoggedInUserId().Value); if (User.GetLoggedInUserId().Value == user.Id) { await PurgeLoggedInUser(); } return(RedirectToAction("Index")); } PopulateDropDownEditUsers(model); return(View(model)); }
public async Task <bool> RegisterUserDevice(UserDeviceModel model, CommonUser user) { var deviceAlreadyExists = await CommonContext.CommonUserDevices.SingleOrDefaultAsync(m => m.DeviceToken == model.DeviceToken && m.UserId == user.Id); if (deviceAlreadyExists != null) { deviceAlreadyExists.IsLogin = true; deviceAlreadyExists.UpdateUserId = user.Id; deviceAlreadyExists.DevicePublicKey = model.DevicePublicKey; using (var tx = CommonContext.Database.BeginTransaction()) { CommonContext.CommonUserDevices.Update(deviceAlreadyExists); await CommonContext.SaveChangesAsync(); tx.Commit(); } } else { CommonUserDevice userDevice = new CommonUserDevice() { DeviceName = model.DeviceName, DeviceToken = model.DeviceToken, DeviceType = model.DeviceType, DevicePublicKey = model.DevicePublicKey, UserId = user.Id, IsLogin = true, CreateUserId = user.Id }; using (var tx = CommonContext.Database.BeginTransaction()) { CommonContext.CommonUserDevices.Add(userDevice); await CommonContext.SaveChangesAsync(); tx.Commit(); } } return(true); }
public async Task <IActionResult> ChangePassword([FromBody] ChangePassword model, Guid Id) { var response = new APIResponse <ChangePassword>() { Success = true }; if (ModelState.IsValid) { var user = await CommonContext.Users.SingleOrDefaultAsync(m => m.Id == Id); if (user != null) { if (user.CheckPassword(model.OldPassword)) { user.SetPassword(model.NewPassword); CommonContext.Users.Update(user); await CommonContext.SaveChangesAsync(); response.Message = "Password Changed Successfully."; } else { response.Success = false; response.Errors.Add(new Error() { Code = 0, Message = "Incorrect Password." }); } } } else { response.Success = false; response.Errors.AddRange(ModelState.ToErrors()); } return(Ok(response)); }
public async Task <IActionResult> Create(UserViewModel model) { if (ModelState.IsValid) { var userAlreadyExists = await CommonContext.Users.AnyAsync(q => q.Email.ToLower() == model.Email.ToLower()); if (userAlreadyExists) { // This isn't a security risk because we've verified the email address already ModelState.AddModelError(string.Empty, "This email address already exists."); PopulateDropDownUsers(model); return(View(model)); } var user = new CommonUser(); user.Email = model.Email; user.FirstName = model.FirstName; user.LastName = model.LastName; user.SetPassword(model.Password); user.Permission = model.Permission; user.CreateUserId = User.GetLoggedInUserId().Value; user.UpdateUserId = user.CreateUserId = User.GetLoggedInUserId().Value; //put dude in the database using (var tx = CommonContext.Database.BeginTransaction()) { CommonContext.Users.Add(user); await CommonContext.SaveChangesAsync(); tx.Commit(); } return(RedirectToAction("Index")); } //, "users", new { Area = Area.Admin }); PopulateDropDownUsers(model); return(View(model)); }
public async Task <IActionResult> Create(CityModel model) { if (ModelState.IsValid) { var cityExists = await CommonContext.Cities.Where(x => x.Name.ToLower() == model.Name.ToLower()).AnyAsync(); if (cityExists) { ModelState.AddModelError(nameof(model.Name), "This name already exists."); return(View(model)); } var city = new City() { County = model.County, Latitude = model.Latitude, Longitude = model.Longitude, Name = model.Name, State = model.State, StateCode = model.StateCode, TimeZone = model.TimeZone, Type = model.Type, CreateUserId = User.GetLoggedInUserId().Value, UpdateUserId = User.GetLoggedInUserId().Value, }; using (var tx = CommonContext.Database.BeginTransaction()) { CommonContext.Cities.Add(city); await CommonContext.SaveChangesAsync(); tx.Commit(); } return(RedirectToAction("Index")); } return(View(model)); }
public async Task <IActionResult> AssociateUser([FromBody] AccountUserAssociationModel model) { var response = new APIResponse <CommonUserAccountModel>() { Success = true }; var commonUser = await CommonContext.Users.SingleOrDefaultAsync(m => m.Id == model.UserId); if (commonUser == null) { response.Success = false; response.Message = "User could not be found"; } else { var commonUserAccount = await CommonContext.UserAccounts.Where(m => m.UserId == model.UserId && m.AccountId == model.AccountId).SingleOrDefaultAsync(); //If these is no association, create it. if (commonUserAccount == null) { commonUserAccount = new CommonUserAccount { AccountId = model.AccountId, UserId = model.UserId, CreateUserId = model.UserId, UpdateUserId = model.UserId }; CommonContext.UserAccounts.Add(commonUserAccount); await CommonContext.SaveChangesAsync(); } await _commonAccountSvc.SaveAccountUser(commonUser, commonUser.CreateUserId); response.Data = Mapper.Map <CommonUserAccountModel>(commonUserAccount); } return(Ok(response)); }
public async Task <ActionResult> Register(UserRegisterModel model) { if (ModelState.IsValid) { var userAlreadyExists = await CommonContext.Users.AnyAsync(q => q.Email.ToLower() == model.Email.ToLower()); if (userAlreadyExists) { // This isn't a security risk because we've verified the email address already ModelState.AddModelError(string.Empty, "A user has already verified that email address."); } else { var user = new CommonUser(); user.Email = model.Email; user.SetPassword(model.Password); user.Permission = IsAdmin(model.Email); //put dude in the database using (var tx = CommonContext.Database.BeginTransaction()) { CommonContext.Users.Add(user); await CommonContext.SaveChangesAsync(); tx.Commit(); await SignInUser(user, false); return(RedirectToAction("Index", "Accounts", new { Area = Area.Admin })); } } } return(View(model)); }
public async Task <IActionResult> ResetPassword(ResetPassword model) { if (ModelState.IsValid) { Guid userid = new Guid(model.Id); var userDetail = (from a in CommonContext.Users where a.Id == userid select new { a }).SingleOrDefault(); if (userDetail != null) { userDetail.a.SetPassword(model.Password); using (var tx = CommonContext.Database.BeginTransaction()) { userDetail.a.Token = null; CommonContext.Users.Update(userDetail.a); await CommonContext.SaveChangesAsync(); tx.Commit(); } await SignInUser(userDetail.a, false); return(RedirectToAction("Index", "Home")); } } return(View(model)); }
public async Task <int> Create_banan(banan ba) { _context.banans.Add(ba); return(await _context.SaveChangesAsync()); }
/// <summary> /// Creates a new Account in the Common and Account partitions. /// Also creates a user in the Account Partition if one doesn't exist. /// </summary> /// <param name="commonAccount"></param> /// <param name="user"></param> /// <param name="createdById"></param> /// <returns></returns> public async Task <ServiceResponse <CommonAccount> > CreateAccount(CommonAccount commonAccount, Guid createdById, List <AccountViolationType> AccViolationType, long CitationCounter) { var result = new ServiceResponse <CommonAccount>(); try { using (var scope = _commonCtx.Database.BeginTransaction()) { //Get the correct account database based on the partition that was chosen for the account. var accountCtx = ContextsUtility.CreateAccountContext(Cryptography.Decrypt(commonAccount.Partition.ConnectionString)); if (accountCtx == null) { _logger.Error($"Account context does not exists for partition: {Cryptography.Decrypt(commonAccount.Partition.ConnectionString)}"); throw new Exception("Account context does not exists"); } //Generate a random account number commonAccount.Number = await GetNextAccountNumberAsync(); commonAccount.CreateUserId = createdById; commonAccount.UpdateUserId = createdById; //Create empty account settings commonAccount.Settings = new CommonAccountSettings { }; commonAccount.Settings.CreateUserId = createdById; commonAccount.Settings.UpdateUserId = createdById; _commonCtx.CommonAccounts.Add(commonAccount); await _commonCtx.SaveChangesAsync(); //Update the count on the partition to let us know how many account reside on one database. commonAccount.Partition.Occupancy = commonAccount.Partition.Occupancy + 1; _commonCtx.Partitions.Update(commonAccount.Partition); //If a Owner is selected, create a user account assosication. if (commonAccount.OwnerUserId != null) { CommonUserAccount userAccount = new CommonUserAccount(); userAccount.CreateUserId = createdById; userAccount.AccountId = commonAccount.Id; userAccount.UpdateUserId = createdById; userAccount.UserId = commonAccount.OwnerUserId; userAccount.Permissions = (AccountPermissions)Enum.GetValues(typeof(AccountPermissions)).Cast <int>().Sum(); _commonCtx.UserAccounts.Add(userAccount); await _commonCtx.SaveChangesAsync(); var commonUser = await _commonCtx.Users.SingleAsync(m => m.Id == commonAccount.OwnerUserId); //Add any new users to acconts await SaveAccountUser(commonUser, createdById); } //Add Account in account context //The Ids for the Account in AccountContext and CommonAccount in CommonContext are going to be exactly the same. accountCtx.Accounts.Add(new Account { Id = commonAccount.Id, Name = commonAccount.Name, CreateUserId = createdById, UpdateUserId = createdById }); await accountCtx.SaveChangesAsync(); foreach (var Type in AccViolationType) { if (Type.IsCheckedViolation == true) { CommonAccountViolationType AccountViolationType = new CommonAccountViolationType(); AccountViolationType.CreateUserId = createdById; AccountViolationType.AccountId = commonAccount.Id; AccountViolationType.UpdateUserId = createdById; AccountViolationType.ViolationTypeId = Type.TypeId; _commonCtx.CommonAccountViolationTypes.Add(AccountViolationType); } } await _commonCtx.SaveChangesAsync(); await _violationSvc.PopulateViolationsForAccount(commonAccount, createdById); Counter count = new Counter() { AccountId = commonAccount.Id, Name = "Citations", NextValue = CitationCounter, CreateUserId = commonAccount.OwnerUserId.Value, UpdateUserId = commonAccount.OwnerUserId.Value }; accountCtx.Counters.Add(count); await accountCtx.SaveChangesAsync(); scope.Commit(); } } catch (Exception ex) { _logger.Error(ex, "Error creating new Account"); throw ex; } return(result); }
public async Task <ActionResult> CreatePassword(CreatePassword model) { if (ModelState.IsValid) { //Create new User and Account var user = new CommonUser(); user.Email = model.InvitedEmail; user.FirstName = model.FirstName; user.LastName = model.LastName; user.Permission = model.SystemPermission; user.SetPassword(model.Password); //Check Account var commonAccount = await CommonContext.CommonAccounts.Where(m => m.Id == model.AccountId).SingleOrDefaultAsync(); var vendorDetail = await _accountCtx.Vendors.Where(x => x.Id == model.VendorId).SingleOrDefaultAsync(); if (commonAccount == null) { ViewBag.SucessMessage = "Account not found"; return(View(model)); } CommonUserAccount userAccount = new CommonUserAccount(); userAccount.CreateUserId = commonAccount.OwnerUserId.Value; userAccount.AccountId = commonAccount.Id; userAccount.UpdateUserId = commonAccount.OwnerUserId.Value; userAccount.UserId = user.Id; userAccount.Permissions = (AccountPermissions)model.Permission; if (vendorDetail != null) { user.Permission = SystemPermissions.Vendor; } using (var tx = CommonContext.Database.BeginTransaction()) { CommonContext.Users.Add(user); await CommonContext.SaveChangesAsync(); CommonContext.UserAccounts.Add(userAccount); await CommonContext.SaveChangesAsync(); tx.Commit(); } //Create AccountUser var accountUser = new AccountUser { Id = userAccount.UserId.Value, FirstName = user.FirstName, LastName = user.LastName, Email = user.Email }; _accountCtx.AccountUsers.Add(accountUser); if (vendorDetail != null) { AccountUserVendor accountUserVendor = new AccountUserVendor(); accountUserVendor.VendorId = vendorDetail.Id; accountUserVendor.AccountUserId = accountUser.Id; _accountCtx.AccountUserVendors.Add(accountUserVendor); } await _accountCtx.SaveChangesAsync(); await SignInUser(user, false); return(RedirectToAction("Index", "Accounts")); } return(View(model)); }
public async Task <ActionResult> AcceptInvite(AcceptInvite model) { //Check to see if this user exists in Users var existingUser = await CommonContext.Users.Where(m => m.Email == model.InvitedEmail).AnyAsync(); if (existingUser) { //Check to see if this user already belongs to the account //Users can belong to multiple accounts, we need to filter by accountID and InvitedEmail var existingAccountUser = await CommonContext.UserAccounts.Include(x => x.User).Where(m => m.User.Email == model.InvitedEmail && m.AccountId == model.AccountId).AnyAsync(); if (!existingAccountUser) { //Get exists User Detail var user = CommonContext.Users.Where(m => m.Email == model.InvitedEmail).SingleOrDefault(); //Get Account detail using accountId var commonAccount = await CommonContext.CommonAccounts.Where(m => m.Id == model.AccountId).SingleOrDefaultAsync(); var vendorDetail = await _accountCtx.Vendors.Where(x => x.Id == model.VendorId).SingleOrDefaultAsync(); if (commonAccount == null) { ViewBag.SucessMessage = "Account not found"; return(View(model)); } CommonUserAccount userAccount = new CommonUserAccount(); userAccount.CreateUserId = commonAccount.OwnerUserId.Value; userAccount.AccountId = commonAccount.Id; userAccount.UpdateUserId = commonAccount.OwnerUserId.Value; userAccount.UserId = user.Id; userAccount.Permissions = (AccountPermissions)model.Permission; using (var tx = CommonContext.Database.BeginTransaction()) { CommonContext.UserAccounts.Add(userAccount); await CommonContext.SaveChangesAsync(); tx.Commit(); } var accountUser = await _accountCtx.AccountUsers.Where(m => m.Id == user.Id).SingleOrDefaultAsync(); if (accountUser == null) { //Create AccountUser accountUser = new AccountUser() { Id = user.Id, FirstName = user.FirstName, LastName = user.LastName, Email = user.Email, }; _accountCtx.AccountUsers.Add(accountUser); await _accountCtx.SaveChangesAsync(); } if (vendorDetail != null) { AccountUserVendor accountUserVendor = new AccountUserVendor(); accountUserVendor.VendorId = vendorDetail.Id; accountUserVendor.AccountUserId = accountUser.Id; user.Permission = SystemPermissions.Vendor; CommonContext.SaveChanges(); using (var tx = _accountCtx.Database.BeginTransaction()) { _accountCtx.AccountUserVendors.Add(accountUserVendor); await _accountCtx.SaveChangesAsync(); tx.Commit(); } } return(RedirectToAction("Index", "Accounts")); } else { ViewBag.SucessMessage = " Already Account user."; return(View(model)); } } else { CreatePassword pwdmodel = new Models.User.CreatePassword(); pwdmodel.AccountId = model.AccountId; pwdmodel.AccountName = model.AccountName; pwdmodel.InvitedEmail = model.InvitedEmail; string[] name = model.Name.Split(' '); pwdmodel.FirstName = name[0]; pwdmodel.LastName = name[1]; pwdmodel.Permission = model.Permission; pwdmodel.VendorId = model.VendorId; pwdmodel.SystemPermission = model.SystemPermission; return(View("CreatePassword", pwdmodel)); } }
public async Task <IActionResult> Edit(UserModel model) { ModelState.Remove("ProfileImageKey"); if (ModelState.IsValid) { var userAlreadyExists = await CommonContext.Users.AsNoTracking().AnyAsync(q => q.Email.ToLower() == model.Email.ToLower() && q.Id != model.Id); if (userAlreadyExists) { // This isn't a security risk because we've verified the email address already ModelState.AddModelError(string.Empty, "A user has already verified that email address."); return(View(model)); } //Get current file extension if (model.files != null) { List <string> Types = _appSettings.ImageTypes.Split(',').ToList(); string ext = System.IO.Path.GetExtension(model.files.FileName).ToLower(); if (Types.Contains(ext)) { if (model.files.Length > _appSettings.ImageSize) { //Convert bytes into MB var size = (_appSettings.ImageSize / 1024f) / 1024f; ModelState.AddModelError(string.Empty, $"File size not be greater than {size} MB."); return(View(model)); } if (model.ProfileImageKey != null) { //Delete the file from AWS Bucket and Database var cityAppFile = await _fileService.DeleteFile(model.ProfileImageKey, _appSettings.AWSAccessKeyID, _appSettings.AWSSecretKey, _appSettings.AmazonS3Bucket); } Guid fileGuid = Guid.NewGuid(); using (var fileStream = model.files.OpenReadStream()) using (var ms = new MemoryStream()) { fileStream.CopyTo(ms); //convert image into Bytes var fileByte1s = ms.ToArray(); //Common/User/(UserId)/Profile/(new Guid()).(ext) var fileNameInFolder = $"common/User/{User.GetLoggedInUserId().Value}/profile/{fileGuid + ext}"; //Upload the file on Amazon S3 Bucket var result = await _fileService.UploadFile(fileByte1s, fileNameInFolder, _appSettings.AWSAccessKeyID, _appSettings.AWSSecretKey, true); model.ProfileImageKey = fileNameInFolder; } } else { ModelState.AddModelError(string.Empty, $"Invalid File Formate {model.files.FileName}."); return(View(model)); } } var user = await CommonContext.Users.SingleAsync(m => m.Id == model.Id); user.Email = model.Email; user.FirstName = model.FirstName; user.LastName = model.LastName; user.ProfileImageKey = model.ProfileImageKey; if (!string.IsNullOrWhiteSpace(model.Password)) { if (!string.IsNullOrWhiteSpace(model.OldPassword)) { if (user.CheckPassword(model.OldPassword)) { user.SetPassword(model.Password); } else { ModelState.AddModelError(string.Empty, "Invalid old password."); return(View(model)); } } else { ModelState.AddModelError(string.Empty, "Invalid old password."); return(View(model)); } } CommonContext.Users.Update(user); await CommonContext.SaveChangesAsync(); //Update user information in all other accounts await _commonAccountSvc.SaveAccountUser(user, User.GetLoggedInUserId().Value); //Update user information in cache await PurgeLoggedInUser(); } if (!string.IsNullOrWhiteSpace(model.ProfileImageKey)) { //Read the file from AWS Bucket var cityAppFile = await _fileService.ReadFile(model.ProfileImageKey, _appSettings.AWSAccessKeyID, _appSettings.AWSSecretKey, _appSettings.AmazonS3Bucket); if (cityAppFile.FileBytes != null) { cityAppFile.FileStream.Position = 0; // Convert byte[] to Base64 String model.ImageName = Convert.ToBase64String(cityAppFile.FileBytes); } } ViewBag.SucessMessage = "Your profile has been updated"; return(View(model)); }
public async Task <IActionResult> UpdateProfile([FromBody] UserModel model) { var response = new APIResponse <UserModel>(); if (ModelState.IsValid) { // if user is trying to update someone else profile. if (User.GetJWTLoggedInUserId() != model.Id) { response.Success = false; response.Errors.Add(new Error { Code = 0, Message = "Invalid ID" }); return(Ok(response)); } var userAlreadyExists = await CommonContext.Users.AsNoTracking().AnyAsync(q => q.Email.ToLower() == model.Email.ToLower() && q.Id != model.Id); if (userAlreadyExists) { // This isn't a security risk because we've verified the email address already response.Success = false; response.Errors.Add(new Error { Code = 0, Message = "A user has already verified that email address." }); return(Ok(response)); } var user = await CommonContext.Users.SingleAsync(m => m.Id == model.Id); user.Email = model.Email; user.FirstName = model.FirstName; user.LastName = model.LastName; user.PhoneNumber = model.PhoneNumber; user.ProfileImageKey = model.profileImageKey; if (!string.IsNullOrWhiteSpace(model.Password)) { user.SetPassword(model.Password); } CommonContext.Users.Update(user); await CommonContext.SaveChangesAsync(); //Update user information in all other accounts await _commonAccountSvc.SaveAccountUser(user, model.Id); //purge the user cache var cacheKey = WebCacheKey.LoggedInUser(model.Id); await _cache.RemoveAsync(cacheKey); response.Message = "Your profile has been updated"; } else { response.Success = false; response.Errors.AddRange(ModelState.ToErrors()); } return(Ok(response)); }