private async Task <List <Transaction> > GetFiltered(TransactionFilterModel filterModel)
{
var transactions = _unitOfWork.Transactions.GetAllAsync();
if (!string.IsNullOrEmpty(filterModel.Status))
{
transactions = transactions.Where(t => t.Status.ToLower() == filterModel.Status.ToLower());
}
if (filterModel.StartDateTime.HasValue)
{
transactions = transactions.Where(t => t.Date > filterModel.StartDateTime.Value);
}
if (filterModel.EndDateTime.HasValue)
{
transactions = transactions.Where(t => t.Date < filterModel.EndDateTime.Value);
}
if (!string.IsNullOrEmpty(filterModel.Currency))
{
transactions = transactions.Where(t => t.CurrencyCode.ToLower() == filterModel.Currency.ToLower());
}
var result = await transactions.ToListAsync();
return(result);
}
public Task <List <Transactions> > Filter(TransactionFilterModel transaction, int user_id)
{
AccountsUserModel acc = new AccountsUserModel()
{
IdARS = _unitOfWork.Accounts.GetAccountId(user_id, "ARS"),
IdUSD = _unitOfWork.Accounts.GetAccountId(user_id, "USD")
};
if (!_unitOfWork.Accounts.ValidateAccounts(acc))
{
throw new CustomException(404, "No se encontró algunas de las cuentas del usuario");
}
//si el id de account es null o menor a 0 se asume que busca en pesos
if (transaction.AccountId == null || transaction.AccountId <= 0)
{
transaction.AccountId = (int)acc.IdARS;
}
if (transaction.AccountId != acc.IdARS && transaction.AccountId != acc.IdUSD) //si el id de la account ingresado es distinta a alguna de la suyas, se asume que busca en pesos
{
transaction.AccountId = (int)acc.IdARS;
}
Task <List <Transactions> > List = _unitOfWork.Transactions.FilterTransaction(transaction, (int)acc.IdUSD, (int)acc.IdARS);
return(List);
}
public async Task <IActionResult> GetFilteredTransactions(TransactionFilterModel filters)
{
return(Ok(await _transactionService.GetFilteredTransactions(filters.CurrencyCode,
filters.StartDate,
filters.EndDate,
filters.Status)));
}
public async Task <List <TransactionResponseModel> > GetAsync(TransactionFilterModel filterModel)
{
var transactions = await GetFiltered(filterModel);
var result = transactions.Adapt <List <TransactionResponseModel> >();
return(result);
}
public async Task <IActionResult> GetTransactionsCount([FromQuery] TransactionFilterModel filter)
{
var count = await _TransactionService.GetTransactionsCount(
filter.TypeId,
filter.DateFrom,
filter.DateTo,
filter.Amountfrom,
filter.AmountTo);
return(Ok(count));
}
public async Task <IActionResult> GetAll([FromQuery] int page, [FromQuery] TransactionFilterModel transactionFilterModel)
{
try
{
//this is commented until the user can log in
var user_id = int.Parse(User.Claims.First(i => i.Type == "UserId").Value);
var ListDB = await _transactionBusiness.GetAll(transactionFilterModel, user_id, page);
return(StatusCode(200, ListDB));
}
catch { throw; }
}
public async Task <IActionResult> GetTransactions([FromQuery] TransactionFilterModel filter)
{
var transactions = await _TransactionService.GetTransactions(
filter.TypeId,
filter.DateFrom,
filter.DateTo,
filter.Amountfrom,
filter.AmountTo,
filter.PageNumber,
filter.PageSize);
return(Ok(transactions));
}
public async Task <List <TransactionViewModel> > GetAllTransactions(TransactionFilterModel filterModel)
{
var query = _context.Transactions.Include(i => i.CurrencyCode).Select(x => x);
if (filterModel.Currency != default)
{
query = query.Where(x => x.CurrencyCodeId == filterModel.Currency);
}
if (filterModel.Status != TransactionStatus.None)
{
query = query.Where(x => x.Status == (byte)filterModel.Status);
}
if (filterModel.FromDate != default)
{
query = query.Where(x => x.TransactionDate >= filterModel.FromDate);
}
if (filterModel.ToDate != default)
{
query = query.Where(x => x.TransactionDate <= filterModel.ToDate);
}
var model = await query.ToListAsync();
var list = new List <TransactionViewModel>();
foreach (var item in model)
{
list.Add(new TransactionViewModel()
{
Id = item.TransactionId,
Payment = $"{item.Amount.ToString("n2")} {item.CurrencyCode.Code}",
Status = ((TransactionStatus)Enum.ToObject(typeof(TransactionStatus), item.Status)).ToString().FirstOrDefault()
});
}
return(list);
}
public async Task <IEnumerable <TransactionModel> > GetAll(TransactionFilterModel tfm, int user_id, int page)
{
if (user_id <= 0)
{
throw new CustomException(400, "Id de usuario no válido");
}
IEnumerable <Transactions> listDB;
//si busca con algún filtro
if ((tfm.Type != "" && tfm.Type != null) ||
(tfm.Concept != "" && tfm.Concept != null) ||
(tfm.AccountId != null && tfm.AccountId >= 1))
{
listDB = await Filter(tfm, user_id);
}
//si busca sin filtros
else
{
AccountsUserModel a = _unitOfWork.Accounts.GetAccountsUsers(user_id);
if (_unitOfWork.Accounts.ValidateAccounts(a))
{
listDB = await _unitOfWork.Transactions.GetTransactionsUser((int)a.IdARS, (int)a.IdUSD);
}
else
{
throw new CustomException(404, "No se encontró algunas de las cuentas del usuario");
}
}
IEnumerable <TransactionModel> list = _mapper.Map <IEnumerable <TransactionModel> >(listDB);
//paginado con xpagelist
if (page <= 0)
{
page = 1;
} //asigna la primer página
int pageNumber = (int)page, pageSize = 10; //10 registros por página
list = await list.ToPagedList(pageNumber, pageSize).ToListAsync();
return(list);
}
public Task <List <Transactions> > FilterTransaction(TransactionFilterModel t, int usd_id, int ars_id)
{
Task <List <Transactions> > list = null;
if (t.Concept != "" && t.Concept != null)
{
list = _context.Transactions.Where(e => e.AccountId == t.AccountId && e.Concept.ToLower().Contains(t.Concept.ToLower())).ToListAsync();
}
else if (t.Type != "" && t.Type != null)
{
list = _context.Transactions.Where(e => e.AccountId == t.AccountId && e.Type.ToLower().Contains(t.Type.ToLower())).ToListAsync();
}
else if (t.AccountId != null)
{
list = _context.Transactions.Where(e => e.AccountId == t.AccountId).ToListAsync();
}
else
{
list = _context.Transactions.Where(e => e.AccountId == usd_id || e.AccountId == ars_id).ToListAsync();
}
return(list);
}
public IActionResult GetTransactionsCount([FromQuery] TransactionFilterModel filter)
{
var count = _transactionService.GetTransactionsCount(filter.TypeId, filter.DateFrom, filter.DateTo, filter.AmountFrom, filter.AmountTo);
return(Ok(count));
}
public IActionResult GetAll([FromQuery] TransactionFilterModel filter)
{
var transactions = _transactionService.GetTransactions(filter.TypeId, filter.DateFrom, filter.DateTo, filter.AmountFrom, filter.AmountTo, filter.PageNumber, filter.PageSize);
return(Ok(transactions));
}
private static TransactionFilter Convert(TransactionFilterModel filterModel) =>
new TransactionFilter(
filterModel.CurrencyCode,
string.IsNullOrEmpty(filterModel.Status) ? (TransactionStatus?)null : (TransactionStatus)Enum.Parse(typeof(TransactionStatus), filterModel.Status),
filterModel.StartDate,
filterModel.EndDate);
public async Task <IReadOnlyCollection <TransactionModel> > Get([FromQuery] TransactionFilterModel filter)
{
IReadOnlyCollection <Transaction> transactions = await _transactionProvider.GetTransactionsAsync(Convert(filter));
return(transactions.Select(transaction => new TransactionModel(transaction)).ToList());
}
public async Task <ActionResult <List <TransactionResponseModel> > > GetAsync([FromQuery] TransactionFilterModel filterModel)
{
var result = await _transactionService.GetAsync(filterModel);
return(Ok(result));
}
public async Task <Pagination <TransactionMDDto> > GetTransactionsWithFiltersAsync(TransactionFilterModel filters)
{
var result = _context.TransactionMDs.AsQueryable();
if (!string.IsNullOrWhiteSpace(filters.Status))
{
TransactionStatus status = GetEnumStatusName(filters.Status);
if (status != TransactionStatus.Default)
{
result = result.Where(x => x.Status == status);
}
}
if (!string.IsNullOrWhiteSpace(filters.Type))
{
TransactionType types = GetEnumTypeName(filters.Type);
if (types != TransactionType.Default)
{
result = result.Where(x => x.Type == types);
}
}
// pagination
var totalItems = result.Count();
var pagesLast = (int)Math.Ceiling((double)totalItems / (double)pageSize);
if (filters.Page > pagesLast)
{
filters.Page = pagesLast;
}
if (filters.Page == 0)
{
filters.Page = 1;
}
var listOfData = await result.Skip((filters.Page - 1) *pageSize).Take(pageSize).ToListAsync();
var data = _mapper.Map <IReadOnlyList <TransactionMD>, IReadOnlyList <TransactionMDDto> >(listOfData);
bool previousPage = filters.Page - 1 != 0 ? true : false;
bool nextPage = filters.Page + 1 > pagesLast ? false : true;
return(new Pagination <TransactionMDDto>(filters.Page, pagesLast, pageSize, totalItems, listOfData.Count(), previousPage, nextPage, data));
}
public async Task <IActionResult> List([FromQuery] TransactionFilterModel model) => Ok(await _transactionService.GetAllTransactions(model));
public async Task <ActionResult <Pagination <TransactionMDDto> > > GetAllTransactions([FromQuery] TransactionFilterModel transFilter)
{
return(Ok(await _transactionService.GetTransactionsWithFiltersAsync(transFilter)));
}
