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> 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)); }
/// <summary> /// Update an existing Account in the Common and Account partitions. /// Also update a user in the Account Partition. /// </summary> /// <param name="commonAccount"></param> /// <param name="createdById"></param> /// <returns></returns> public async Task <ServiceResponse <CommonAccount> > UpdateAccount(CommonAccount commonAccount, Guid createdById, int AccountNumber, List <AccountViolationType> AccViolationType) { var result = new ServiceResponse <CommonAccount>(); try { using (var scope = _commonCtx.Database.BeginTransaction()) { //update common account table var accountDetail = await _commonCtx.CommonAccounts.Include(m => m.Partition).Include(m => m.Settings).SingleOrDefaultAsync(a => a.Id == commonAccount.Id); var accountCtx = ContextsUtility.CreateAccountContext(Cryptography.Decrypt(accountDetail.Partition.ConnectionString)); accountDetail.UpdateUserId = createdById; accountDetail.UpdateUtc = DateTime.Now; accountDetail.Name = commonAccount.Name; accountDetail.OwnerUserId = commonAccount.OwnerUserId; accountDetail.StorageBucketName = commonAccount.StorageBucketName; accountDetail.CitationWorkflow = commonAccount.CitationWorkflow; accountDetail.Features = commonAccount.Features; _commonCtx.CommonAccounts.Update(accountDetail); await _commonCtx.SaveChangesAsync(); //update accounts table from selected partition var AccountsDetail = await accountCtx.Accounts.SingleOrDefaultAsync(a => a.Id == commonAccount.Id); AccountsDetail.Name = commonAccount.Name; AccountsDetail.UpdateUserId = createdById; AccountsDetail.UpdateUtc = DateTime.UtcNow; accountCtx.Accounts.Update(AccountsDetail); await accountCtx.SaveChangesAsync(); //update user accounts table if (commonAccount.OwnerUserId != null) { //Check to see if the owner exists in the User Account Table. var userAccount = await _commonCtx.UserAccounts.SingleOrDefaultAsync(a => a.AccountId == commonAccount.Id && a.UserId == commonAccount.OwnerUserId); if (userAccount == null) { CommonUserAccount NewuserAccount = new CommonUserAccount(); NewuserAccount.CreateUserId = createdById; NewuserAccount.AccountId = commonAccount.Id; NewuserAccount.UpdateUserId = createdById; NewuserAccount.UserId = commonAccount.OwnerUserId; NewuserAccount.Permissions = (AccountPermissions)Enum.GetValues(typeof(AccountPermissions)).Cast <int>().Sum(); _commonCtx.UserAccounts.Add(NewuserAccount); await _commonCtx.SaveChangesAsync(); var commonUser = await _commonCtx.Users.SingleAsync(m => m.Id == commonAccount.OwnerUserId); //Add any new users to acconts await SaveAccountUser(commonUser, createdById); } } //Remove the current violation types var AccountViolationType = await _commonCtx.CommonAccountViolationTypes.Where(av => av.AccountId == commonAccount.Id).ToListAsync(); _commonCtx.CommonAccountViolationTypes.RemoveRange(AccountViolationType); await _commonCtx.SaveChangesAsync(); //Add new violatoin types from the page foreach (var Types in AccViolationType) { if (Types.IsCheckedViolation == true) { CommonAccountViolationType AcntViolationType = new CommonAccountViolationType(); AcntViolationType.CreateUserId = createdById; AcntViolationType.AccountId = commonAccount.Id; AcntViolationType.UpdateUserId = createdById; AcntViolationType.ViolationTypeId = Types.TypeId; _commonCtx.CommonAccountViolationTypes.Add(AcntViolationType); await _commonCtx.SaveChangesAsync(); } } scope.Commit(); //Purge common accounts cache var cacheKey = WebCacheKey.CommonAccount(accountDetail.Number); await _cache.RemoveAsync(cacheKey); } } catch (Exception ex) { _logger.Error(ex, "Error updating an Account"); throw ex; } return(result); }
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)); } }
/// <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); }