public async Task <List <Invoices> > GetInvoices(InvoiceFilter filter)
{
string filterStr = GetFilter(filter);
DbConnection connection = GetConnection();
string sql = @" SELECT I.Id AS Id,
I.InvoiceDate AS InvoiceDate,
I.Price AS Price,
I.Currency AS Currency,
I.BuyerEU AS BuyerEU,
I.BuyerID AS BuyerID,
F.Country AS BuyerCountry, F.Name AS BuyerName, F.City AS BuyerCity, F.Address AS BuyerAddress, F.ZipCode AS BuyerZipCode
FROM Invoices I
INNER JOIN Facilities F
ON F.Id = I.BuyerID
WHERE " + filterStr;
var result = connection.Query <Invoices>(sql).ToList();
foreach (var item in result)
{
string sql2 = @" SELECT ISE.Serial AS Serial, ISE.Id AS Id
FROM InvoiceSerials ISE
WHERE ISE.InvoiceID = " + item.Id;
var serials = connection.Query <Serials>(sql2).ToList();
item.Serials = serials;
}
connection.Close();
return(result);
}
public IActionResult Get(InvoiceFilter filter)
{
var invoices = _siriusService.GetInvoices(filter);
if (invoices != null)
{
return(Ok(invoices));
}
return(NotFound());
}
public async Task <ActionResult <List <InvoiceDTO> > > GetInvoicesPaginated([FromQuery] InvoiceFilter invoiceFilter)
{
var invoices = await invoiceRepository.GetInvoicesPaginated(invoiceFilter, IncludeAll);
if (invoices == null)
{
return(NotFound());
}
return(mapper.Map <List <InvoiceDTO> >(invoices));
}
public Task <List <Invoice> > GetInvoicesPaginated(InvoiceFilter invoiceFilter, InvoiceIncludeFilters invoiceIncludeFilters)
{
var queryable = dbContext.Invoices.AsQueryable();
queryable = queryable.ApplyIncludes(invoiceIncludeFilters);
queryable = FindIds(invoiceFilter, queryable);
queryable = queryable.Paginate(invoiceFilter);
return(queryable.ToListAsync());
}
public IActionResult GetInvoiceStatuses([FromBody] InvoiceFilter filter)
{
try
{
filter.OrganisationId = invoiceService.OrganisationId;
return(Ok(invoiceService.GetInvoiceStatuses(filter)));
}
catch (Exception ex)
{
return(BadRequest(new Error(ex.Message)));
}
}
public ActionResult <IList <InvoiceDTO> > GetInvoices(InvoiceFilter filter)
{
string userId = User?.Identity?.Name;
if (string.IsNullOrEmpty(userId))
{
return(Forbid());
}
var invoices = InvoiceService.GetInvoices(filter);
return(invoices.Select((invoice) => new InvoiceDTO(invoice)).ToList());
}
private static IQueryable <Invoice> FindIds(InvoiceFilter invoiceFilter, IQueryable <Invoice> queryable)
{
if (!string.IsNullOrEmpty(invoiceFilter.UserId))
{
queryable = queryable.Where(x => x.UserId.Contains(invoiceFilter.UserId));
}
if (invoiceFilter.ActivityId.HasValue)
{
queryable = queryable.Where(x => x.ActivityId.Equals(invoiceFilter.ActivityId));
}
return(queryable);
}
public async Task <bool> UpdateInvoice(InvoiceFilter invoiceFilter, InvoiceCreationDTO invoiceCreationDTO)
{
var entity = await dbContext.Invoices.FirstOrDefaultAsync(x => x.ActivityId.Equals(invoiceFilter.ActivityId) && x.UserId.Equals(invoiceFilter.UserId));
if (entity == null)
{
return(false);
}
mapper.Map(invoiceCreationDTO, entity);
dbContext.Entry(entity).State = EntityState.Modified;
await dbContext.SaveChangesAsync();
return(true);
}
public async Task <int> GetTotalInvoices(InvoiceFilter filter)
{
string filterStr = GetFilter(filter);
DbConnection connection = GetConnection();
string sql = @" SELECT COUNT(*)
FROM Invoices I
WHERE " + filterStr;
var result = connection.Query <int>(sql).FirstOrDefault();
connection.Close();
return(result);
}
public async Task <ProcessResult <int> > CountAsync(InvoiceFilter filter)
{
IQueryable <Invoice> q = context.Invoices;
q = SetFilter(q, filter);
Func <Task <int> > action = async() =>
{
var countItems = await q.CountAsync();
return(countItems);
};
return(await Process.RunAsync(action));
}
private string GetFilter(InvoiceFilter filter)
{
string filterStr = "1=1";
string dateConverted;
if (filter.InvoiceDateFrom != null)
{
dateConverted = filter.InvoiceDateFrom?.ToString("yyyy-MM-ddTHH:mm:ssZ");
filterStr += $" AND I.InvoiceDate >= '{dateConverted}'";
}
if (filter.InvoiceDateTo != null)
{
dateConverted = filter.InvoiceDateTo?.ToString("yyyy-MM-ddTHH:mm:ssZ");
filterStr += $" AND I.InvoiceDate <= '{dateConverted}'";
}
if (filter.Id != 0)
{
filterStr += $" AND I.Id = {filter.Id}";
}
if (!string.IsNullOrEmpty(filter.BuyerID))
{
filterStr += $" AND I.BuyerID like '{filter.BuyerID}%'";
}
if (filter.BuyerEU == true)
{
filterStr += $" AND I.BuyerEU = 1";
}
else
{
filterStr += $" AND I.BuyerEU = 0";
}
if (!string.IsNullOrEmpty(filter.Currency))
{
filterStr += $" AND I.Currency like '{filter.Currency}%'";
}
if (filter.Price != 0.0)
{
filterStr += $" AND I.Price >= {filter.Price}";
}
return(filterStr);
}
public DataRespond FilterBySearchBox([FromBody] InvoiceFilter inv)
{
DataRespond data = new DataRespond();
try
{
data.success = true;
data.data = m_invoiceResponcitory.FilterBySearchBox(inv.filterBy);
}
catch (Exception e)
{
data.success = false;
data.error = e;
}
return(data);
}
public async Task <bool> DeleteInvoice(InvoiceFilter invoiceFilter)
{
if (invoiceFilter.ActivityId.HasValue && !string.IsNullOrEmpty(invoiceFilter.UserId))
{
var queryable = dbContext.Invoices.AsQueryable();
queryable = FindIds(invoiceFilter, queryable);
var entity = queryable.ToListAsync();
if (entity == null)
{
return(false);
}
dbContext.Entry(entity).State = EntityState.Deleted;
await dbContext.SaveChangesAsync();
return(true);
}
return(false);
}
public DataRespond filterIvByDay([FromBody] InvoiceFilter inv)
{
DataRespond data = new DataRespond();
try
{
DateTime stday = DateTime.ParseExact(inv.startday, "dd/MM/yyyy", CultureInfo.InvariantCulture);
DateTime eday = DateTime.ParseExact(inv.endday, "dd/MM/yyyy", CultureInfo.InvariantCulture);
data.data = m_invoiceResponcitory.FilterInvoiceByDay(stday, eday);
data.success = true;
}
catch (Exception e)
{
data.error = e;
data.success = false;
}
return(data);
}
public async Task <ActionResult> ExportXml([FromQuery] InvoiceFilter invoiceFilter, CancellationToken cancellationToken)
{
var list = await _invoiceService.GetAllInvoicesWithFiltersAsync(invoiceFilter, cancellationToken);
var memory = new MemoryStream();
var writer = new StreamWriter(memory);
var serializer = new XmlSerializer(typeof(List <GetInvoiceResource>));
serializer.Serialize(writer, list);
writer.Flush();
memory.Position = 0;
if (memory != Stream.Null)
{
return(File(memory, "application/xml", $"Export_{DateTime.Now}.xml"));
}
return(NotFound());
}
public async Task <ActionResult> ExportCsv([FromQuery] InvoiceFilter invoiceFilter, CancellationToken cancellationToken)
{
var list = await _invoiceService.GetAllInvoicesWithFiltersAsync(invoiceFilter, cancellationToken);
var memory = new MemoryStream();
var writer = new StreamWriter(memory);
var csvWriter = new CsvWriter(writer, CultureInfo.InvariantCulture);
csvWriter.WriteRecords(list);
writer.Flush();
memory.Position = 0;
if (memory != Stream.Null)
{
return(File(memory, "text/csv", $"Export_{DateTime.Now}.csv"));
}
return(NotFound());
}
private IQueryable <Invoice> SetFilter(IQueryable <Invoice> q, InvoiceFilter f)
{
if (f == null)
{
return(q);
}
if (f.reservationID > 0)
{
q = q.Where(s => s.ReservationID == f.reservationID);
}
if (f.currencyID > 0)
{
q = q.Where(s => s.CurrencyID == f.currencyID);
}
if (f.Date != null)
{
q = q.Where(s => s.Date > f.Date);
}
return(q);
}
public void GetTotalPages(InvoiceFilter filter)
{
using var context = Context();
filter.TotalRow = context.Invoice.Where(u => (filter.StatusId == 0 || u.StatusId == filter.StatusId) &&
(u.IdNavigation.OrganisationId == filter.OrganisationId) &&
(filter.CustomerId == 0 || u.IdNavigation.CustomerId == filter.CustomerId) &&
(
(filter.DateTypeFilter.Id == (int)InvoiceDateTypeFilterEnum.All &&
(filter.FromDate == null || u.IdNavigation.Date >= filter.FromDate || u.IdNavigation.DueDate >= filter.FromDate) &&
(filter.ToDate == null || u.IdNavigation.Date <= filter.ToDate || u.IdNavigation.DueDate <= filter.ToDate)) ||
(filter.DateTypeFilter.Id == (int)InvoiceDateTypeFilterEnum.Date &&
(filter.FromDate == null || u.IdNavigation.Date >= filter.FromDate) &&
(filter.ToDate == null || u.IdNavigation.Date <= filter.ToDate)) ||
(
filter.DateTypeFilter.Id == (int)InvoiceDateTypeFilterEnum.DueDate &&
(filter.FromDate == null || u.IdNavigation.DueDate >= filter.FromDate) &&
(filter.ToDate == null || u.IdNavigation.DueDate <= filter.ToDate))
) &&
(string.IsNullOrEmpty(filter.SearchText) || u.IdNavigation.Number.Contains(filter.SearchText))
).Count();
}
public List <Models.InvoiceStatus> GetInvoiceStatuses(InvoiceFilter filter)
{
using var context = Context();
var result = context.Invoice.Where(u => (u.IdNavigation.OrganisationId == filter.OrganisationId) &&
(filter.CustomerId == 0 || u.IdNavigation.CustomerId == filter.CustomerId) &&
(
(filter.DateTypeFilter.Id == (int)InvoiceDateTypeFilterEnum.All &&
(filter.FromDate == null || u.IdNavigation.Date >= filter.FromDate || u.IdNavigation.DueDate >= filter.FromDate) &&
(filter.ToDate == null || u.IdNavigation.Date <= filter.ToDate || u.IdNavigation.DueDate <= filter.ToDate)) ||
(filter.DateTypeFilter.Id == (int)InvoiceDateTypeFilterEnum.Date &&
(filter.FromDate == null || u.IdNavigation.Date >= filter.FromDate) &&
(filter.ToDate == null || u.IdNavigation.Date <= filter.ToDate)) ||
(
filter.DateTypeFilter.Id == (int)InvoiceDateTypeFilterEnum.DueDate &&
(filter.FromDate == null || u.IdNavigation.DueDate >= filter.FromDate) &&
(filter.ToDate == null || u.IdNavigation.DueDate <= filter.ToDate))
) &&
(string.IsNullOrEmpty(filter.SearchText) || u.IdNavigation.Number.Contains(filter.SearchText))
).GroupBy(u => u.StatusId)
.Select(u => new
{
StatusId = u.Key,
Count = u.Count()
}).ToList();
var statues = context.InvoiceStatus.ToList()
.Select(u => new Models.InvoiceStatus
{
Count = result.Any(t => t.StatusId == u.Id)?result.FirstOrDefault(t => t.StatusId == u.Id).Count:0,
Id = u.Id,
Name = IsKhmer?u.NameKh: u.Name
}).ToList();
statues.Insert(0, new Models.InvoiceStatus
{
Id = 0,
Name = AppResource.GetResource("All"),
Count = result.Sum(u => u.Count)
});
return(statues);
}
/// <summary>
/// Получить накладные по фильтру
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
public IEnumerable <InvoiceListDto> GetInvoices(InvoiceFilter filter)
{
if (filter.Name != null)
{
filter.Name = filter.Name.ToLower();
}
if (filter.FinishDate != DateTime.MinValue)
{
filter.FinishDate = filter.FinishDate.AddMinutes(59).AddHours(23);
}
Expression <Func <Invoice, bool> > f = x =>
(filter.Id != Guid.Empty ? x.Id == filter.Id : true) &&
(filter.Name != null ? x.Name.ToLower().Contains(filter.Name) : true) &&
(filter.VendorId != Guid.Empty ? x.VendorId == filter.VendorId : true) &&
(filter.UserId != Guid.Empty ? x.UserId == filter.UserId : true) &&
(filter.TypeId != Guid.Empty ? x.TypeId == filter.TypeId : true) &&
(filter.StartDate != DateTime.MinValue ? x.Date >= filter.StartDate : true) &&
(filter.FinishDate != DateTime.MinValue ? x.Date <= filter.FinishDate : true) &&
(filter.FixedOnly == true ? x.IsFixed == true : true);
return(_unitOfWork.InvoiceRepository.GetAll(f));
}
public IList <Invoice> GetInvoices(InvoiceFilter filter)
{
var query = Context.Set <Invoice>()
.Include(i => i.Lessons)
.ThenInclude(l => l.Student)
.AsEnumerable();
if (filter.TeacherId != null)
{
query = query.Where((invoice) => invoice.UserId == filter.TeacherId);
}
if (filter.Start != null)
{
query = query.Where((invoice) => invoice.CreatedDate >= filter.Start);
}
if (filter.End != null)
{
query = query.Where((invoice) => invoice.CreatedDate <= filter.End);
}
return(query.ToList());
}
public async Task <IReadOnlyList <Invoice> > GetByFilterAsync(InvoiceFilter invoiceFilter)
{
var filter = string.Empty;
if (invoiceFilter.MerchantIds.Any())
{
var localFilter = string.Empty;
foreach (var merchantId in invoiceFilter.MerchantIds)
{
localFilter = localFilter.OrIfNotEmpty(nameof(InvoiceEntity.PartitionKey).PropertyEqual(GetPartitionKey(merchantId)));
}
filter = localFilter;
}
if (invoiceFilter.ClientMerchantIds.Any())
{
var localFilter = string.Empty;
foreach (var clientMerchantId in invoiceFilter.ClientMerchantIds)
{
localFilter = localFilter.OrIfNotEmpty(nameof(InvoiceEntity.ClientName).PropertyEqual(clientMerchantId));
}
filter = filter.AndIfNotEmpty(localFilter);
}
if (invoiceFilter.Statuses.Any())
{
var localFilter = string.Empty;
foreach (var status in invoiceFilter.Statuses)
{
localFilter = localFilter.OrIfNotEmpty(nameof(InvoiceEntity.Status).PropertyEqual(status.ToString()));
}
filter = filter.AndIfNotEmpty(localFilter);
}
if (invoiceFilter.Dispute)
{
filter = filter.AndIfNotEmpty(nameof(InvoiceEntity.Dispute).PropertyEqual(true));
}
if (invoiceFilter.BillingCategories.Any())
{
var localFilter = string.Empty;
foreach (var cat in invoiceFilter.BillingCategories)
{
if (cat.IsEmpty())
{
continue;
}
localFilter = localFilter.OrIfNotEmpty(nameof(InvoiceEntity.BillingCategory).PropertyEqual(cat));
}
filter = filter.AndIfNotEmpty(localFilter);
}
if (invoiceFilter.DateFrom.HasValue)
{
filter = filter.AndIfNotEmpty(nameof(InvoiceEntity.CreatedDate).DateGreaterThanOrEqual(invoiceFilter.DateFrom.Value));
}
if (invoiceFilter.DateTo.HasValue)
{
filter = filter.AndIfNotEmpty(nameof(InvoiceEntity.CreatedDate).DateLessThanOrEqual(invoiceFilter.DateTo.Value));
}
if (filter.IsEmpty())
{
filter = nameof(InvoiceEntity.RowKey).PropertyNotEqual(GetInvoiceIdIndexRowKey())
.And(nameof(InvoiceEntity.RowKey).PropertyNotEqual(GetPaymentRequestIndexRowKey()));
}
var tableQuery = new TableQuery <InvoiceEntity>().Where(filter);
var result = await _storage.WhereAsync(tableQuery);
return(Mapper.Map <List <Invoice> >(result));
}
public async Task <List <Invoice> > GetInvoicesWithFilters(InvoiceFilter filter, CancellationToken cancellationToken = default)
{
try
{
using (var connection = CreateConnection())
{
string query =
@"select[i].[Id] as InvoiceId, [i].[CreatedDate], [i].[ConfirmationStatus], [i].[TotalCost], [w].[Id] as WarehouseId , [w].[Address], [ca].[Id] as CounterAgentId, [ca].[FirstName], [ca].[LastName], [ca].[Address], [ca].[Email], [ca].[IsCustomer], [ca].[PhoneNumber],[sm].[Id] as StaffMemberId, [sm].[FirstName], [sm].[LastName], [sm].[Address], [sm].[Email], [sm].[RegisterDate], [sm].[PhoneNumber], [p].[Id] as ProductId, [p].[Name], [p].[Description], [p].[Price], [p].[ManufacturedDate], [p].[ExpirationDate], [m].[Name] as Manufacturer, [mu].[Name] as MeasurementUnit, [p].[QuantityAtWarehouse], [inprod].[SoldPrice], [inprod].[SoldQuantity] from dbo.Invoice i join dbo.CounterAgent ca on i.AgentId = ca.Id join dbo.Warehouse w on i.WarehouseId = w.Id join dbo.StaffMember sm on i.CreatedStaffId = sm.Id join dbo.InvoiceProduct inprod on i.Id = inprod.InvoiceId join dbo.Product p on inprod.ProductId = p.Id join dbo.Manufacturer m on p.ManufacturerId = m.Id join dbo.MeasurementUnit mu on p.MeasurementUnitId = mu.Id";
var parameters = new DynamicParameters();
#region Filtration
string sqlWhere = "";
if (!string.IsNullOrWhiteSpace(filter.ProductName))
{
sqlWhere += " [p].[Name] like '%' + rtrim(ltrim(@ProductName)) + '%' AND";
parameters.Add("@ProductName", filter.ProductName);
}
if (!string.IsNullOrWhiteSpace(filter.StaffName))
{
sqlWhere += " [sm].[FirstName] like rtrim(ltrim(@StaffName)) + '%' AND";
parameters.Add("@StaffName", filter.StaffName);
}
if (filter.DateStart.HasValue)
{
sqlWhere += " [i].[CreatedDate] >= @DateStart AND";
parameters.Add("@DateStart", filter.DateStart);
}
if (filter.MinPrice.HasValue)
{
sqlWhere += " [i].[TotalCost] >= @MinPrice AND";
parameters.Add("@MinPrice", filter.MinPrice);
}
if (filter.MaxPrice.HasValue)
{
sqlWhere += " [i].[TotalCost] <= @MaxPrice AND";
parameters.Add("@MaxPrice", filter.MaxPrice);
}
if (filter.DateEnd.HasValue)
{
sqlWhere += " [i].[CreatedDate] <= @DateEnd AND";
parameters.Add("@DateEnd", filter.DateEnd);
}
if (filter.AgentIsCustomer.HasValue && filter.AgentIsCustomer == true)
{
sqlWhere += " [ca].[IsCustomer] = 1 AND";
}
if (filter.AgentIsCustomer.HasValue && filter.AgentIsCustomer == false)
{
sqlWhere += " [ca].[IsCustomer] = 0 AND";
}
if (sqlWhere.Length > 0)
{
sqlWhere = " WHERE " + sqlWhere.Substring(0, sqlWhere.Length - 3);
}
#endregion
string sqlQuery = query + sqlWhere;
var data = (await connection.QueryAsync
<Invoice, StaffMember, CounterAgent, Warehouse, InvoiceProduct, Invoice>(
sql: sqlQuery,
map: (invoice, staffMember, counterAgent, warehouse, invoiceProduct) => {
invoice.CreatedStaff = staffMember;
invoice.CounterAgent = counterAgent;
invoice.Warehouse = warehouse;
invoice.Products.Add(invoiceProduct);
return(invoice);
},
param: parameters,
splitOn: "InvoiceId, WarehouseId, CounterAgentId, StaffMemberId, ProductId",
commandType: CommandType.Text
))
.ToList();
var result = data.GroupBy(p => p.InvoiceId).Select(g =>
{
var groupedInvoice = g.First();
groupedInvoice.Products = g.Select(p => p.Products.Single()).ToList();
return(groupedInvoice);
});
return(result.ToList());
}
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
}
public async Task <List <GetInvoiceResource> > GetAllInvoicesWithFiltersAsync(InvoiceFilter invoiceFilter, CancellationToken cancellationToken = default)
{
var invoices = await _invoiceRepository.GetInvoicesWithFilters(invoiceFilter, cancellationToken);
var invoiceResources = _mapper.Map <List <GetInvoiceResource> >(invoices);
return(invoiceResources);
}
public IList <Invoice> GetInvoices(InvoiceFilter filter)
{
return(InvoiceRepository.GetInvoices(filter));
}
public List <Models.Invoice> GetInvoices(InvoiceFilter filter)
{
using var context = Context();
var khmer = IsKhmer;
var result = context.Invoice.Where(u => (filter.StatusId == 0 || u.StatusId == filter.StatusId) &&
(u.IdNavigation.OrganisationId == filter.OrganisationId) &&
(filter.CustomerId == 0 || u.IdNavigation.CustomerId == filter.CustomerId) &&
(
(filter.DateTypeFilter.Id == (int)InvoiceDateTypeFilterEnum.All &&
(filter.FromDate == null || u.IdNavigation.Date >= filter.FromDate || u.IdNavigation.DueDate >= filter.FromDate) &&
(filter.ToDate == null || u.IdNavigation.Date <= filter.ToDate || u.IdNavigation.DueDate <= filter.ToDate)) ||
(filter.DateTypeFilter.Id == (int)InvoiceDateTypeFilterEnum.Date &&
(filter.FromDate == null || u.IdNavigation.Date >= filter.FromDate) &&
(filter.ToDate == null || u.IdNavigation.Date <= filter.ToDate)) ||
(
filter.DateTypeFilter.Id == (int)InvoiceDateTypeFilterEnum.DueDate &&
(filter.FromDate == null || u.IdNavigation.DueDate >= filter.FromDate) &&
(filter.ToDate == null || u.IdNavigation.DueDate <= filter.ToDate))
) &&
(string.IsNullOrEmpty(filter.SearchText) || u.IdNavigation.Number.Contains(filter.SearchText))
).OrderByDescending(u => u.IdNavigation.Date)
.Skip((filter.Page - 1) * filter.PageSize)
.Take(filter.PageSize)
.Select(u => new Models.Invoice
{
BaseCurrencyExchangeRate = u.IdNavigation.BaseCurrencyExchangeRate,
Created = u.IdNavigation.Created,
CreatedBy = u.IdNavigation.CreatedBy,
Currency = new Models.Currency
{
Code = u.IdNavigation.Currency.Code,
Id = u.IdNavigation.CurrencyId,
Name = u.IdNavigation.Currency.Name,
Symbole = u.IdNavigation.Currency.Symbole
},
CurrencyId = u.IdNavigation.CurrencyId,
Id = u.Id,
Customer = new Models.Customer
{
Id = u.IdNavigation.CustomerId,
DisplayName = u.IdNavigation.Customer.DisplayName
},
CustomerId = u.IdNavigation.CustomerId,
Date = u.IdNavigation.Date,
DueDate = u.IdNavigation.DueDate,
IsTaxIncome = u.IdNavigation.IsTaxIncome,
Note = u.IdNavigation.Note,
Number = u.IdNavigation.Number,
OrganisationId = u.IdNavigation.OrganisationId,
RefNo = u.IdNavigation.RefNo,
StatusId = u.StatusId,
Total = u.IdNavigation.Total,
TotalIncludeTax = u.IdNavigation.TotalIncludeTax,
TaxCurrencyExchangeRate = u.IdNavigation.TaxCurrencyExchangeRate,
Status = new Models.InvoiceStatus
{
Id = u.StatusId,
Name = khmer?u.Status.NameKh:u.Status.Name
},
PaidBy = u.IdNavigation.PaidBy,
PaidDate = u.IdNavigation.PaidDate
}).ToList();
return(result);
}
public async Task <ActionResult <IEnumerable <GetInvoiceResource> > > GetInvoices([FromQuery] InvoiceFilter invoiceFilter, CancellationToken cancellationToken = default)
{
return(Ok(await _invoiceService.GetAllInvoicesWithFiltersAsync(invoiceFilter, cancellationToken)));
}
