public async Task DeleteFromWatchlist(int idwatchlist) { UserWatchlist wl = new UserWatchlist { Id = idwatchlist }; _dbContext.UserWatchlist.Attach(wl); _dbContext.UserWatchlist.Remove(wl); await _dbContext.SaveChangesAsync(); }
public async Task <CategoryModel> SaveCategory(CategoryDto category) { var categoryModel = new CategoryModel { name = category.name, color = category.color }; context.Add(categoryModel); await context.SaveChangesAsync(); return(categoryModel); }
public async Task <IActionResult> UpdateSmartContract([FromBody] ERC20Token model) { try { _dbContext.Erc20Tokens.Update(model); await _dbContext.SaveChangesAsync(); return(new OkResult()); } catch (Exception e) { return(BadRequest(e.Message)); } }
private static async Task InsertPageElements(WalletDbContext context) { if (context.PageData.Any()) { return; } var data = new List <PageData>() { new PageData() { ElementName = "AboutPage", ElementData = "Test data for about page" }, new PageData() { ElementName = "ContactPage", ElementData = "Test data for contact page" }, new PageData() { ElementName = "TipsETH", ElementData = "0x53d284357ec70ce289d6d64134dfac8e511c8a3d" }, new PageData() { ElementName = "TipsBTC", ElementData = "0x742d35cc6634c0532925a3b844bc454e4438f44e" } }; context.PageData.AddRange(data); await context.SaveChangesAsync(); }
public async Task <WalletAccount> Handle(DeleteWalletAccountCommand request, CancellationToken cancellationToken) { var walletAccountEntity = await _context.WalletAccounts .FindAsync(request.ID); if (walletAccountEntity == null) { return(new WalletAccount { ID = 0, statusCode = SharedStatusCodes.NotFound }); } _context.WalletAccounts.Remove(walletAccountEntity); if (await _context.SaveChangesAsync() > 0) { walletAccountEntity.statusCode = SharedStatusCodes.Deleted; } else { walletAccountEntity.statusCode = SharedStatusCodes.Failed; } return(walletAccountEntity); }
public async Task <Currency> Handle(CreateCurrencyCommand request, CancellationToken cancellationToken) { var entity = _context.Currencies.SingleOrDefault(b => b.Code == request.Code); if (entity != null) { entity.statusCode = SharedStatusCodes.Exists; return(entity); } var currencyEntity = new Currency { Name = request.Name, Symbol = request.Symbol, Code = request.Code, AddOnRegistration = request.AddOnRegistration }; _context.Currencies.Add(currencyEntity); if (await _context.SaveChangesAsync(cancellationToken) > 0) { currencyEntity.statusCode = SharedStatusCodes.Created; } else { currencyEntity.statusCode = SharedStatusCodes.Failed; } return(currencyEntity); }
public async Task <List <SavedCard> > Handle(GetUserSavedCardsQuery request, CancellationToken cancellationToken) { await _context.SaveChangesAsync(); List <SavedCard> savedCards = new List <SavedCard>(); try { if (request.UserID != null) { savedCards = _context.SavedCards.Where(x => x.UserID == request.UserID).ToList(); savedCards.FirstOrDefault().statusCode = SharedStatusCodes.Retrieved; } else { savedCards = _context.SavedCards.ToList(); savedCards.FirstOrDefault().statusCode = SharedStatusCodes.Retrieved; } } catch (Exception) { savedCards = null; } return(savedCards); }
public async Task <PaymentMethod> Handle(CreatePaymentMethodCommand request, CancellationToken cancellationToken) { var entity = _context.PaymentMethods.SingleOrDefault(b => b.Name == request.Name); if (entity != null) { entity.statusCode = SharedStatusCodes.Exists; return(entity); } var methodEntity = new PaymentMethod { Name = request.Name, Icon = request.Icon, ExternalCharges = request.ExternalCharges, InternalCharges = request.InternalCharges, AllowDeposit = request.AllowDeposit, AllowTransfer = request.AllowTransfer, AllowWithdrawal = request.AllowWithdrawal }; _context.PaymentMethods.Add(methodEntity); if (await _context.SaveChangesAsync(cancellationToken) > 0) { methodEntity.statusCode = SharedStatusCodes.Created; } else { methodEntity.statusCode = SharedStatusCodes.Failed; } return(methodEntity); }
public async Task <SavedCard> Handle(CreateSavedCardCommand request, CancellationToken cancellationToken) { var entity = _context.SavedCards.Where(e => e.MaskedNumber == request.MaskedNumber).FirstOrDefault(); if (entity != null) { entity.statusCode = SharedStatusCodes.Exists; return(entity); } var savedCard = new SavedCard { UserID = request.UserID, CardType = request.CardType, MaskedNumber = request.MaskedNumber, ExpiryDate = request.ExpiryDate }; _context.SavedCards.Add(savedCard); if (await _context.SaveChangesAsync(cancellationToken) > 0) { savedCard.statusCode = SharedStatusCodes.Created; } else { savedCard.statusCode = SharedStatusCodes.Failed; } return(savedCard); }
public async Task <PaymentMethod> Handle(DeletePaymentMethodCommand request, CancellationToken cancellationToken) { var entity = await _context.PaymentMethods .FindAsync(request.ID); if (entity == null) { return(new PaymentMethod { ID = 0, statusCode = SharedStatusCodes.NotFound }); } _context.PaymentMethods.Remove(entity); if (await _context.SaveChangesAsync() > 0) { entity.statusCode = SharedStatusCodes.Deleted; } else { entity.statusCode = SharedStatusCodes.Failed; } return(entity); }
public async Task <WalletAccount> Handle(CreateWalletAccountCommand request, CancellationToken cancellationToken) { var entity = new WalletAccount { UserID = request.UserID, CurrencyID = request.CurrencyID, WalletAccountCategoryID = request.WalletAccountCategoryID, WalletAccountCode = WalletAccount.generateWalletAccountCode(request.UserID), Name = request.Name, Balance = 0, IsDefault = false }; _context.WalletAccounts.Add(entity); if (await _context.SaveChangesAsync(cancellationToken) > 0) { entity.statusCode = SharedStatusCodes.Created; } else { entity.statusCode = SharedStatusCodes.Failed; } return(entity); }
public async Task <List <Recipient> > Handle(GetMultipleRecipientsQuery request, CancellationToken cancellationToken) { await _context.SaveChangesAsync(); List <Recipient> recipients = new List <Recipient>(); try { if (request.UserID != null) { recipients = _context.Recipients.Where(x => x.UserID == request.UserID).ToList(); recipients.FirstOrDefault().statusCode = SharedStatusCodes.Retrieved; } else { recipients = _context.Recipients.ToList(); recipients.FirstOrDefault().statusCode = SharedStatusCodes.Retrieved; } } catch (System.Exception) { recipients = null; } return(recipients); }
public async Task <SavedCard> Handle(DeleteSavedCardCommand request, CancellationToken cancellationToken) { var cardEntity = await _context.SavedCards .FindAsync(request.ID); if (cardEntity == null) { return(new SavedCard { ID = 0, statusCode = SharedStatusCodes.NotFound }); } _context.SavedCards.Remove(cardEntity); if (await _context.SaveChangesAsync() > 0) { cardEntity.statusCode = SharedStatusCodes.Deleted; } else { cardEntity.statusCode = SharedStatusCodes.Failed; } return(cardEntity); }
public async Task Handle(OrderStockUpdatedMessage message) { _logger.LogInformation($"OrderStockUpdated message was received. Order Id = {message.OrderId}"); var wallet = await _dbContext.Wallets.FirstOrDefaultAsync(x => x.UserId == message.UserId); var totalPrice = message.Products.Sum(x => x.Quantity * x.UnitPrice); if (wallet.Balance >= totalPrice) { wallet.Balance -= totalPrice; await _dbContext.SaveChangesAsync(); await _kafkaMessageProducer.Produce(OrderWalletPayCompletedTopicName, message.OrderId.ToString(), new { message.OrderId }); _logger.LogInformation($"OrderWalletPayCompleted message was sent. Order Id = {message.OrderId}"); } else { var orderWalletPayErrorMessage = new OrderWalletPayErrorMessage { OrderId = message.OrderId, WalletError = WalletError.InsufficientBalance, Products = message.Products.Select(x => new ProductDto { ProductId = x.ProductId, Quantity = x.Quantity }) }; await _kafkaMessageProducer.Produce(OrderWalletPayErrorTopicName, message.OrderId.ToString(), orderWalletPayErrorMessage); _logger.LogWarning($"OrderWalletPayError message was sent. Order Id = {message.OrderId}"); } }
public async Task <PaymentMethod> Handle(UpdatePaymentMethodCommand request, CancellationToken cancellationToken) { var entity = _context.PaymentMethods.SingleOrDefault(b => b.ID == request.ID); if (entity == null) { return(new PaymentMethod { ID = 0, statusCode = SharedStatusCodes.NotFound }); } if (entity.Name != request.Name) { entity.Name = request.Name; } if (entity.Icon != request.Icon) { entity.Icon = request.Icon; } if (request.ExternalCharges != null) { entity.ExternalCharges = request.ExternalCharges; } if (request.InternalCharges != null) { entity.InternalCharges = request.InternalCharges; } if (request.AllowDeposit != null) { entity.AllowDeposit = request.AllowDeposit; } if (request.AllowTransfer != null) { entity.AllowTransfer = request.AllowTransfer; } if (request.AllowWithdrawal != null) { entity.AllowWithdrawal = request.AllowWithdrawal; } if (!_context.Entry(entity).Context.ChangeTracker.HasChanges()) { entity.statusCode = SharedStatusCodes.Unchanged; return(entity); } if (await _context.SaveChangesAsync(cancellationToken) > 0) { entity.statusCode = SharedStatusCodes.Updated; } else { entity.statusCode = SharedStatusCodes.Failed; } return(entity); }
public async Task <IActionResult> Freeze([FromBody] FreezeRequest freezeRequest) { if (!ModelState.IsValid) { return(new BadRequestResult()); } var account = await _dbContext.Account.FirstOrDefaultAsync(a => a.Id == freezeRequest.Account); if (account == null) { return(StatusCode(205)); } account.IsFrozen = true; await _dbContext.SaveChangesAsync(); return(new OkResult()); }
private static async Task InsertTokens(WalletDbContext context) { if (context.Erc20Tokens.Any()) { return; } var tokens = ERC20TokensData.GetTokens(); context.Erc20Tokens.AddRange(tokens); await context.SaveChangesAsync(); }
public async Task <TransactionModel> SaveTransaction(TransactionDto transaction) { CategoryModel categoryModel = await context.Category.Where(c => c.id == transaction.categoryId).FirstOrDefaultAsync(); if (categoryModel == null) { throw new Exception("Brak kategorii transakcji"); } var transactionModel = new TransactionModel { title = transaction.title, type = transaction.type, category = categoryModel, amount = transaction.amount }; context.Add(transactionModel); await context.SaveChangesAsync(); return(transactionModel); }
public async Task <List <Currency> > Handle(GetMultipleCurrenciesQuery request, CancellationToken cancellationToken) { await _context.SaveChangesAsync(); List <Currency> currencies = _context.Currencies.ToList(); if (currencies.Count > 0) { currencies.FirstOrDefault().statusCode = SharedStatusCodes.Retrieved; } return(currencies); }
public async Task <List <PaymentMethod> > Handle(GetMultiplePaymentMethodsQuery request, CancellationToken cancellationToken) { await _context.SaveChangesAsync(); List <PaymentMethod> methods = _context.PaymentMethods.ToList(); if (methods.Count > 0) { methods.FirstOrDefault().statusCode = SharedStatusCodes.Retrieved; } return(methods); }
public async Task <Currency> Handle(UpdateCurrencyCommand request, CancellationToken cancellationToken) { var currencyEntity = _context.Currencies.SingleOrDefault(b => b.ID == request.ID); if (currencyEntity == null) { return(new Currency { ID = 0, statusCode = SharedStatusCodes.NotFound }); } if (request.Name != null) { currencyEntity.Name = request.Name; } if (request.Code != null) { currencyEntity.Code = request.Code; } if (request.Symbol != null) { currencyEntity.Symbol = request.Symbol; } if (request.AddOnRegistration != null && request.AddOnRegistration == true) { foreach (var crr in _context.Currencies.Where(x => x.AddOnRegistration == true).ToList()) { crr.AddOnRegistration = false; } currencyEntity.AddOnRegistration = request.AddOnRegistration; } if (!_context.Entry(currencyEntity).Context.ChangeTracker.HasChanges()) { currencyEntity.statusCode = SharedStatusCodes.Unchanged; return(currencyEntity); } if (await _context.SaveChangesAsync(cancellationToken) > 0) { currencyEntity.statusCode = SharedStatusCodes.Updated; } else { currencyEntity.statusCode = SharedStatusCodes.Failed; } return(currencyEntity); }
public async Task <IActionResult> SetPageElements([FromBody] PageData[] model) { try { dbContext.PageData.UpdateRange(model); await dbContext.SaveChangesAsync(); return(new OkResult()); } catch (Exception e) { return(BadRequest($"En error occurred :{e.Message}")); } }
public async Task <IActionResult> Register([FromBody] SignUpRequest signUpRequest) { if (!ModelState.IsValid) { return(new BadRequestResult()); } var user = await _dbContext.User.FirstOrDefaultAsync(u => u.Email == signUpRequest.Email || u.Username == signUpRequest.Username); if (user != null) { return(StatusCode(205)); } var accountId = Guid.NewGuid().ToString(); await _dbContext.Account.AddAsync(new Account { Id = accountId, Balance = 0, IsFrozen = false }); await _dbContext.User.AddAsync(new User { Username = signUpRequest.Username, Firstname = signUpRequest.Firstname, Middlename = signUpRequest.Middlename, Lastname = signUpRequest.Lastname, Email = signUpRequest.Email, Password = signUpRequest.Password, Account = accountId }); await _dbContext.SaveChangesAsync(); await Authenticate(signUpRequest.Username); // аутентификация return(new OkResult()); }
public async Task <Recipient> Handle(CreateRecipientCommand request, CancellationToken cancellationToken) { if (string.IsNullOrEmpty(request.Email) && string.IsNullOrEmpty(request.Phone)) { return(new Recipient { statusCode = RecipientStatusCodes.MissingEmailandPhone }); } var user = _context.Users.Where(e => e.ID == request.UserID).FirstOrDefault(); if (user == null) { return(new Recipient { ID = 0, statusCode = SharedStatusCodes.UserNotFound }); } var entity = _context.Recipients.Where(e => e.UserID == request.UserID && ((e.Email == request.Email && e.Email != null) || (e.Phone == request.Phone && e.Phone != null))).FirstOrDefault(); if (entity != null) { entity.statusCode = SharedStatusCodes.Exists; return(entity); } var recipientEntity = new Recipient { UserID = request.UserID, FirstName = request.FirstName, LastName = request.LastName, Email = request.Email, Phone = request.Phone }; _context.Recipients.Add(recipientEntity); if (await _context.SaveChangesAsync(cancellationToken) > 0) { recipientEntity.statusCode = SharedStatusCodes.Created; } else { recipientEntity.statusCode = SharedStatusCodes.Failed; } return(recipientEntity); }
public async Task <Recipient> Handle(UpdateRecipientCommand request, CancellationToken cancellationToken) { var recipientEntity = _context.Recipients.SingleOrDefault(b => b.ID == request.ID); if (recipientEntity == null) { return(new Recipient { ID = 0, statusCode = SharedStatusCodes.NotFound }); } if (recipientEntity.FirstName != request.FirstName) { recipientEntity.FirstName = request.FirstName; } if (recipientEntity.LastName != request.LastName) { recipientEntity.LastName = request.LastName; } if (request.Email != null) { recipientEntity.Email = request.Email; } if (request.Phone != null) { recipientEntity.Phone = request.Phone; } if (!_context.Entry(recipientEntity).Context.ChangeTracker.HasChanges()) { recipientEntity.statusCode = SharedStatusCodes.Unchanged; return(recipientEntity); } if (await _context.SaveChangesAsync(cancellationToken) > 0) { recipientEntity.statusCode = SharedStatusCodes.Updated; } else { recipientEntity.statusCode = SharedStatusCodes.Failed; } return(recipientEntity); }
public async Task <IActionResult> Add([FromBody] AddRequest request) { var account = await _dbContext.Account.FirstOrDefaultAsync(a => a.Id == request.Account); if (account == null) { return(StatusCode(205)); } if (account.IsFrozen) { return(StatusCode(202)); } account.Balance += request.MoneyAmount * 0.998f; await _dbContext.SaveChangesAsync(); return(new OkResult()); }
public async Task <Country> Handle(UpdateCountryCommand request, CancellationToken cancellationToken) { var entity = _context.Countries.SingleOrDefault(b => b.ID == request.ID); if (entity == null) { return(new Country { ID = 0, statusCode = SharedStatusCodes.NotFound }); } if (request.DefaultCurrencyID != null) { entity.DefaultCurrencyID = request.DefaultCurrencyID; } if (request.Name != null) { entity.Name = request.Name; } if (request.Code != null) { entity.Code = request.Code; } if (request.PhoneCode != null) { entity.PhoneCode = request.PhoneCode; } if (!_context.Entry(entity).Context.ChangeTracker.HasChanges()) { entity.statusCode = SharedStatusCodes.Unchanged; return(entity); } if (await _context.SaveChangesAsync(cancellationToken) > 0) { entity.statusCode = SharedStatusCodes.Updated; } else { entity.statusCode = SharedStatusCodes.Failed; } return(entity); }
public async Task <SavedCard> Handle(UpdateSavedCardCommand request, CancellationToken cancellationToken) { var cardEntity = _context.SavedCards.SingleOrDefault(b => b.ID == request.ID); if (cardEntity == null) { return(new SavedCard { ID = 0, statusCode = SharedStatusCodes.NotFound }); } if (cardEntity.MaskedNumber != request.MaskedNumber) { cardEntity.MaskedNumber = request.MaskedNumber; } if (cardEntity.CardType != request.CardType) { cardEntity.CardType = request.CardType; } if (cardEntity.ExpiryDate != request.ExpiryDate) { cardEntity.ExpiryDate = request.ExpiryDate; } if (!_context.Entry(cardEntity).Context.ChangeTracker.HasChanges()) { cardEntity.statusCode = SharedStatusCodes.Unchanged; return(cardEntity); } if (await _context.SaveChangesAsync(cancellationToken) > 0) { cardEntity.statusCode = SharedStatusCodes.Updated; } else { cardEntity.statusCode = SharedStatusCodes.Failed; } return(cardEntity); }
public async Task <User> Handle(DeleteUserCommand request, CancellationToken cancellationToken) { var entity = _context.Users.SingleOrDefault(x => x.ID == request.ID); if (entity == null) { return(new User { ID = 0, statusCode = SharedStatusCodes.NotFound }); } _context.Users.Remove(entity); // TO DO - remove other entities associated with this user await _context.SaveChangesAsync(cancellationToken); return(entity); }
private static async Task InsertUser(WalletDbContext context, UserManager <User> userManager, RoleManager <IdentityRole> roleManager) { if ((await context.Users.FirstOrDefaultAsync(u => u.Email == "*****@*****.**")) != null) { return; } const string email = "*****@*****.**"; const string role = "Admin"; await CreateDefaultAdministratorRole(roleManager, role); var user = await CreateDefaultUser(userManager, email); await AddDefaultRoleToDefaultUser(userManager, role, user); user.EmailConfirmed = true; await context.SaveChangesAsync(); }