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);
}
