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