using Asp.Versioning;
using NTP.Api.Authorization;
using NTP.Application.Access;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using NTP.Application.Common;
using NTP.Application.Grains.Permits;
namespace NTP.Api.Controllers.V1.Grains;
///
/// Grain permits (legacy GNPermits.cfm / createGnOrder.cfm / viewPermitDetails.cfm / PhoneAccept.cfm / PhoneReject.cfm / deleteGnOrder.cfm /
/// RevokeGnPermit.cfm / arrivalTruck.cfm / addGrainsWeights.cfm / activeOrInactiveAbsenceFeature.cfm and grains.cfc).
/// Company users (stakeholder 62) only see and change their own permits (enforced in the service).
///
[ApiController]
[ApiVersion(1.0)]
[Route("api/v{version:apiVersion}/grains/permits")]
[Produces("application/json")]
public sealed class PermitsController(IPermitService permits) : ControllerBase
{
// ---- lists
/// getGNPermits: empty until at least one filter is given (legacy behaviour).
[HttpGet]
[RequirePermission(PermissionKeys.PermitsList)]
public Task> Search(
[FromQuery] string? tn, [FromQuery] string? pn, [FromQuery] string? status, [FromQuery] long? destAddressId,
[FromQuery] string? tenderOrder, [FromQuery] string? shipmentMode, [FromQuery] string? creationDate, [FromQuery] long? companyCode,
[FromQuery] int page = 1, [FromQuery] int pageSize = 20, CancellationToken ct = default) =>
permits.SearchAsync(new PermitSearchQuery(tn, pn, status, destAddressId, tenderOrder, shipmentMode, creationDate, companyCode),
new PageRequest(page, pageSize), ct);
/// getGNList (permitsGrid.cfm): gate / clearance list.
[HttpGet("gate")]
[RequirePermission(PermissionKeys.PermitsList, PermissionKeys.PermitsWeighbridge)]
public Task> Gate(
[FromQuery] string? tn, [FromQuery] string? trn, [FromQuery] string? pn,
[FromQuery] int page = 1, [FromQuery] int pageSize = 20, CancellationToken ct = default) =>
permits.SearchGateListAsync(new GatePermitQuery(tn, trn, pn), new PageRequest(page, pageSize), ct);
[HttpGet("{id:long}")]
[RequirePermission(PermissionKeys.PermitsList)]
public Task Get(long id, CancellationToken ct) => permits.GetAsync(id, ct);
[HttpGet("{id:long}/events")]
[RequirePermission(PermissionKeys.PermitsList)]
public Task> Events(long id, CancellationToken ct) => permits.GetEventsAsync(id, ct);
// ---- lookups used by the order form
[HttpGet("lookups/truck/{tn}")]
[RequirePermission(PermissionKeys.PermitsList)]
public Task Truck(string tn, [FromQuery] bool validate = false, CancellationToken ct = default) =>
permits.GetTruckInfoAsync(tn, validate, ct);
[HttpGet("lookups/trailer/{trn}")]
[RequirePermission(PermissionKeys.PermitsList)]
public Task Trailer(string trn, CancellationToken ct) => permits.GetTrailerInfoAsync(trn, ct);
[HttpGet("lookups/driver/{nnpn}")]
[RequirePermission(PermissionKeys.PermitsList)]
public Task Driver(string nnpn, CancellationToken ct) => permits.GetDriverInfoAsync(nnpn, ct);
// ---- order lifecycle (companies and staff)
[HttpPost("{id:long}/submit")]
[RequirePermission(PermissionKeys.PermitsList)]
public Task Submit(long id, SubmitOrderRequest request, CancellationToken ct) => permits.SubmitAsync(id, request, ct);
[HttpPut("{id:long}")]
[RequirePermission(PermissionKeys.PermitsList)]
public Task Update(long id, UpdateOrderRequest request, CancellationToken ct) => permits.UpdateAsync(id, request, ct);
[HttpPost("{id:long}/accept")]
[RequirePermission(PermissionKeys.PermitsList)]
public Task Accept(long id, CancellationToken ct) => permits.AcceptAsync(id, ct);
[HttpPost("{id:long}/revoke")]
[RequirePermission(PermissionKeys.PermitsList)]
public Task Revoke(long id, CancellationToken ct) => permits.RevokeAsync(id, ct);
[HttpPost("{id:long}/revoke-accepted")]
[RequirePermission(PermissionKeys.PermitsList)]
public Task RevokeAccepted(long id, CancellationToken ct) => permits.RevokeAcceptedAsync(id, ct);
// ---- staff operations
[HttpPost("{id:long}/convert-to-resd")]
[RequirePermission(PermissionKeys.PermitsList)]
public Task ConvertToResd(long id, CancellationToken ct) => permits.ConvertToResdAsync(id, ct);
[HttpPost("{id:long}/cancel-order")]
[RequirePermission(PermissionKeys.PermitsList)]
public Task CancelOrder(long id, ReasonRequest request, CancellationToken ct) => permits.CancelOrderAsync(id, request, ct);
[HttpPost("{id:long}/revoke-permit")]
[RequirePermission(PermissionKeys.PermitsList)]
public Task RevokePermit(long id, ReasonRequest request, CancellationToken ct) => permits.RevokePermitAsync(id, request, ct);
[HttpPost("{id:long}/reactivate")]
[RequirePermission(PermissionKeys.PermitsList)]
public Task Reactivate(long id, CancellationToken ct) => permits.ReactivateAsync(id, ct);
/// GrainsFactory(Web).cancelGrainsPermit: RESD back to ACCPT.
[HttpPost("{id:long}/cancel-grains-permit")]
[RequirePermission(PermissionKeys.PermitsList)]
public Task CancelGrainsPermit(long id, CancellationToken ct) => permits.CancelGrainsPermitAsync(id, ct);
/// closePermit / arrivalTruck.cfm.
[HttpPost("close")]
[RequirePermission(PermissionKeys.PermitsClose)]
public Task Close(ClosePermitRequest request, CancellationToken ct) => permits.CloseManualAsync(request, ct);
[HttpPost("{id:long}/phone-accept")]
[RequirePermission(PermissionKeys.PermitsList)]
public Task PhoneAccept(long id, PhoneAcceptRequest request, CancellationToken ct) => permits.PhoneAcceptAsync(id, request, ct);
[HttpPost("{id:long}/phone-reject")]
[RequirePermission(PermissionKeys.PermitsList)]
public Task PhoneReject(long id, PhoneRejectRequest request, CancellationToken ct) => permits.PhoneRejectAsync(id, request, ct);
// ---- stored loading weights (addGrainsWeights.cfm)
[HttpGet("weights/{pn}")]
[RequirePermission(PermissionKeys.OrdersWeights)]
public Task Weights(string pn, CancellationToken ct) => permits.LookupWeightsAsync(pn, ct);
[HttpPut("weights")]
[RequirePermission(PermissionKeys.OrdersWeights)]
public Task SaveWeights(SaveWeightsRequest request, CancellationToken ct) => permits.SaveWeightsAsync(request, ct);
// ---- absence feature switch (activeOrInactiveAbsenceFeature.cfm)
[HttpGet("absence-feature")]
[RequirePermission(PermissionKeys.PermitsAbsence, PermissionKeys.PermitsDistribution)]
public AbsenceFeatureDto AbsenceFeature() => permits.GetAbsenceFeature();
[HttpPost("absence-feature/toggle")]
[RequirePermission(PermissionKeys.PermitsAbsence)]
public Task ToggleAbsenceFeature(CancellationToken ct) => permits.ToggleAbsenceFeatureAsync(ct);
}
/// Turns (legacy CreateQueue.cfm / queueGrid.cfm / createPermit.cfm / dblMovePN.cfm): OPEN permit records and the TCS permit.
[ApiController]
[ApiVersion(1.0)]
[Route("api/v{version:apiVersion}/grains/permit-queue")]
[Produces("application/json")]
public sealed class PermitQueueController(IQueueService queue) : ControllerBase
{
/// getGNQueueList (queueGrid.cfm).
[HttpGet]
[RequirePermission(PermissionKeys.PermitsCreate)]
public Task> List([FromQuery] string? tn, [FromQuery] string? pn,
[FromQuery] int page = 1, [FromQuery] int pageSize = 20, CancellationToken ct = default) =>
queue.ListAsync(new QueueSearchQuery(tn, pn), new PageRequest(page, pageSize), ct);
/// AddToQueue (CreateQueue.cfm).
[HttpPost]
[RequirePermission(PermissionKeys.PermitsCreate)]
public Task Add(AddToQueueRequest request, CancellationToken ct) => queue.AddToQueueAsync(request, ct);
[HttpGet("trailer-of/{tn}")]
[RequirePermission(PermissionKeys.PermitsCreate)]
public async Task> TrailerOf(string tn, CancellationToken ct) => new { trailer = await queue.GetTrailerNumberAsync(tn, ct) };
/// checkTrucks.
[HttpPost("check-trucks")]
[RequirePermission(PermissionKeys.PermitsCreate)]
public Task CheckTrucks([FromQuery] long tn, [FromQuery] long scac, CancellationToken ct) => queue.CheckTrucksAsync(tn, scac, ct);
/// parseGrainsPermits job, on demand: create OPEN permits for the given companies.
[HttpPost("seed")]
[RequirePermission(PermissionKeys.PermitsCreate)]
public Task Seed(SeedPermitsRequest request, CancellationToken ct) => queue.SeedPermitsAsync(request, ct);
// ---- TCS permit form (createPermit.cfm)
[HttpGet("{id:long}/tcs-form")]
[RequirePermission(PermissionKeys.PermitsCreate)]
public Task TcsForm(long id, CancellationToken ct) => queue.GetTcsFormDataAsync(id, ct);
[HttpGet("tcs/routing-templates")]
[RequirePermission(PermissionKeys.PermitsCreate)]
public Task> RoutingTemplates([FromQuery] long origin, [FromQuery] long destination,
[FromQuery] string shipmentMode, [FromQuery] string firms, CancellationToken ct) =>
queue.GetRoutingTemplatesAsync(origin, destination, shipmentMode, firms, ct);
[HttpGet("tcs/origins")]
[RequirePermission(PermissionKeys.PermitsCreate)]
public Task> Origins([FromQuery] long routing, CancellationToken ct) => queue.GetOriginAddressesAsync(routing, ct);
[HttpGet("tcs/ph-routes")]
[RequirePermission(PermissionKeys.PermitsCreate)]
public Task> PhRoutes(CancellationToken ct) => queue.GetPhRoutesAsync(ct);
[HttpGet("tcs/clearing-agent/{can:long}")]
[RequirePermission(PermissionKeys.PermitsCreate)]
public async Task> ClearingAgent(long can, CancellationToken ct) => new { name = await queue.GetClearingAgentNameAsync(can, ct) };
[HttpGet("tcs/fop/{fop}")]
[RequirePermission(PermissionKeys.PermitsCreate)]
public Task Fop(string fop, CancellationToken ct) => queue.GetFopDetailAsync(fop, ct);
[HttpPost("{id:long}/tcs-permit")]
[RequirePermission(PermissionKeys.PermitsCreate)]
public Task CreateTcsPermit(long id, CreateTcsPermitRequest request, CancellationToken ct) =>
queue.CreateTcsPermitAsync(id, request, ct);
}
/// Destinations of permits and companies (legacy assginggdest.cfm / compdest.cfm / ManualInput.cfm / activateOrders.cfm).
[ApiController]
[ApiVersion(1.0)]
[Route("api/v{version:apiVersion}/grains/permit-destinations")]
[Produces("application/json")]
public sealed class PermitDestinationsController(IDestinationService destinations) : ControllerBase
{
[HttpGet("lookups/locations")]
[RequirePermission(PermissionKeys.PermitsList, PermissionKeys.PermitsDestinations, PermissionKeys.PermitsManualEntry, PermissionKeys.PermitsActivation, PermissionKeys.PermitsCreate)]
public Task> Locations(CancellationToken ct) => destinations.GetGrainsLocationsAsync(ct);
/// Destination filter of the permit list (GNPermits.cfm): every GN exit location by name, active or not.
[HttpGet("lookups/filter-destinations")]
[RequirePermission(PermissionKeys.PermitsList)]
public Task> FilterDestinations(CancellationToken ct) => destinations.GetPermitFilterDestinationsAsync(ct);
[HttpGet("lookups/exit-locations")]
[RequirePermission(PermissionKeys.PermitsList, PermissionKeys.PermitsDestinations, PermissionKeys.PermitsManualEntry, PermissionKeys.PermitsActivation, PermissionKeys.PermitsCreate)]
public Task> ExitLocations(CancellationToken ct) => destinations.GetExitLocationsAsync(ct);
[HttpGet("lookups/cargo-types")]
[RequirePermission(PermissionKeys.PermitsList, PermissionKeys.PermitsDestinations, PermissionKeys.PermitsManualEntry, PermissionKeys.PermitsActivation, PermissionKeys.PermitsCreate)]
public Task> CargoTypes(CancellationToken ct) => destinations.GetCargoTypesAsync(ct);
[HttpGet("lookups/location-groups")]
[RequirePermission(PermissionKeys.PermitsDestinations)]
public Task LocationGroups(CancellationToken ct) => destinations.GetLocationGroupsAsync(ct);
[HttpGet("lookups/companies")]
[RequirePermission(PermissionKeys.PermitsList, PermissionKeys.PermitsDestinations, PermissionKeys.PermitsManualEntry, PermissionKeys.PermitsActivation, PermissionKeys.PermitsCreate)]
public Task> Companies(CancellationToken ct) => destinations.GetCompaniesAsync(ct);
[HttpGet("companies/{scac:long}")]
[RequirePermission(PermissionKeys.PermitsDestinations)]
public Task> CompanyDestinations(long scac, CancellationToken ct) => destinations.GetCompanyDestinationsAsync(scac, ct);
[HttpPut("companies/{scac:long}")]
[RequirePermission(PermissionKeys.PermitsDestinations)]
public Task SaveCompanyDestinations(long scac, SaveCompanyDestinationsRequest request, CancellationToken ct) =>
destinations.SaveCompanyDestinationsAsync(scac, request, ct);
/// savegrainsdest (assginggdest.cfm).
[HttpPost("assign-by-pn")]
[RequirePermission(PermissionKeys.PermitsDestinations)]
public Task AssignByPn(AssignByPnRequest request, CancellationToken ct) => destinations.AssignByPnAsync(request, ct);
// ---- manual input (ManualInput.cfm)
[HttpGet("order-dates")]
[RequirePermission(PermissionKeys.PermitsManualEntry, PermissionKeys.PermitsDestinations)]
public Task> OrderDates(CancellationToken ct) => destinations.GetOrderDatesAsync(ct);
[HttpGet("allowed-destinations")]
[RequirePermission(PermissionKeys.PermitsManualEntry, PermissionKeys.PermitsDestinations)]
public Task> AllowedDestinations([FromQuery] string pn, [FromQuery] string orderDate, CancellationToken ct) =>
destinations.GetAllowedDestinationsAsync(pn, orderDate, ct);
[HttpGet("{permitId:long}/allowed-cargo")]
[RequirePermission(PermissionKeys.PermitsManualEntry, PermissionKeys.PermitsDestinations)]
public Task> AllowedCargo(long permitId, CancellationToken ct) => destinations.GetAllowedCargoAsync(permitId, ct);
[HttpGet("orders-for-permit")]
[RequirePermission(PermissionKeys.PermitsManualEntry, PermissionKeys.PermitsDestinations)]
public Task> OrdersForPermit([FromQuery] string pn, [FromQuery] string orderDate, CancellationToken ct) =>
destinations.GetOrdersForPermitAsync(pn, orderDate, ct);
[HttpPost("manual-input")]
[RequirePermission(PermissionKeys.PermitsManualEntry)]
public Task ManualInput(ManualInputRequest request, CancellationToken ct) => destinations.ManualInputAsync(request, ct);
/// searchDestination (WeightBridge.cfm): the truck's destination, assigning one when needed.
[HttpGet("search/{tn}")]
[RequirePermission(PermissionKeys.PermitsWeighbridge)]
public Task Search(string tn, CancellationToken ct) => destinations.SearchDestinationAsync(tn, ct);
// ---- activation of today's orders (activateOrders.cfm)
[HttpGet("activation")]
[RequirePermission(PermissionKeys.PermitsActivation)]
public Task> Activation(CancellationToken ct) => destinations.GetActivationAsync(ct);
[HttpPost("activation")]
[RequirePermission(PermissionKeys.PermitsActivation)]
public Task Activate(ActivateOrdersRequest request, CancellationToken ct) => destinations.ActivateOrdersAsync(request, ct);
/// activateGrainsDestination job, on demand.
[HttpPost("jobs/activate-company-destinations")]
[Authorize(Roles = "SU")]
public async Task> ActivatePending(CancellationToken ct) => new { activated = await destinations.ActivatePendingCompanyDestinationsAsync(ct) };
}
/// Distribution of OPEN permits (legacy distributedOrder.cfm / distributionDetails.cfm / distributeSingelTruck.cfm / processOpenPermit.cfm ...).
[ApiController]
[ApiVersion(1.0)]
[Route("api/v{version:apiVersion}/grains/permit-distribution")]
[Produces("application/json")]
public sealed class PermitDistributionController(IDistributionService distribution) : ControllerBase
{
[HttpPost("distribute")]
[RequirePermission(PermissionKeys.PermitsDistribution)]
public Task Distribute(DistributeRequest request, CancellationToken ct) => distribution.DistributeAsync(request, ct);
[HttpPost("release")]
[RequirePermission(PermissionKeys.PermitsDistribution)]
public Task Release(ReleasePermitRequest request, CancellationToken ct) => distribution.ReleaseAsync(request, ct);
[HttpPost("process-open")]
[RequirePermission(PermissionKeys.PermitsTruckOrder)]
public Task ProcessOpen(OpenPermitRequest request, CancellationToken ct) => distribution.ProcessOpenPermitAsync(request, ct);
[HttpPost("process-open-with-destination")]
[RequirePermission(PermissionKeys.PermitsTruckOrder)]
public Task ProcessOpenWithDestination(OpenPermitWithDestinationRequest request, CancellationToken ct) =>
distribution.ProcessOpenPermitWithDestinationAsync(request, ct);
[HttpPost("process-company-open")]
[RequirePermission(PermissionKeys.PermitsTruckOrder)]
public Task ProcessCompanyOpen(CompanyOpenPermitsRequest request, CancellationToken ct) =>
distribution.ProcessCompanyOpenPermitsAsync(request, ct);
[HttpPost("single-truck")]
[RequirePermission(PermissionKeys.PermitsTruckOrder)]
public Task SingleTruck([FromQuery] string tn, CancellationToken ct) => distribution.DistributeSingleTruckAsync(tn, ct);
[HttpGet("summary")]
[RequirePermission(PermissionKeys.PermitsDistribution)]
public Task> Summary(CancellationToken ct) => distribution.GetSummaryAsync(ct);
[HttpGet("pivot")]
[RequirePermission(PermissionKeys.PermitsDistribution, PermissionKeys.OrdersSupply)]
public Task> Pivot(CancellationToken ct) => distribution.GetPivotAsync(ct);
[HttpGet("search-truck")]
[RequirePermission(PermissionKeys.PermitsTruckStatus)]
public Task SearchTruck([FromQuery] string tn, CancellationToken ct) => distribution.SearchTruckAsync(tn, ct);
[HttpGet("blacklisted")]
[RequirePermission(PermissionKeys.PermitsTruckStatus, PermissionKeys.PermitsDistribution)]
public Task> Blacklisted([FromQuery] string tn, CancellationToken ct) => distribution.GetBlacklistedAsync(tn, ct);
[HttpPost("check-trips")]
[RequirePermission(PermissionKeys.PermitsDistribution)]
public Task CheckTrips(CheckTripsRequest request, CancellationToken ct) => distribution.CheckTripsAsync(request, ct);
/// RevokeAllREQST.cfm: send every REQST / PLND permit of an order id below the given limit back to OPEN.
[HttpPost("revoke-all-requested")]
[Authorize(Roles = "SU")]
public Task RevokeAllRequested([FromQuery] long scrnBelow, CancellationToken ct) => distribution.RevokeAllRequestedAsync(scrnBelow, ct);
/// checkForGabanEvents job, on demand.
[HttpPost("jobs/revert-unloaded")]
[Authorize(Roles = "SU")]
public async Task> RevertUnloaded(CancellationToken ct) => new { reverted = await distribution.RevertUnloadedPermitsAsync("SYSTEM", ct) };
// ---- auto call (GrainsFactoryWeb.autoCallService2 / callAPI)
[HttpPost("auto-call/send")]
[RequirePermission(PermissionKeys.PermitsDistribution)]
public Task SendAutoCall(AutoCallRequest request, CancellationToken ct) => distribution.SendAutoCallFileAsync(request, ct);
[HttpPost("auto-call/ivr")]
[RequirePermission(PermissionKeys.PermitsDistribution)]
public Task TriggerIvr(CancellationToken ct) => distribution.TriggerIvrAsync(ct);
}
/// autoCallResponse.cfc: the dialer's callback. Authenticated with the X-Api-Key header (Grains:Permits:AutoCall:ApiKey), not a JWT.
[ApiController]
[ApiVersion(1.0)]
[Route("api/v{version:apiVersion}/grains/permit-autocall")]
[Produces("application/json")]
public sealed class PermitAutoCallController(IDistributionService distribution) : ControllerBase
{
[HttpPost("callback")]
[AllowAnonymous]
public async Task Callback(AutoCallResponse body, [FromHeader(Name = "X-Api-Key")] string? apiKey, CancellationToken ct)
{
if (!distribution.IsValidDialerApiKey(apiKey)) return Unauthorized();
var r = await distribution.HandleDialerCallbackAsync(body, ct);
return Ok(new { code = r.Code, msg = r.Message });
}
}
/// Weighbridges and print pages (legacy WeightBridge.cfm / EN_WeightBridge.cfm / EX_WeightBridge.cfm / loadingWeightBridge.cfm / printIn / printOut / acceptPrint).
[ApiController]
[ApiVersion(1.0)]
[Route("api/v{version:apiVersion}/grains/permit-weighbridge")]
[Produces("application/json")]
public sealed class PermitWeighbridgeController(IWeighbridgeService weighbridge) : ControllerBase
{
[HttpPost("enter")]
[RequirePermission(PermissionKeys.PermitsWeighbridge)]
public Task Enter(WeighbridgeReadingRequest request, CancellationToken ct) => weighbridge.EnterAsync(request, ct);
[HttpPost("exit")]
[RequirePermission(PermissionKeys.PermitsWeighbridge)]
public Task Exit(WeighbridgeReadingRequest request, CancellationToken ct) => weighbridge.ExitAsync(request, ct);
[HttpPost("manual")]
[RequirePermission(PermissionKeys.PermitsWeighbridge)]
public Task Manual(ManualWeighbridgeRequest request, CancellationToken ct) => weighbridge.ManualAsync(request, ct);
[HttpPost("loading-weights")]
[RequirePermission(PermissionKeys.PermitsWeighbridge)]
public Task Loading(WeighbridgeWeightsRequest request, CancellationToken ct) => weighbridge.LoadingWeightsAsync(request, ct);
[HttpPost("discharge-weights")]
[RequirePermission(PermissionKeys.PermitsWeighbridge)]
public Task Discharge(WeighbridgeWeightsRequest request, CancellationToken ct) => weighbridge.DischargeWeightsAsync(request, ct);
/// getTruckInfoFromTN.
[HttpGet("truck/{tn}")]
[RequirePermission(PermissionKeys.PermitsWeighbridge, PermissionKeys.PermitsClose)]
public Task Truck(string tn, [FromQuery] string status, CancellationToken ct) => weighbridge.GetTruckPermitAsync(tn, status, ct);
[HttpGet("truck/{tn}/weight")]
[RequirePermission(PermissionKeys.PermitsWeighbridge, PermissionKeys.PermitsClose)]
public Task TruckWeight(string tn, CancellationToken ct) => weighbridge.GetTruckWaybridgeEventAsync(tn, ct);
/// getlocTruckNum (locTruckNumGrid.cfm).
[HttpGet("location-truck-counts")]
[RequirePermission(PermissionKeys.PermitsWeighbridge)]
public Task> LocationCounts(CancellationToken ct) => weighbridge.GetLocationTruckCountsAsync(ct);
// ---- print data
[HttpGet("{permitId:long}/print/accept")]
[RequirePermission(PermissionKeys.PermitsList, PermissionKeys.PermitsWeighbridge)]
public Task AcceptPrint(long permitId, CancellationToken ct) => weighbridge.GetAcceptPrintAsync(permitId, ct);
[HttpGet("{permitId:long}/print/in")]
[RequirePermission(PermissionKeys.PermitsList, PermissionKeys.PermitsWeighbridge)]
public Task PrintIn(long permitId, CancellationToken ct) => weighbridge.GetPrintInAsync(permitId, ct);
[HttpGet("{permitId:long}/print/out")]
[RequirePermission(PermissionKeys.PermitsList, PermissionKeys.PermitsWeighbridge)]
public Task PrintOut(long permitId, CancellationToken ct) => weighbridge.GetPrintOutAsync(permitId, ct);
[HttpGet("{permitId:long}/print/details")]
[RequirePermission(PermissionKeys.PermitsList, PermissionKeys.PermitsWeighbridge)]
public Task Details(long permitId, CancellationToken ct) => weighbridge.GetPermitDetailsAsync(permitId, ct);
// ---- jobs on demand
[HttpPost("jobs/sync")]
[Authorize(Roles = "SU")]
public async Task> Sync([FromQuery] bool aqaba, CancellationToken ct) => new { processed = await weighbridge.SyncAsync(aqaba, ct) };
}