public async Task <int> Count(WalletFilter filter) { IQueryable <WalletDAO> walletDAOs = wASContext.Wallet; walletDAOs = DynamicFilter(walletDAOs, filter); return(await walletDAOs.CountAsync()); }
public async Task <Transaction> Create(Transaction transaction) { if (!await TransactionValidator.Create(transaction)) { return(transaction); } using (UnitOfWork.Begin()) { try { CategoryFilter categoryFilter = new CategoryFilter { Name = new StringFilter { Equal = transaction.CategoryName } }; Category category = await UnitOfWork.CategoryRepository.Get(categoryFilter); WalletFilter walletFilter = new WalletFilter { Name = new StringFilter { Equal = transaction.WalletName }, UserId = new GuidFilter { Equal = transaction.UserId } }; Wallet wallet = await UnitOfWork.WalletRepository.Get(walletFilter); transaction.Id = Guid.NewGuid(); transaction.WalletId = wallet.Id; transaction.CategoryId = category.Id; if (category.Type == CategoryType.Inflow) { wallet.Balance += transaction.Amount; } else { wallet.Balance -= transaction.Amount; } await UnitOfWork.WalletRepository.Update(wallet); await UnitOfWork.TransactionRepository.Create(transaction); await UnitOfWork.Commit(); } catch (Exception ex) { await UnitOfWork.Rollback(); transaction.AddError(nameof(TransactionService), nameof(Transaction.Id), CommonEnum.ErrorCode.SystemError); } } return(transaction); }
public async Task <Wallet> UpdateWalletName(Wallet wallet, string newName) { if (wallet == null) { return(null); } if (!await WalletValidator.Update(wallet, newName)) { return(wallet); } using (UnitOfWork.Begin()) { try { WalletFilter filter = new WalletFilter { UserId = new GuidFilter { Equal = wallet.UserId }, Name = new StringFilter { Equal = wallet.Name } }; wallet = await Get(filter); wallet.Name = newName; await UnitOfWork.WalletRepository.Update(wallet); await UnitOfWork.Commit(); return(await Get(new WalletFilter { Id = new GuidFilter { Equal = wallet.Id }, UserId = new GuidFilter { Equal = wallet.UserId }, Name = new StringFilter { Equal = wallet.Name }, Balance = new DecimalFilter { Equal = wallet.Balance } })); } catch (Exception ex) { await UnitOfWork.Rollback(); wallet.AddError(nameof(WalletService), nameof(wallet.Id), CommonEnum.ErrorCode.SystemError); } } return(wallet); }
public async Task <int> Count(WalletFilter filter) { if (filter == null) { filter = new WalletFilter { } } ; return(await UnitOfWork.WalletRepository.Count(filter)); }
public async Task <List <Wallet> > List(WalletFilter filter) { if (filter == null) { filter = new WalletFilter { } } ; return(await UnitOfWork.WalletRepository.List(filter)); }
public async Task <Wallet> Get(WalletFilter filter) { IQueryable <WalletDAO> wallets = wASContext.Wallet.AsNoTracking(); WalletDAO walletDAO = DynamicFilter(wallets, filter).FirstOrDefault(); return(new Wallet() { Id = walletDAO.Id, Name = walletDAO.Name, Balance = walletDAO.Balance, UserId = walletDAO.UserId }); }
private async Task <bool> WalletDuplicated(Wallet wallet) { WalletFilter walletFilter = new WalletFilter { Take = Int32.MaxValue, Id = new GuidFilter { Equal = wallet.Id } }; int count = await unitOfWork.WalletRepository.Count(walletFilter); if (count > 0) { wallet.AddError(nameof(WalletValidator), nameof(wallet.Name), ErrorCode.WalletDuplicated); return(false); } return(true); }
private IQueryable <WalletDAO> DynamicOrder(IQueryable <WalletDAO> query, WalletFilter filter) { switch (filter.OrderType) { case OrderType.ASC: switch (filter.OrderBy) { case WalletOrder.Name: query = query.OrderBy(q => q.Name); break; case WalletOrder.Balance: query = query.OrderBy(q => q.Balance); break; default: query = query.OrderBy(q => q.CX); break; } break; case OrderType.DESC: switch (filter.OrderBy) { case WalletOrder.Name: query = query.OrderByDescending(q => q.Name); break; case WalletOrder.Balance: query = query.OrderByDescending(q => q.Balance); break; default: query = query.OrderByDescending(e => e.CX); break; } break; default: query = query.OrderBy(q => q.CX); break; } return(query.Skip(filter.Skip).Take(filter.Take)); }
public async Task <List <Wallet> > List(WalletFilter filter) { if (filter == null) { return(new List <Wallet>()); } IQueryable <WalletDAO> query = wASContext.Wallet; query = DynamicFilter(query, filter); query = DynamicOrder(query, filter); List <Wallet> list = await query.Select(q => new Wallet() { Id = q.Id, Name = q.Name, Balance = q.Balance, UserId = q.UserId }).ToListAsync(); return(list); }
private async Task <bool> ValidateNotExistedWallet(Wallet wallet) { WalletFilter filter = new WalletFilter { UserId = new GuidFilter { Equal = wallet.UserId }, Name = new StringFilter { Equal = wallet.Name } }; int countWallet = await unitOfWork.WalletRepository.Count(filter); if (countWallet > 0) { wallet.AddError(nameof(WalletValidator), nameof(wallet.Name), ErrorCode.WalletDuplicated); return(false); } return(true); }
public async Task <List <WalletDTO> > List() { WalletFilter walletFilter = new WalletFilter() { UserId = new GuidFilter { Equal = currentUserId }, }; List <Entities.Wallet> wallets = await walletService.List(walletFilter); List <WalletDTO> walletDTOs = new List <WalletDTO>(); wallets.ForEach(w => walletDTOs.Add(new WalletDTO { UserId = w.UserId, Name = w.Name, Balance = w.Balance, Errors = w.Errors })); return(walletDTOs); }
private IQueryable <WalletDAO> DynamicFilter(IQueryable <WalletDAO> query, WalletFilter filter) { if (filter == null) { return(query.Where(q => 1 == 0)); } query = query.Where(q => q.UserId, filter.UserId); if (filter.Id != null) { query = query.Where(q => q.Id, filter.Id); } if (filter.Name != null) { query = query.Where(q => q.Name, filter.Name); } if (filter.Balance != null) { query = query.Where(q => q.Balance, filter.Balance); } return(query); }
public async Task <Wallet> Delete(Wallet wallet) { if (!await WalletValidator.Delete(wallet)) { return(wallet); } using (UnitOfWork.Begin()) { try { WalletFilter walletFilter = new WalletFilter { UserId = new GuidFilter { Equal = wallet.UserId }, Name = new StringFilter { Equal = wallet.Name } }; Wallet walletToDelete = await UnitOfWork.WalletRepository.Get(walletFilter); await UnitOfWork.WalletRepository.Delete(walletToDelete.Id); await UnitOfWork.Commit(); return(walletToDelete); } catch (Exception ex) { await UnitOfWork.Rollback(); wallet.AddError(nameof(WalletService), nameof(wallet.Id), CommonEnum.ErrorCode.SystemError); return(wallet); } } }
public async Task <Tuple <Wallet, Wallet> > Transfer(Tuple <Wallet, Wallet> transferWalletTuple, decimal transferAmount, string note) { if (!await WalletValidator.Transfer(transferWalletTuple)) { return(transferWalletTuple); } using (UnitOfWork.Begin()) { try { // tao filter de tim 2 wallet yeu cau trong Repo WalletFilter sourceWalletFilter = new WalletFilter { UserId = new GuidFilter { Equal = transferWalletTuple.Item1.UserId }, Name = new StringFilter { Equal = transferWalletTuple.Item1.Name } }; WalletFilter destinationWalletFilter = new WalletFilter { UserId = new GuidFilter { Equal = transferWalletTuple.Item2.UserId }, Name = new StringFilter { Equal = transferWalletTuple.Item2.Name } }; // Lay du lieu 2 wallet tu DB, tru tien cua sourceWallet va cong tien vao destWallet Wallet source = await UnitOfWork.WalletRepository.Get(sourceWalletFilter); Wallet dest = await UnitOfWork.WalletRepository.Get(destinationWalletFilter); source.Balance -= transferAmount; dest.Balance += transferAmount; // Tao transaction o ca 2 wallet Transaction sourceTransaction = new Transaction { Id = Guid.NewGuid(), Amount = transferAmount, Date = DateTime.Now, Note = note, WalletId = source.Id, CategoryId = CommonEnum.CreateGuid("Wallet Transfer Source") }; Transaction destTransaction = new Transaction { Id = Guid.NewGuid(), Amount = transferAmount, Date = DateTime.Now, Note = note, WalletId = dest.Id, CategoryId = CommonEnum.CreateGuid("Wallet Transfer Destination") }; // Update vao Repo await UnitOfWork.WalletRepository.Update(source); await UnitOfWork.TransactionRepository.Create(sourceTransaction); await UnitOfWork.WalletRepository.Update(dest); await UnitOfWork.TransactionRepository.Create(destTransaction); await UnitOfWork.Commit(); // Tra ve tuple da transfer return(Tuple.Create(source, dest)); } catch (Exception e) { await UnitOfWork.Rollback(); transferWalletTuple.Item1.AddError(nameof(WalletService), nameof(Transfer), CommonEnum.ErrorCode.SystemError); transferWalletTuple.Item2.AddError(nameof(WalletService), nameof(Transfer), CommonEnum.ErrorCode.SystemError); return(transferWalletTuple); } } }
public async Task <Wallet> Get(WalletFilter filter) { return(await UnitOfWork.WalletRepository.Get(filter)); }
public async Task AssociationDeleteTest() { await categories.DeleteAllAsync(); await wallets.DeleteAllAsync(); await walletsCategories.DeleteAllAsync(); var cat1 = new Category() { Name = "category test 1" }; var cat2 = new Category() { Name = "category test 2" }; var wallet1 = new Wallet() { Name = "wallet test 1" }; var wallet2 = new Wallet() { Name = "wallet test 2" }; await categories.InsertAsync(cat1, cat2); await wallets.InsertAsync(wallet1, wallet2); var categoryFilter = new CategoryFilter() { Name = "category test 1" }; cat1 = (await categories.GetAsync(categoryFilter)).First(); categoryFilter.Name = "category test 2"; cat2 = (await categories.GetAsync(categoryFilter)).First(); var walletFilter = new WalletFilter() { Name = "wallet test 1" }; wallet1 = (await wallets.GetAsync(walletFilter)).First(); walletFilter.Name = "wallet test 2"; wallet2 = (await wallets.GetAsync(walletFilter)).First(); var walletCategory1 = new WalletCategory() { CategoryId = cat1.Id, WalletId = wallet1.Id }; var walletCategory2 = new WalletCategory() { CategoryId = cat2.Id, WalletId = wallet2.Id }; await walletsCategories.InsertAsync(walletCategory1, walletCategory2); Assert.AreEqual(2, (await walletsCategories.GetAllAsync()).Count); await categories.DeleteAsync(cat1.Id); Assert.AreEqual(1, (await walletsCategories.GetAllAsync()).Count); await wallets.DeleteAsync(wallet2.Id); Assert.AreEqual(0, (await walletsCategories.GetAllAsync()).Count); }