NTP_V2/src/NTP.Application/Grains/Orders/BillingService.cs

204 lines
11 KiB
C#

using FluentValidation;
using NTP.Application.Abstractions;
using NTP.Application.Common;
using NTP.Domain.Grains.Orders;
namespace NTP.Application.Grains.Orders;
public interface IBillingService
{
Task<BillingPermitDto> GetPermitAsync(long pn, long? scac, CancellationToken ct);
Task<OrdersResult> AddAsync(AddBillingRequest request, CancellationToken ct);
Task<PagedResult<BillingDto>> SearchAsync(BillingQuery query, PageRequest page, CancellationToken ct);
Task<BillingRerouteDto> GetRerouteAsync(long id, CancellationToken ct);
Task<OrdersResult> RerouteAsync(long id, RerouteRequest request, CancellationToken ct);
Task<OrdersResult> DeleteAsync(long id, CancellationToken ct);
}
/// <summary>Port of Invoice.cfc getBillingInfo / addBillingInfo / getBillingGrid (BillingScreen.cfm, BillingGrid.cfm).</summary>
public sealed class BillingService(
IBillingRepository repository,
IUnitOfWork unitOfWork,
IEventLogger events,
ICurrentUser user,
IValidator<AddBillingRequest> validator) : IBillingService
{
private static string? Date(DateTime? d) => d?.ToString("yyyy-MM-dd");
/// <summary>Port of getBillingInfo (2023 version): empty PN, billing already entered, permit not found.</summary>
public async Task<BillingPermitDto> GetPermitAsync(long pn, long? scac, CancellationToken ct)
{
if (await repository.PnExistsAsync(pn, ct)) throw OrdersErrors.BillingExists();
var info = await repository.GetPermitBillingInfoAsync(pn, user.UserId, ct) ?? throw OrdersErrors.InvalidPn();
if (scac.HasValue && scac.Value != info.Scac) throw OrdersErrors.PnNotOfCompany();
var lnw = BillingCalculator.NetWeight(info.Lgw, info.Ltw);
var dnw = BillingCalculator.NetWeight(info.Dgw, info.Dtw);
// Prices shown on the screen are the ones addBillingInfo will store: the destination's wage rate and the
// cargo type's fine rate, both valid on the loading date.
decimal? price = null, finePrice = null;
if (info.LoadDate.HasValue)
{
if (info.Destination.HasValue)
price = (await repository.GetWageRateAsync(info.Destination.Value, info.LoadDate.Value.Date, ct))?.Wage;
if (info.CargoType.HasValue)
finePrice = (await repository.GetFineRateAsync(info.CargoType.Value, info.LoadDate.Value.Date, ct))?.Fine;
}
return new BillingPermitDto(
info.Pn, info.Scac, info.CompanyName, info.CargoType, info.Tn, info.Destination,
Date(info.LoadDate), Date(info.DischargeDate), lnw,
dnw == 0 ? null : dnw, // the legacy page left the received-weight box empty when it was 0
info.LastInvoice, price, finePrice);
}
/// <summary>
/// Port of addBillingInfo (Invoice.cfc, 2023) with the field mapping corrected on request: "رقم المطالبة" is the invoice
/// number (INVOICE / GRAINS_BILLING.INVOICENUMBER) and "رقم المستند" is stored in GRAINS_BILLING.SERIALNO.
/// (The legacy CFC had the two swapped.)
/// </summary>
public async Task<OrdersResult> AddAsync(AddBillingRequest request, CancellationToken ct)
{
await validator.ValidateAndThrowAsync(request, ct);
var invoiceNumber = request.InvoiceNumber;
var serialNo = long.Parse(request.SerialNo.Trim());
// 1. an invoice keeps one family of cargo types (38 / 74 / 39+41)
var invoiceCargo = await repository.GetInvoiceCargoTypeAsync(request.Scac, invoiceNumber, ct);
if (invoiceCargo.HasValue && !BillingCalculator.IsCargoAllowedOnInvoice(invoiceCargo.Value, request.CargoType))
throw OrdersErrors.InvoiceCargoMismatch();
// 2. archived invoices take no new billing
var invoiceStatus = await repository.GetInvoiceStatusAsync(request.Scac.ToString(), invoiceNumber.ToString(), ct);
if (string.Equals(invoiceStatus, "ARCHIVED", StringComparison.OrdinalIgnoreCase)) throw OrdersErrors.InvoiceArchived();
// 3. one billing per permit
if (await repository.PnExistsAsync(request.Pn, ct)) throw OrdersErrors.BillingExists();
// page JS rules kept as server checks
if (!BillingCalculator.IsDischargeAfterLoad(request.LoadDate, request.DischargeDate)) throw OrdersErrors.DischargeBeforeLoad();
var lnw = request.Lnw;
var dnw = request.Dnw;
if (dnw <= 0) throw OrdersErrors.ReceivedWeightMissing();
if (!BillingCalculator.IsSentWeightInRange(lnw)) throw OrdersErrors.SentWeightRange();
// 4. PRICE = wage rate of the destination on the loading date, FINEPRICE = fine rate of the cargo type on that
// date; if either is missing the billing cannot be added.
var wage = await repository.GetWageRateAsync(request.Destination, request.LoadDate.Date, ct);
var fine = await repository.GetFineRateAsync(request.CargoType, request.LoadDate.Date, ct);
if (wage is null || fine is null) throw OrdersErrors.PriceNotDefined();
var wageAmount = BillingCalculator.Wage(wage.Wage, lnw);
var loseFine = BillingCalculator.ShortageFine(lnw, dnw, fine.Allowance, fine.Fine);
var finalCost = wageAmount - loseFine;
var companyName = await repository.GetTenderCompanyNameAsync(request.Scac, ct);
var permit = await repository.GetPermitRefAsync(request.Pn, ct) ?? throw OrdersErrors.InvalidPn();
return await unitOfWork.ExecuteInTransactionAsync(async token =>
{
// first billing of the invoice creates it
if (invoiceStatus is null) await repository.InsertInvoiceAsync(invoiceNumber, request.Scac, token);
// a permit that is not CLOSE yet is closed by the system when it is billed
if (!string.Equals(permit.ShipmentStatusCode, "CLOSE", StringComparison.OrdinalIgnoreCase))
{
await repository.ClosePermitAsync(permit.Id, token);
await events.AddAsync(new EventEntry(
"PERMITID", permit.Id, permit.ShipmentStatusCode, "CLOSE", "SYSTEM", "OVRD", "GN", null, "NTP", null,
new Dictionary<string, object?> { ["REMARKS"] = "Billing Close." }), token);
}
var id = await repository.InsertAsync(new NewGrainsBilling(
request.Pn, serialNo, request.Tn.Trim(), request.CargoType, request.Destination,
request.LoadDate.Date, request.DischargeDate.Date, dnw, lnw,
request.Scac, companyName, invoiceNumber, GrainsOrderConstants.BillingOriginId,
wage.Wage, fine.Fine, finalCost, loseFine, user.UserId, request.DemurrageFine, request.OtherFine), token);
return new OrdersResult(OrdersErrors.Success, id);
}, ct);
}
/// <summary>Legacy returned an empty grid when no filter was supplied.</summary>
public async Task<PagedResult<BillingDto>> SearchAsync(BillingQuery query, PageRequest page, CancellationToken ct)
{
if (!query.HasFilter) return new PagedResult<BillingDto>([], page.SafePage, page.SafePageSize, 0);
var r = await repository.SearchAsync(query, page, ct);
var items = r.Items.Select(x => new BillingDto(
x.Id, x.CargoType, x.Scac, x.Pn, x.Tn, Date(x.LoadDate), x.Destination, Date(x.DischargeDate),
x.Lnw, x.Dnw, x.Price, x.FinePrice, x.InvoiceNumber, x.CreateUserId)).ToList();
return new PagedResult<BillingDto>(items, r.Page, r.PageSize, r.TotalCount);
}
/// <summary>Port of getBillingInfoForReroute (rerouteScreen.cfm).</summary>
public async Task<BillingRerouteDto> GetRerouteAsync(long id, CancellationToken ct)
{
var b = await repository.GetDetailAsync(id, ct) ?? throw OrdersErrors.BillingNotFound();
return new BillingRerouteDto(b.Id, b.Pn, b.Tn, b.CompanyName, b.SerialNo, b.CargoType, b.Destination,
Date(b.LoadDate), Date(b.DischargeDate), b.Lnw, b.Dnw, b.Price, b.InvoiceNumber,
b.DemurrageFine, b.OtherFine, b.ReroutePrice, b.RerouteName);
}
/// <summary>Port of addRerouteInfo; the page JS rule: a new price must be at least the current price and at most 35.</summary>
public async Task<OrdersResult> RerouteAsync(long id, RerouteRequest request, CancellationToken ct)
{
var b = await repository.GetDetailAsync(id, ct) ?? throw OrdersErrors.BillingNotFound();
if (request.ReroutePrice.HasValue && (request.ReroutePrice.Value < (b.Price ?? 0) || request.ReroutePrice.Value > 35))
throw OrdersErrors.ReroutePriceRange();
var name = string.IsNullOrWhiteSpace(request.RerouteName) ? null : request.RerouteName.Trim();
if (name is { Length: > 50 }) name = name[..50];
await repository.UpdateRerouteAsync(id, request.ReroutePrice, name, ct);
return new OrdersResult(OrdersErrors.Rerouted, id);
}
/// <summary>Port of deleteInvoice: soft delete; not from an archived invoice; only the entering user unless GNAC.</summary>
public async Task<OrdersResult> DeleteAsync(long id, CancellationToken ct)
{
var b = await repository.GetDetailAsync(id, ct) ?? throw OrdersErrors.BillingNotFound();
if (b.Scac is not null && b.InvoiceNumber is not null
&& string.Equals(await repository.GetInvoiceStatusAsync(b.Scac, b.InvoiceNumber, ct), "ARCHIVED", StringComparison.OrdinalIgnoreCase))
throw OrdersErrors.DeleteFromArchivedInvoice();
if (!user.IsInRole("GNAC") && !string.Equals(b.CreateUserId, user.UserId, StringComparison.OrdinalIgnoreCase))
throw OrdersErrors.DeleteNotOwner(b.CreateUserId);
await repository.MarkDeletedAsync(id, ct);
return new OrdersResult(OrdersErrors.Deleted, id);
}
}
public interface IInvoiceService
{
Task<PagedResult<InvoiceDto>> SearchAsync(long? invoiceNumber, PageRequest page, CancellationToken ct);
Task<OrdersResult> ArchiveAsync(long id, CancellationToken ct);
Task<OrdersResult> ActivateAsync(long id, CancellationToken ct);
}
/// <summary>Port of Invoice.cfc getInvoiceGrid (InvoiceGrid.cfm).</summary>
public sealed class InvoiceService(IInvoiceRepository repository, IUnitOfWork unitOfWork) : IInvoiceService
{
public async Task<PagedResult<InvoiceDto>> SearchAsync(long? invoiceNumber, PageRequest page, CancellationToken ct)
{
var r = await repository.SearchAsync(invoiceNumber, page, ct);
var items = r.Items.Select(x => new InvoiceDto(x.Id, x.InvoiceNumber, x.StatusCode, x.Cnt, x.CompanyName, x.Scac, x.InvoiceDate)).ToList();
return new PagedResult<InvoiceDto>(items, r.Page, r.PageSize, r.TotalCount);
}
public async Task<OrdersResult> ArchiveAsync(long id, CancellationToken ct)
{
if (!await repository.ExistsAsync(id, ct)) throw OrdersErrors.InvoiceNotFound();
return await unitOfWork.ExecuteInTransactionAsync(async token =>
{
await repository.ArchiveAsync(id, token);
return new OrdersResult(OrdersErrors.Archived, id);
}, ct);
}
public async Task<OrdersResult> ActivateAsync(long id, CancellationToken ct)
{
if (!await repository.ExistsAsync(id, ct)) throw OrdersErrors.InvoiceNotFound();
await repository.ActivateAsync(id, ct);
return new OrdersResult(OrdersErrors.Activated, id);
}
}