public async Task <IActionResult> SaveQuestionOrder(List <OrderList> Orderlist) { var result = new ServiceResponse <ViolationQuestion>() { Success = true }; try { if (Orderlist.Count > 0) { foreach (var question in Orderlist) { var QuestionDetails = await _accountCtx.ViolationQuestions.SingleOrDefaultAsync(a => a.Id == question.questionID); if (QuestionDetails != null) { // CitationDetails.UpdateUserId = createdById; QuestionDetails.UpdateUtc = DateTime.Now; QuestionDetails.Order = question.order; _accountCtx.ViolationQuestions.Update(QuestionDetails); } } await _accountCtx.SaveChangesAsync(); } } catch (Exception ex) { result.Success = false; result.Message = ex.Message; } return(Json(result)); }
public async Task <IActionResult> Register(RegistrationModel model) { if (ModelState.IsValid) { var user = new IdentityUser { UserName = model.UserLogin, Email = model.UserLogin }; var result = await _userManager.CreateAsync(user, model.UserPassword); var userModel = new UsersModel { UserId = user.Id, UserLogin = model.UserLogin, FirstName = model.FirstName, LastName = model.LastName, DateOfBirth = model.DateOfBirth, Gender = model.Gender.ToString(), DateOfCreation = DateTime.UtcNow }; await _context.UsersModel.AddAsync(userModel); if (result.Succeeded) { await _signInManager.SignInAsync(user, isPersistent : false); await _context.SaveChangesAsync(); return(RedirectToAction("index", "home")); } foreach (var error in result.Errors) { ModelState.AddModelError("", error.Description); } } return(View(model)); }
public async Task <IActionResult> PutAccount(int id, Account account) { if (id != account.AccountNumber) { return(BadRequest()); } _context.Entry(account).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!AccountExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutAccount([FromRoute] string id, [FromBody] Account account) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (id != account.Id) { return(BadRequest()); } _context.Entry(account).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!AccountExists(id)) { return(NotFound(0)); } else { throw; } } return(NoContent()); }
public async Task <IActionResult> PutTransaction(string id, Transaction transaction) { if (id != transaction.Id) { return(BadRequest()); } _context.Entry(transaction).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!TransactionExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <int> AddAsync(ProductClass productClass) { _context.ProductClass.Add(productClass); int result = await _context.SaveChangesAsync(); return(result); }
public async Task <IActionResult> UserChat(string UserLogin) { var userValues = await _context.MessageModel.FirstOrDefaultAsync(user => user.UserFrom == User.Identity.Name && user.UserTo == UserLogin || (user.UserTo == User.Identity.Name && user.UserFrom == UserLogin)); if (userValues == null) { _messageModel.UserTo = UserLogin; _messageModel.UserFrom = User.Identity.Name; _messageModel.MessageStore = string.Empty; _messageModel.MessageSend = string.Empty; } else { if (userValues.UserFrom == User.Identity.Name) { _messageModel.UserFrom = User.Identity.Name; _messageModel.UserTo = UserLogin; _messageModel.UserFromRead = true; userValues.UserFromRead = true; await _context.SaveChangesAsync(); } else { _messageModel.UserFrom = UserLogin; _messageModel.UserTo = User.Identity.Name; _messageModel.UserToRead = true; userValues.UserToRead = true; await _context.SaveChangesAsync(); } _messageModel.MessageStore = userValues.MessageStore; _messageModel.MessageSend = string.Empty; } return(View(_messageModel)); }
public async Task <int> AddAsync(NewsType newsType) { _context.NewsType.Add(newsType); int result = await _context.SaveChangesAsync(); return(result); }
public async Task <IActionResult> PutUser(int id, User user) { if (id != user.Userid) { return(BadRequest()); } _context.Entry(user).State = EntityState.Modified; try { await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!UserExists(id)) { return(NotFound()); } else { throw; } } return(NoContent()); }
public async Task <ActionResult <IEnumerable <Account> > > GetAccounts() { if (_context.Accounts.Count <Account>() < 1) { _context.Accounts.Add(new Account() { FirstName = "Roy", LastName = "Williams", DateOfBirth = "12/01/1992", Address = "1234 Maple Ln", City = "Richmond", State = "VA", ZipCode = 23220, Phone = "555-555-5555", Email = "*****@*****.**", Password = "******", CardName = "Roy Williams", CardNumber = 1234567891011121, ExpirationDate = "12/24", CVV = 345, CardAddress = "1234 Maple Ln", CardCity = "Richmond", CardState = "VA", CardZipCode = 23220, CardPhone = "555-555-5555" }); await _context.SaveChangesAsync(); } return(await _context.Accounts.ToListAsync()); }
public async Task <IActionResult> Create([Bind("AccountNumber,CustomerName,Branch,JoiningDate")] Account account) { if (ModelState.IsValid) { _context.Add(account); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(account)); }
public async Task <IActionResult> Create([Bind("UserId,Password,NicName,UserGroup,InActivity")] UserIdentity userIdentity) { if (ModelState.IsValid) { _context.Add(userIdentity); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(userIdentity)); }
public async Task ClearNotification(string userFrom, string userTo) { var messageModel = await _context.MessageModel.FirstOrDefaultAsync(user => user.UserFrom == userFrom && user.UserTo == userTo || (user.UserTo == userFrom && user.UserFrom == userTo)); if (messageModel != null) { messageModel.UserToRead = true; messageModel.UserFromRead = true; await _context.SaveChangesAsync(); } }
public async Task <IActionResult> Create([Bind("AccountId,AccountType,FirstName,LastName")] Account account) { if (ModelState.IsValid) { _context.Add(account); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(account)); }
public async Task <IActionResult> Create([Bind("AccountNumber,AccountType,CustomerID,ModifyDate")] Account account) { if (ModelState.IsValid) { _context.Add(account); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } ViewData["CustomerID"] = new SelectList(_context.Set <Customer>(), "CustomerID", "CustomerName", account.CustomerID); return(View(account)); }
public async void Test_GenericRepository_Update() { var options = new DbContextOptionsBuilder <AccountContext>() .UseInMemoryDatabase(databaseName: "Test2G") .Options; using (var ctx = new AccountContext(options)) { var profiles = new ProfileRepository(ctx); var payment = new PaymentRepository(ctx); var newProfile = new ProfileModel() { Id = 0, Email = "*****@*****.**", Name = null, Phone = "1234567897", Age = "Adult", AccountId = 1, Account = null }; var updateProfile = new ProfileModel() { Id = 1, Email = "*****@*****.**", Name = null, Phone = "2222222222", Age = "Child", AccountId = 1, Account = null }; await profiles.Add(newProfile); await ctx.SaveChangesAsync(); ctx.Entry <ProfileModel>(newProfile).State = EntityState.Detached; await profiles.Update(updateProfile); await ctx.SaveChangesAsync(); var actual = await profiles.GetAll(); var payments = await payment.GetAll(); var payments2 = await payment.Find(payment => payment.AccountId == 1); var phone = actual.First().Phone; Assert.Equal("2222222222", phone); Assert.Empty(payments); Assert.Empty(payments2); } }
public async Task <IActionResult> Create([Bind("FirstName,LastName,Email,Password,ConfirmPassword")] Account account) { if (ModelState.IsValid) { account.TimeStamp = DateTime.Now; _context.Add(account); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(account)); }
public async Task <bool> insertLoginInfo(LoginInfo loginInfo) { try { await _context.AddAsync(loginInfo); await _context.SaveChangesAsync(); } catch (Exception e) { return(false); } return(true); }
public async Task <IActionResult> Create([Bind("Guid,UserName,Password,Role,Email,CreateTime,UpdateTime")] Account account) { if (ModelState.IsValid) { account.Guid = Guid.NewGuid(); account.CreateTime = DateTime.Now; account.UpdateTime = DateTime.Now; account.Role = UserRole.Ordinary; context.Add(account); await context.SaveChangesAsync(); var partyMember = new PartyMember(new SeriaNumber().Seria(pMContext.PartyMembers.Count() + 1, Key.PMPre)) { Guid = Guid.NewGuid(), CreateTime = DateTime.Now, UpdateTime = DateTime.Now }; pMContext.Add(partyMember); await pMContext.SaveChangesAsync(); var accountPartyMember = new AccountPartyMember(account.UserName, partyMember.PartyMemberID) { Guid = Guid.NewGuid(), CreateTime = DateTime.Now, UpdateTime = DateTime.Now }; aPMContext.Add(accountPartyMember); await aPMContext.SaveChangesAsync(); var partyCost = new PartyCost(new SeriaNumber().Seria(pCContext.PartyCosts.Count() + 1, Key.PCPre), partyMember.PartyMemberID) { Guid = Guid.NewGuid(), CreateTime = DateTime.Now, UpdateTime = DateTime.Now, State = Verify.Unaudited }; pCContext.Add(partyCost); await pCContext.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(account)); }
public async void Test_GenericRepository_Find() { var options = new DbContextOptionsBuilder <AccountContext>() .UseInMemoryDatabase(databaseName: "Test1G") .Options; using (var ctx = new AccountContext(options)) { var profiles = new ProfileRepository(ctx); var newProfile = new ProfileModel() { Id = 10, Email = "*****@*****.**", Name = null, Phone = "1234567897", Age = "Adult", AccountId = 1, Account = null }; await profiles.Add(newProfile); await ctx.SaveChangesAsync(); var actual = await profiles.Find(profile => profile.AccountId == 1); var phone = actual.First().Phone; Assert.Equal("1234567897", phone); } }
public async Task <bool> AddOperationsHistory(AddTransaction message) { OperationHistoryEntity operationHistory1 = new OperationHistoryEntity(); OperationHistoryEntity operationHistory2 = new OperationHistoryEntity(); operationHistory1.AccountId = message.FromAccount; var b = await _context.Accounts.FirstOrDefaultAsync(b => b.AccountId == message.FromAccount).ConfigureAwait(false); operationHistory1.Balance = b.Balance; operationHistory1.CreditOrDebit = false; operationHistory1.Date = DateTime.Now; operationHistory1.Id = Guid.NewGuid(); operationHistory1.TransactionAmount = message.Amount; operationHistory1.TransactionId = message.TransactionId; operationHistory2.AccountId = message.ToAccount; var b2 = await _context.Accounts.FirstOrDefaultAsync(b => b.AccountId == message.ToAccount).ConfigureAwait(false); operationHistory2.Balance = b2.Balance; operationHistory2.CreditOrDebit = true; operationHistory2.Date = DateTime.Now; operationHistory2.Id = Guid.NewGuid(); operationHistory2.TransactionAmount = message.Amount; operationHistory2.TransactionId = message.TransactionId; await _context.OperationHistoryEntity.AddAsync(operationHistory1); await _context.OperationHistoryEntity.AddAsync(operationHistory2); await _context.SaveChangesAsync(); return(true); }
public async Task <User> ResetPassword(int id, string newPassword) { using (var db = new AccountContext()) { if (!UserExists(id)) { return(null); } var user = await db.Users.FindAsync(id); user.Password = getHashedPassword(newPassword); db.Entry(user).State = EntityState.Modified; try { await db.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!UserExists(user.UserId)) { return(null); } else { throw; } } return(user); } }
public async Task <ResponseModel> Add(Banner banner) { _context.Banner.Add(banner); int i = await _context.SaveChangesAsync(); if (i > 0) { return new ResponseModel { code = 200, result = "广告图添加成功" } } ; return(new ResponseModel { code = 0, result = "广告图添加失败" }); }
public async Task <ClientDTO> CreateClientAsync(CreateClientCommand command, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); var client = new Client { Name = command.Name, Age = command.Age, Gender = command.Gender }; _context.Clients.Add(client); await _context.SaveChangesAsync(cancellationToken); return(client.ToDTO()); }
public async Task <IActionResult> EditPayment(PaymentViewModel model) { if (ModelState.IsValid) { var accountDetail = await CommonContext.CommonAccounts.Include(m => m.Partition).SingleOrDefaultAsync(account => account.Id == model.AccountId); _accountCtx = ContextsUtility.CreateAccountContext(Cryptography.Decrypt(accountDetail.Partition.ConnectionString)); var payment = await _accountCtx.CitationPayments.Include(m => m.Citation).ThenInclude(m => m.Payments).Where(m => m.Id == model.Id).SingleAsync(); payment.ChargeAmount = model.ChargeAmount; payment.CitationFineAmount = model.CitationFineAmount; payment.ProcessingFee = model.ProcessingFee; payment.Status = model.Status; payment.ChargeId = model.ChargeId; payment.Citation.Balance = payment.Citation.Payments.Select(m => m.ChargeAmount).Sum(); await _accountCtx.SaveChangesAsync(); return(RedirectToAction("Citation", new { id = model.CitationId, accountId = model.AccountId })); } return(View(model)); }
public async Task <int> AddNewAccountsAsync(IEnumerable <Account> accounts) { var existingAccounts = GetAllDbAccounts(); var newAccounts = accounts .Where(a => !existingAccounts.Any(ea => ea.Id == a.Id)) .ToList(); await _accountContext.AddRangeAsync(newAccounts.Select(na => na.ToDataModel())); _logger.LogDebug($"Added {newAccounts.Count} new accounts"); await _accountContext.SaveChangesAsync(); return(newAccounts.Count); }
public async Task ExecuteAsync(CreateAccount cmd) { var validator = new CreateAccountValidator(_context); var validationResult = validator.Validate(cmd); CommandHandlerException.ThrowIsNotValid("Ошибочные значения параметров", validationResult); var existsAccount = await _context.Accounts.Where(a => a.IP == cmd.IP) .OrderByDescending(a => a.CreatedAt) .FirstOrDefaultAsync(); var currentDateTime = DateTime.Now; var allowedInterval = _config.Value.AllowedIntervalInSeconds; if (existsAccount != null && currentDateTime.Subtract(existsAccount.CreatedAt).Seconds < allowedInterval) { var ex = new CommandHandlerException(403, $"С одного IP разрешено регистрироваться не более одного раза в {allowedInterval} сек."); _loggerService.LogError(ex, ex.Message); throw ex; } var account = new Account(currentDateTime, cmd.IP, cmd.Email.ToLower(), _passwordService.GetSha256Hash(cmd.Password), cmd.Country, cmd.Province); _context.Accounts.Add(account); await _context.SaveChangesAsync(); _domainEventDispatcher.Raise(new CreatedAccountEvent(account)); }
public async Task <IActionResult> CreatePayment(PaymentViewModel model) { ValidateCreatePayment(model); if (ModelState.IsValid) { var accountDetail = await CommonContext.CommonAccounts.Include(m => m.Partition).SingleOrDefaultAsync(account => account.Id == model.AccountId); _accountCtx = ContextsUtility.CreateAccountContext(Cryptography.Decrypt(accountDetail.Partition.ConnectionString)); var citation = await GetCitation(model.AccountId, model.CitationId); var citationPayment = Mapper.Map <CitationPayment>(model); citationPayment.AccountId = accountDetail.Id; citationPayment.CreateUtc = DateTime.UtcNow; citationPayment.UpdateUtc = DateTime.UtcNow; citationPayment.CreateUserId = citation.CreateUserId; citationPayment.UpdateUserId = citation.CreateUserId; citation.Payments.Add(citationPayment); //Calcualte the new balance. citation.Balance = citation.Payments.Select(m => m.ChargeAmount).Sum(); await _accountCtx.SaveChangesAsync(); return(RedirectToAction("Citation", new { id = model.CitationId, accountId = model.AccountId })); } return(View(model)); }
public async Task HandleAsync(AddTransaction command) { var account = await _context.Accounts.SingleOrDefaultAsync(x => x.Id == command.AccountId); account.AddTransaction(command); await _context.SaveChangesAsync(); }
public async Task HandleAsync(DeleteAccount command) { var account = await _context.Accounts.SingleOrDefaultAsync(x => x.Id == command.Id); _context.Accounts.Remove(account); await _context.SaveChangesAsync(); }