NTP_V2/src/NTP.Application/Refinery/Trips/TripActionService.cs

323 lines
18 KiB
C#

using System.Globalization;
using NTP.Application.Abstractions;
using NTP.Application.Common;
using NTP.Application.Refinery.Integrations;
using NTP.Application.Refinery.RemainingBalance;
namespace NTP.Application.Refinery.Trips;
public interface ITripActionService
{
Task<TripsResult> FirstAdvanceAsync(long id, CancellationToken ct);
Task<TripsResult> SecondAdvanceAsync(long id, CancellationToken ct);
Task<TripsResult> FirstAdvanceReverseAsync(long id, CancellationToken ct);
Task<TripsResult> SecondAdvanceReverseAsync(long id, CancellationToken ct);
Task<TripsResult> ExchangeAsync(long id, CancellationToken ct);
Task<TripsResult> ExchangeAuditAsync(long id, CancellationToken ct);
Task<TripsResult> ReceiptAsync(long id, CancellationToken ct);
Task<TripsResult> PaymentAsync(long id, CancellationToken ct);
Task<TripsResult> ActivateWalletExchangeAsync(long id, CancellationToken ct);
Task<TripsResult> OrangePaymentAsync(long id, CancellationToken ct);
Task<TripsResult> CashPaymentAsync(long id, CancellationToken ct);
Task<TripsResult> ConfirmExchangeAsync(long id, CancellationToken ct);
Task<TripVoucherDto> PrintAsync(long id, CancellationToken ct);
}
/// <summary>
/// Port of the actions of refinerytripFactory.cfc (diesel card advances and their reversals, receipt / payment / exchange of the wage,
/// audit, cash and Orange payments, confirm / activate wallet exchange, print of the cash voucher).
/// Role-specific branches of the legacy code are gone: the permission key of each endpoint decides who may act. The status rules the
/// legacy STATUS_ACTION_MATRIX enforced per action are kept (WrongStatus = legacy ERROR.NO_AUTHORITY). Mobile push notifications of the
/// legacy actions are not sent.
/// </summary>
public sealed class TripActionService(
ITripRepository trips,
ITripAmountsService amountsService,
IRemainingBalanceService balances,
IDinarakGateway dinarak,
IDinarakReferenceGateway dinarakReference,
IVoucherSerialRepository voucherSerial,
IUnitOfWork uow,
ICurrentUser user,
ITripSettingsService settings) : ITripActionService
{
private string UserId => user.Id.ToString(CultureInfo.InvariantCulture);
private static TripsResult Ok(long id) => new(TripErrors.Ok, id);
// ------------------------------------------------------------------ helpers
private async Task<TripRecord> LoadAsync(long id, CancellationToken ct) =>
await trips.GetAsync(id, ct) ?? throw new NotFoundException("RefineryTrip", id);
/// <summary>Locks the trip row (inside the transaction) and reads it again, so two operators cannot act on the same trip together.</summary>
private async Task<TripRecord> LockAndLoadAsync(long id, CancellationToken ct)
{
if (await trips.LockAsync(id, ct) is null) throw new NotFoundException("RefineryTrip", id);
return await LoadAsync(id, ct);
}
private static (bool Exists, object? Value) OldValue(TripRecord t, string key) => key switch
{
"STATUS_CODE" => (true, t.StatusCode),
"REMARKS" => (true, t.Remarks ?? string.Empty),
"CURRENT_BALANCE" => (true, t.CurrentBalance),
"DINARAK_REFERENCE_ID" => (true, t.DinarakReferenceId),
_ => (false, null)
};
/// <summary>REFINERY_TRIPS_LOG row like legacy logs.saveLog (nothing when no argument changed).</summary>
private async Task LogAsync(string method, TripRecord old, IReadOnlyDictionary<string, object?> args, CancellationToken ct)
{
var built = TripLogBuilder.Build(method, k => OldValue(old, k), args);
if (built is { } b) await trips.InsertLogAsync(old.Id, method, UserId, b.OldJson, b.NewJson, ct);
}
private static void EnsureStatus(TripRecord t, params string[] allowed)
{
if (t.StatusCode is null || !allowed.Contains(t.StatusCode)) throw TripErrors.WrongStatus();
}
private static string RequireTn(TripRecord t) => t.Tn ?? throw TripErrors.CardNotFound();
// ------------------------------------------------------------------ diesel card advances
// refinerytripfactory.cfc:215-279 + dao FIRST_ADVANCED_PAYMENT
public Task<TripsResult> FirstAdvanceAsync(long id, CancellationToken ct) => uow.ExecuteInTransactionAsync(async c =>
{
var t = await LockAndLoadAsync(id, c);
if (t.DieselCharge != 0) throw TripErrors.FirstAdvanceExists();
var card = await trips.GetActiveCardAsync(RequireTn(t), c) ?? throw TripErrors.CardNotFound();
var calc = await trips.CalculateDieselAsync(id, c) ?? throw TripErrors.PriceNotDeclared();
await trips.InsertCardLogAsync(card.Id, "FIRST_ADVANCED_PAYMENT", card.CurrentBalance, calc, calc - card.CurrentBalance, UserId, t.Pn ?? string.Empty, c);
await trips.MarkFirstAdvanceAsync(id, UserId, c);
await trips.UpdateCardBalanceAsync(card.Id, calc, UserId, id, c);
await LogAsync("FIRST_ADVANCED_PAYMENT", t, new Dictionary<string, object?> { ["CURRENT_BALANCE"] = calc }, c);
return Ok(id);
}, ct);
// refinerytripfactory.cfc:285-351 + dao SECOND_ADVANCED_PAYMENT
public Task<TripsResult> SecondAdvanceAsync(long id, CancellationToken ct) => uow.ExecuteInTransactionAsync(async c =>
{
var t = await LockAndLoadAsync(id, c);
if (t.DieselCharge != 1) throw TripErrors.SecondAdvanceExists();
var calc = await trips.CalculateDieselAsync(id, c) ?? throw TripErrors.WrongLoadingDate();
var card = await trips.GetActiveCardAsync(RequireTn(t), c) ?? throw TripErrors.CardNotFound();
await trips.InsertCardLogAsync(card.Id, "SECOND_ADVANCED_PAYMENT", card.CurrentBalance, calc, calc - card.CurrentBalance, UserId, t.Pn ?? string.Empty, c);
await trips.MarkSecondAdvanceAsync(id, UserId, calc, c);
await trips.UpdateCardBalanceAsync(card.Id, calc, UserId, id, c);
await LogAsync("SECOND_ADVANCED_PAYMENT", t, new Dictionary<string, object?> { ["CURRENT_BALANCE"] = calc }, c);
return Ok(id);
}, ct);
// refinerytripfactory.cfc:358-412 + dao FIRST_ADVANCED_PAYMENT_REVERSE
public Task<TripsResult> FirstAdvanceReverseAsync(long id, CancellationToken ct) => uow.ExecuteInTransactionAsync(async c =>
{
var t = await LockAndLoadAsync(id, c);
if (t.DieselCharge == 0) throw TripErrors.FirstAdvanceReverseExists();
if (t.DieselCharge != 1) throw TripErrors.CannotReverseAdvance();
await ReverseAsync(t, "FIRST_ADVANCED_PAYMENT", "FIRST_ADVANCED_PAYMENT_REVERSE", 0, c);
return Ok(id);
}, ct);
// refinerytripfactory.cfc:418-477 + dao SECOND_ADVANCED_PAYMENT_REVERSE
public Task<TripsResult> SecondAdvanceReverseAsync(long id, CancellationToken ct) => uow.ExecuteInTransactionAsync(async c =>
{
var t = await LockAndLoadAsync(id, c);
if (t.DieselCharge == 1) throw TripErrors.SecondAdvanceExists();
if (t.DieselCharge != 2) throw TripErrors.CannotReverseAdvance();
if (await trips.CalculateDieselAsync(id, c) is null) throw TripErrors.WrongLoadingDate();
await ReverseAsync(t, "SECOND_ADVANCED_PAYMENT", "SECOND_ADVANCED_PAYMENT_REVERSE", 1, c);
return Ok(id);
}, ct);
/// <summary>Takes back the amount of the last card log row of the advance: card balance - amount, a negative log row, the trip goes back one step.</summary>
private async Task ReverseAsync(TripRecord t, string advanceMethod, string reverseMethod, int newDieselCharge, CancellationToken c)
{
var card = await trips.GetActiveCardAsync(RequireTn(t), c) ?? throw TripErrors.CardNotFound();
var previous = await trips.GetLastCardLogAmountAsync(t.Pn ?? string.Empty, advanceMethod, c) ?? throw TripErrors.CannotReverseAdvance();
var balance = card.CurrentBalance - previous;
await trips.MarkAdvanceReversedAsync(t.Id, UserId, newDieselCharge, c);
await trips.InsertCardLogAsync(card.Id, reverseMethod, card.CurrentBalance, balance, -previous, UserId, t.Pn ?? string.Empty, c);
await trips.UpdateCardBalanceAsync(card.Id, balance, UserId, t.Id, c);
await LogAsync(reverseMethod, t, new Dictionary<string, object?> { ["CURRENT_BALANCE"] = balance }, c);
}
// ------------------------------------------------------------------ wage payment
// refinerytripfactory.cfc:494-595 (e-wallet through Dinarak)
public async Task<TripsResult> ExchangeAsync(long id, CancellationToken ct)
{
var t = await LoadAsync(id, ct);
EnsureStatus(t, TripStatus.Discharged, TripStatus.PendingExchange);
var amounts = await amountsService.ComputeAsync(t, ct);
TripPaymentRules.EnsurePayable(amounts.NetWage, settings.Value.MaxPaymentAmount);
var wallet = await trips.GetActiveWalletByTruckAsync(RequireTn(t), ct);
TripPaymentRules.EnsureWalletReady(wallet is not null, wallet?.Epayment, wallet?.WalletNumber, wallet?.OwnerNnpn?.ToString(CultureInfo.InvariantCulture), wallet?.OwnerName);
// the legacy action stored the figures before it called Dinarak (and they stay when the call fails)
await trips.SaveAmountsAsync(id, UserId, amounts, ct);
// outside any transaction on purpose: the Dinarak log rows must survive a failed payment (legacy kept them too)
var res = await dinarak.TransferAsync(id, wallet!.WalletNumber!, wallet.OwnerNnpn!.Value.ToString(CultureInfo.InvariantCulture),
amounts.NetWage, wallet.OwnerName!, ct);
if (!res.Success)
{
await LogAsync("EXCHANGE", t, new Dictionary<string, object?> { ["REMARKS"] = res.Message }, ct);
if (res.Code == "106") throw new BusinessException("DINARAK_DISABLED", "خدمة دينارك غير مفعلة في الإعدادات");
throw TripErrors.DinarakRefused(res.Message);
}
return await uow.ExecuteInTransactionAsync(async c =>
{
// the money is already sent: record it whatever the status became meanwhile
await trips.MarkExchangedAsync(id, UserId, "SUCCESSFULL_EXCHANGE_OPERATION", null, true, wallet.Id, c);
await balances.ResetAfterPaymentAsync(RequireTn(t), id, c);
await LogAsync("EXCHANGE", t, new Dictionary<string, object?>
{
["STATUS_CODE"] = TripStatus.Exchanged, ["REMARKS"] = "SUCCESSFULL_EXCHANGE_OPERATION"
}, c);
return Ok(id);
}, ct);
}
// refinerytripfactory.cfc:598-648
public async Task<TripsResult> ReceiptAsync(long id, CancellationToken ct)
{
var first = await LoadAsync(id, ct);
var wallet = await trips.GetActiveWalletByTruckAsync(RequireTn(first), ct);
if (wallet is null) throw TripErrors.NoPaymentMethod();
if (wallet.Epayment == 1) throw TripErrors.ReloadForm();
EnsureStatus(first, TripStatus.Discharged);
return await uow.ExecuteInTransactionAsync(async c =>
{
var t = await LockAndLoadAsync(id, c);
EnsureStatus(t, TripStatus.Discharged);
var amounts = await amountsService.ComputeAsync(t, c);
if (amounts.NetWage == 0) throw TripErrors.PriceNotDeclared();
await trips.SetStatusReceivedAsync(id, UserId, TripStatus.ReadyToPay, c);
await trips.SaveAmountsAsync(id, UserId, amounts, c);
await LogAsync("RECEIPT", t, new Dictionary<string, object?> { ["STATUS_CODE"] = TripStatus.ReadyToPay }, c);
return Ok(id);
}, ct);
}
// refinerytripfactory.cfc:701-734
public Task<TripsResult> ExchangeAuditAsync(long id, CancellationToken ct) => uow.ExecuteInTransactionAsync(async c =>
{
var t = await LockAndLoadAsync(id, c);
EnsureStatus(t, TripStatus.Discharged);
var amounts = await amountsService.ComputeAsync(t, c);
if (amounts.NetWage == 0) throw TripErrors.PriceNotDeclared();
await trips.SetStatusReceivedAsync(id, UserId, TripStatus.PendingExchange, c);
await trips.SaveAmountsAsync(id, UserId, amounts, c);
await LogAsync("EXCHANGE_AUDIT", t, new Dictionary<string, object?> { ["STATUS_CODE"] = TripStatus.PendingExchange }, c);
return Ok(id);
}, ct);
// refinerytripfactory.cfc:651-698 (bank transfer paid by the accountant)
public Task<TripsResult> PaymentAsync(long id, CancellationToken ct) => uow.ExecuteInTransactionAsync(async c =>
{
var t = await LockAndLoadAsync(id, c);
EnsureStatus(t, TripStatus.ReadyToPay);
var wallet = await trips.GetActiveWalletByTruckAsync(RequireTn(t), c) ?? throw TripErrors.NoPaymentMethod();
var amounts = await amountsService.ComputeAsync(t, c);
TripPaymentRules.EnsurePayable(amounts.NetWage, settings.Value.MaxPaymentAmount);
await trips.MarkExchangedAsync(id, UserId, null, null, false, wallet.Id, c);
await trips.SaveAmountsAsync(id, UserId, amounts, c);
await balances.ResetAfterPaymentAsync(RequireTn(t), id, c);
await LogAsync("PAYMENT", t, new Dictionary<string, object?> { ["STATUS_CODE"] = TripStatus.Exchanged }, c);
return Ok(id);
}, ct);
// refinerytripfactory.cfc:991-1085
public Task<TripsResult> CashPaymentAsync(long id, CancellationToken ct) => WalletPaymentAsync(id, "CACH_PAYMENT", resetBalance: true, checkSign: true, ct);
// refinerytripfactory.cfc:885-965 (no legacy screen can reach it: there is no STATUS_ACTION_MATRIX row; no sign / size check, no balance reset)
public Task<TripsResult> OrangePaymentAsync(long id, CancellationToken ct) => WalletPaymentAsync(id, "ORANGE_PAYMENT", resetBalance: false, checkSign: false, ct);
private Task<TripsResult> WalletPaymentAsync(long id, string method, bool resetBalance, bool checkSign, CancellationToken ct) =>
uow.ExecuteInTransactionAsync(async c =>
{
var t = await LockAndLoadAsync(id, c);
var amounts = await amountsService.ComputeAsync(t, c);
TripPaymentRules.EnsurePayable(amounts.NetWage, settings.Value.MaxPaymentAmount, checkSign);
EnsureStatus(t, TripStatus.Discharged);
var wallet = await trips.GetActiveWalletByTruckAsync(RequireTn(t), c);
TripPaymentRules.EnsureWalletReady(wallet is not null, wallet?.Epayment, wallet?.WalletNumber, wallet?.OwnerNnpn?.ToString(CultureInfo.InvariantCulture), wallet?.OwnerName);
await trips.SaveAmountsAsync(id, UserId, amounts, c);
await trips.MarkExchangedAsync(id, UserId, "SUCCESSFULL_EXCHANGE_OPERATION", method, true, wallet!.Id, c);
if (resetBalance) await balances.ResetAfterPaymentAsync(RequireTn(t), id, c);
await LogAsync(method, t, new Dictionary<string, object?>
{
["STATUS_CODE"] = TripStatus.Exchanged, ["REMARKS"] = "SUCCESSFULL_EXCHANGE_OPERATION"
}, c);
return Ok(id);
}, ct);
// refinerytripfactory.cfc:737-781: asks Dinarak first whether the transfer already went through, then moves the message id by 0.01
public async Task<TripsResult> ActivateWalletExchangeAsync(long id, CancellationToken ct)
{
var t = await LoadAsync(id, ct);
EnsureStatus(t, TripStatus.PendingExchange, TripStatus.Discharged);
if (t.DinarakReferenceId is { } reference)
{
var status = await dinarakReference.GetTransferByReferenceAsync(reference, ct);
if (status.StatusName == "ERROR") throw TripErrors.DinarakStatusUnknown();
if (status.Accepted) throw TripErrors.PaymentAlreadySent();
}
return await uow.ExecuteInTransactionAsync(async c =>
{
var locked = await LockAndLoadAsync(id, c);
var next = await trips.BumpDinarakReferenceAsync(id, UserId, c);
await LogAsync("ACTIVATE_WALLET_EXCHANGE", locked, new Dictionary<string, object?> { ["DINARAK_REFERENCE_ID"] = next }, c);
return Ok(id);
}, ct);
}
// refinerytripfactory.cfc:967-984 + dao CONFIRM_EXCHANGE
public async Task<TripsResult> ConfirmExchangeAsync(long id, CancellationToken ct)
{
var t = await LoadAsync(id, ct);
EnsureStatus(t, TripStatus.Discharged, TripStatus.PendingExchange);
if (!await trips.HasTransferLogAsync(id, ct)) throw TripErrors.NoFailedTransfer();
return await uow.ExecuteInTransactionAsync(async c =>
{
await LockAndLoadAsync(id, c);
await trips.ConfirmExchangeAsync(id, UserId, c);
// not in the legacy action (it left the truck balance applied twice); the trip was paid, so the balance is consumed
await balances.ResetAfterPaymentAsync(RequireTn(t), id, c);
await LogAsync("CONFIRM_EXCHANGE", t, new Dictionary<string, object?> { ["STATUS_CODE"] = TripStatus.Exchanged }, c);
return Ok(id);
}, ct);
}
// refinerytripfactory.cfc:1112-1243: voucher serial stored on first print, amount from CalculateRefinaryAmount
public Task<TripVoucherDto> PrintAsync(long id, CancellationToken ct) => uow.ExecuteInTransactionAsync(async c =>
{
var t = await LoadAsync(id, c);
EnsureStatus(t, TripStatus.Discharged);
long serial;
if (t.VoucherSerialNumber is { } existing) serial = existing;
else
{
serial = await voucherSerial.NextAsync(c);
await trips.SetVoucherSerialAsync(id, serial, c);
}
var amount = await trips.CalculateAmountAsync(id, c) ?? throw TripErrors.PriceNotDeclared();
await LogAsync("PRINT", t, new Dictionary<string, object?> { ["NOTES"] = string.Empty }, c);
return new TripVoucherDto(id, t.Pn ?? string.Empty, serial.ToString(CultureInfo.InvariantCulture),
DateTime.Now.ToString("dd/MM/yyyy", CultureInfo.InvariantCulture), amount, t.DischargeAuthNo, t.OwnerName);
}, ct);
}