NTP_V2/src/NTP.Api/Controllers/V1/Grains/RegistryController.cs

304 lines
20 KiB
C#

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.Registry;
namespace NTP.Api.Controllers.V1.Grains;
/// <summary>
/// Grains registry slice: trucks, trailers, drivers, blacklist (+ weighbridge exceptions, location counts, permit-screen lookups).
/// Port of services\Grains\cfc\register.cfc and the registry parts of grains.cfc. Thin controller: authorization of the individual actions
/// (legacy isActAuthorized ids, company scoping) is done in the services.
/// </summary>
[ApiController]
[ApiVersion(1.0)]
[Route("api/v{version:apiVersion}/grains/registry")]
[Produces("application/json")]
public sealed class RegistryController(
ITruckRegistryService trucks,
ITrailerRegistryService trailers,
IDriverRegistryService drivers,
IBlacklistService blacklist,
IRegistryOpsService ops,
IRegistryLookupService lookups,
IRegistryAttachmentService attachments,
IRegistryQueuePermitService queuePermits) : ControllerBase
{
// ------------------------------------------------------------------------------------------ permissions + lookups
/// <summary>What the caller may do on the registry screens (legacy isActAuthorized buttons).</summary>
[HttpGet("permissions")]
public Task<RegistryPermissionsDto> Permissions(CancellationToken ct) => lookups.PermissionsAsync(ct);
/// <summary>NTP_TENDERS_COMPANIES (ACTIVE): the company select of the truck/trailer forms and filters.</summary>
[HttpGet("lookups/companies")]
[RequirePermission(PermissionKeys.RegistryTrucks, PermissionKeys.RegistryTrailers, PermissionKeys.RegistryDrivers, PermissionKeys.RegistryBlacklist)]
public Task<IReadOnlyList<TenderCompanyDto>> Companies(CancellationToken ct) => lookups.CompaniesAsync(ct);
/// <summary>TRUCKKINDS by code (S, T for trucks; HTR, TR for trailers): the axial loads select.</summary>
[HttpGet("lookups/truck-kinds")]
[RequirePermission(PermissionKeys.RegistryTrucks, PermissionKeys.RegistryTrailers)]
public Task<IReadOnlyList<TruckKindDto>> TruckKinds([FromQuery] string kinds, CancellationToken ct) =>
lookups.TruckKindsAsync((kinds ?? string.Empty).Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries), ct);
/// <summary>Destination locations grouped as on the truck form (packed / bulk / bulk-gallab).</summary>
[HttpGet("lookups/destinations")]
[RequirePermission(PermissionKeys.RegistryTrucks)]
public Task<RegistryDestinationOptionsDto> Destinations(CancellationToken ct) => lookups.DestinationsAsync(ct);
[HttpGet("lookups/driver-nationalities")]
[RequirePermission(PermissionKeys.RegistryDrivers)]
public Task<IReadOnlyList<RegistryNationalityDto>> DriverNationalities(CancellationToken ct) => lookups.DriverNationalitiesAsync(ct);
[HttpGet("lookups/weighbridge-locations")]
[RequirePermission(PermissionKeys.RegistryWeighbridge)]
public Task<IReadOnlyList<RegistryLocationDto>> WeighbridgeLocations(CancellationToken ct) => lookups.WeighbridgeLocationsAsync(ct);
// ------------------------------------------------------------------------------------------ trucks (truckGrid.cfm, registerGrainsTruck.cfm)
/// <summary>getTruckGrid. searchType TN (trucks, default) or TRN (searches the trailers table, rows carry tnId).</summary>
[HttpGet("trucks")]
[RequirePermission(PermissionKeys.RegistryTrucks)]
public Task<PagedResult<TruckGridRowDto>> SearchTrucks(
[FromQuery] string? searchType, [FromQuery] string? tn, [FromQuery] string? chasesNumber, [FromQuery] string? statusCode,
[FromQuery] string? headType, [FromQuery] long? tcscac, [FromQuery] int page = 1, [FromQuery] int pageSize = 15, CancellationToken ct = default) =>
trucks.SearchAsync(new TruckListQuery(searchType, tn, chasesNumber, statusCode, headType, tcscac), new PageRequest(page, pageSize), ct);
/// <summary>getTruckInfo (+ connected trailer, destinations, attachments).</summary>
[HttpGet("trucks/{id:long}")]
[RequirePermission(PermissionKeys.RegistryTrucks)]
public Task<TruckDetailDto> GetTruck(long id, CancellationToken ct) => trucks.GetAsync(id, ct);
/// <summary>getAllTrnOnthisTn: trailers connected to the truck.</summary>
[HttpGet("trucks/{id:long}/trailers")]
[RequirePermission(PermissionKeys.RegistryTrucks, PermissionKeys.RegistryTrailers)]
public Task<IReadOnlyList<TrailerGridRowDto>> TrailersOfTruck(long id, CancellationToken ct) => trucks.TrailersAsync(id, null, ct);
/// <summary>saveTrucksDetails.</summary>
[HttpPost("trucks")]
[RequirePermission(PermissionKeys.RegistryTrucksCreate)]
public Task<RegistryResult> CreateTruck(SaveTruckRequest request, CancellationToken ct) => trucks.CreateAsync(request, ct);
/// <summary>editTrucksDetails.</summary>
[HttpPut("trucks/{id:long}")]
[RequirePermission(PermissionKeys.RegistryTrucksEdit)]
public Task<RegistryResult> UpdateTruck(long id, SaveTruckRequest request, CancellationToken ct) => trucks.UpdateAsync(id, request, ct);
/// <summary>acceptTruck (-> ACCPT).</summary>
[HttpPost("trucks/{id:long}/accept")]
[RequirePermission(PermissionKeys.RegistryTrucks)]
public Task<RegistryResult> AcceptTruck(long id, CancellationToken ct) => trucks.AcceptAsync(id, ct);
/// <summary>revokeTruck (-> RVKD, cascades to trailers, destinations and open permits).</summary>
[HttpPost("trucks/{id:long}/revoke")]
[RequirePermission(PermissionKeys.RegistryTrucks)]
public Task<RegistryResult> RevokeTruck(long id, CancellationToken ct) => trucks.RevokeAsync(id, ct);
// ------------------------------------------------------------------------------------------ trailers (trailerGrid.cfm, registerGrainsTrailer.cfm)
[HttpGet("trailers")]
[RequirePermission(PermissionKeys.RegistryTrailers)]
public Task<PagedResult<TrailerGridRowDto>> SearchTrailers(
[FromQuery] string? tn, [FromQuery] string? chasesNumber, [FromQuery] string? statusCode, [FromQuery] long? tcscac,
[FromQuery] int page = 1, [FromQuery] int pageSize = 15, CancellationToken ct = default) =>
trailers.SearchAsync(new TrailerListQuery(tn, chasesNumber, statusCode, tcscac), new PageRequest(page, pageSize), ct);
[HttpGet("trailers/{id:long}")]
[RequirePermission(PermissionKeys.RegistryTrailers)]
public Task<TrailerDetailDto> GetTrailer(long id, CancellationToken ct) => trailers.GetAsync(id, ct);
/// <summary>saveTrailerDetails.</summary>
[HttpPost("trailers")]
[RequirePermission(PermissionKeys.RegistryTrailersCreate)]
public Task<RegistryResult> CreateTrailer(SaveTrailerRequest request, CancellationToken ct) => trailers.CreateAsync(request, ct);
/// <summary>editTrailerDetails.</summary>
[HttpPut("trailers/{id:long}")]
[RequirePermission(PermissionKeys.RegistryTrailersEdit)]
public Task<RegistryResult> UpdateTrailer(long id, SaveTrailerRequest request, CancellationToken ct) => trailers.UpdateAsync(id, request, ct);
[HttpPost("trailers/{id:long}/accept")]
[RequirePermission(PermissionKeys.RegistryTrailers)]
public Task<RegistryResult> AcceptTrailer(long id, CancellationToken ct) => trailers.AcceptAsync(id, ct);
[HttpPost("trailers/{id:long}/revoke")]
[RequirePermission(PermissionKeys.RegistryTrailers)]
public Task<RegistryResult> RevokeTrailer(long id, [FromQuery] long? truckId, CancellationToken ct) => trailers.RevokeAsync(id, truckId, ct);
// ------------------------------------------------------------------------------------------ drivers (driverGrid.cfm, regesterDriver.cfm)
[HttpGet("drivers")]
[RequirePermission(PermissionKeys.RegistryDrivers)]
public Task<PagedResult<DriverGridRowDto>> SearchDrivers(
[FromQuery] string? nnpn, [FromQuery] string? name, [FromQuery] string? statusCode,
[FromQuery] int page = 1, [FromQuery] int pageSize = 15, CancellationToken ct = default) =>
drivers.SearchAsync(new DriverListQuery(nnpn, name, statusCode), new PageRequest(page, pageSize), ct);
[HttpGet("drivers/{id:long}")]
[RequirePermission(PermissionKeys.RegistryDrivers)]
public Task<DriverDetailDto> GetDriver(long id, CancellationToken ct) => drivers.GetAsync(id, ct);
/// <summary>saveDriverDetails.</summary>
[HttpPost("drivers")]
[RequirePermission(PermissionKeys.RegistryDriversCreate)]
public Task<RegistryResult> CreateDriver(SaveDriverRequest request, CancellationToken ct) => drivers.CreateAsync(request, ct);
[HttpPost("drivers/{id:long}/accept")]
[RequirePermission(PermissionKeys.RegistryDrivers)]
public Task<RegistryResult> AcceptDriver(long id, CancellationToken ct) => drivers.AcceptAsync(id, ct);
[HttpPost("drivers/{id:long}/revoke")]
[RequirePermission(PermissionKeys.RegistryDrivers)]
public Task<RegistryResult> RevokeDriver(long id, CancellationToken ct) => drivers.RevokeAsync(id, ct);
// ------------------------------------------------------------------------------------------ blacklist (blackListGrid.cfm, createBlacklist.cfm, confirmDeleteBL.cfm)
/// <summary>getBlackListGrid. entityId = permit number.</summary>
[HttpGet("blacklist")]
[RequirePermission(PermissionKeys.RegistryBlacklist)]
public Task<PagedResult<BlacklistGridRowDto>> SearchBlacklist(
[FromQuery] string? entityId, [FromQuery] string? category, [FromQuery] string? statusCode,
[FromQuery] int page = 1, [FromQuery] int pageSize = 15, CancellationToken ct = default) =>
blacklist.SearchAsync(new BlacklistQuery(entityId, category, statusCode), new PageRequest(page, pageSize), ct);
/// <summary>BL_addToBlacklist.</summary>
[HttpPost("blacklist")]
[RequirePermission(PermissionKeys.RegistryBlacklist)]
public Task<BlacklistAddedDto> AddToBlacklist(AddBlacklistRequest request, CancellationToken ct) => blacklist.AddAsync(request, ct);
/// <summary>deleteFromBlackList (roles GNSU, GNCO, GTO).</summary>
[HttpPost("blacklist/{id:long}/cancel")]
[RequirePermission(PermissionKeys.RegistryBlacklist)]
public Task<RegistryResult> CancelBlacklist(long id, CancelBlacklistRequest request, CancellationToken ct) => blacklist.CancelAsync(id, request, ct);
// ------------------------------------------------------------------------------------------ weighbridge exceptions, weights, counts, fleet
/// <summary>saveWeighbridgesControlInfo (WeighbridgesControl.cfm).</summary>
[HttpPost("weighbridge-control")]
[RequirePermission(PermissionKeys.RegistryWeighbridge)]
public Task<RegistryResult> SaveWeighbridgeControl(SaveWeighbridgeControlRequest request, CancellationToken ct) =>
ops.SaveWeighbridgeControlAsync(request, ct);
/// <summary>saveGrainsWeights.</summary>
[HttpPost("permit-weights")]
[RequirePermission(PermissionKeys.OrdersWeights)]
public Task<RegistryResult> SaveGrainsWeights(SaveGrainsWeightsRequest request, CancellationToken ct) => ops.SaveGrainsWeightsAsync(request, ct);
/// <summary>getlocTruckNum (locTruckNumGrid.cfm, refreshed every 5 minutes by the screen).</summary>
[HttpGet("location-truck-counts")]
[RequirePermission(PermissionKeys.RegistryLocationCounts)]
public Task<IReadOnlyList<LocationTruckCountDto>> LocationTruckCounts(CancellationToken ct) => ops.LocationTruckCountsAsync(ct);
/// <summary>checkTrucks: every company must use its whole fleet before reusing a truck.</summary>
[HttpPost("fleet-check")]
[RequirePermission(PermissionKeys.RegistryTrucks, PermissionKeys.PermitsCreate)]
public Task<FleetCheckResult> FleetCheck(FleetCheckRequest request, CancellationToken ct) => ops.CheckTrucksAsync(request, ct);
/// <summary>validateNtpTrucks.</summary>
[HttpGet("validate-truck")]
[RequirePermission(PermissionKeys.PermitsList, PermissionKeys.PermitsCreate, PermissionKeys.PermitsTruckOrder, PermissionKeys.PermitsClose, PermissionKeys.PermitsManualEntry, PermissionKeys.RegistryTrucks, PermissionKeys.RegistryTrailers, PermissionKeys.RegistryDrivers)]
public async Task<object> ValidateTruck([FromQuery] string tn, CancellationToken ct) => new { validTn = await ops.ValidateNtpTruckAsync(tn ?? string.Empty, ct) };
// ------------------------------------------------------------------------------------------ permit-screen lookups (grains.cfc)
/// <summary>grains.cfc getDriverInfo: latest permit of the driver (active status).</summary>
[HttpGet("permit-lookups/driver")]
[RequirePermission(PermissionKeys.PermitsList, PermissionKeys.PermitsCreate, PermissionKeys.PermitsTruckOrder, PermissionKeys.PermitsClose, PermissionKeys.PermitsManualEntry, PermissionKeys.RegistryTrucks, PermissionKeys.RegistryTrailers, PermissionKeys.RegistryDrivers)]
public Task<DriverFromPermitDto?> DriverFromPermits([FromQuery] string nnpn, CancellationToken ct) => lookups.DriverFromPermitsAsync(nnpn ?? string.Empty, ct);
/// <summary>grains.cfc getTruckInfo: latest finished permit of the truck.</summary>
[HttpGet("permit-lookups/truck")]
[RequirePermission(PermissionKeys.PermitsList, PermissionKeys.PermitsCreate, PermissionKeys.PermitsTruckOrder, PermissionKeys.PermitsClose, PermissionKeys.PermitsManualEntry, PermissionKeys.RegistryTrucks, PermissionKeys.RegistryTrailers, PermissionKeys.RegistryDrivers)]
public Task<TruckFromPermitDto?> TruckFromPermits([FromQuery] string tn, CancellationToken ct) => lookups.TruckFromPermitsAsync(tn ?? string.Empty, ct);
/// <summary>grains.cfc isTrailerInUse.</summary>
[HttpGet("permit-lookups/trailer-in-use")]
[RequirePermission(PermissionKeys.PermitsList, PermissionKeys.PermitsCreate, PermissionKeys.PermitsTruckOrder, PermissionKeys.PermitsClose, PermissionKeys.PermitsManualEntry, PermissionKeys.RegistryTrucks, PermissionKeys.RegistryTrailers, PermissionKeys.RegistryDrivers)]
public Task<IReadOnlyList<TrailerInUseDto>> TrailerInUse([FromQuery] string trn, [FromQuery] long? permitId, CancellationToken ct) =>
lookups.TrailerInUseAsync(trn ?? string.Empty, permitId, ct);
/// <summary>grains.cfc getTruckInfoFromTN.</summary>
[HttpGet("permit-lookups/permit-by-truck")]
[RequirePermission(PermissionKeys.PermitsList, PermissionKeys.PermitsCreate, PermissionKeys.PermitsTruckOrder, PermissionKeys.PermitsClose, PermissionKeys.PermitsManualEntry, PermissionKeys.RegistryTrucks, PermissionKeys.RegistryTrailers, PermissionKeys.RegistryDrivers)]
public Task<PermitByTruckDto?> PermitByTruck([FromQuery] string tn, [FromQuery] string status, CancellationToken ct) =>
lookups.PermitByTruckAsync(tn ?? string.Empty, status ?? string.Empty, ct);
/// <summary>grains.cfc getTrailerNumber: the trailer of a truck.</summary>
[HttpGet("permit-lookups/truck-trailer")]
[RequirePermission(PermissionKeys.PermitsList, PermissionKeys.PermitsCreate, PermissionKeys.PermitsTruckOrder, PermissionKeys.PermitsClose, PermissionKeys.PermitsManualEntry, PermissionKeys.RegistryTrucks, PermissionKeys.RegistryTrailers, PermissionKeys.RegistryDrivers)]
public Task<TrailerOfTruckDto> TruckTrailer([FromQuery] string tn, CancellationToken ct) => lookups.TrailerNumberOfTruckAsync(tn ?? string.Empty, ct);
/// <summary>grains.cfc getTNinfo (validate = ownership + MOT checks).</summary>
[HttpGet("permit-lookups/truck-info")]
[RequirePermission(PermissionKeys.PermitsList, PermissionKeys.PermitsCreate, PermissionKeys.PermitsTruckOrder, PermissionKeys.PermitsClose, PermissionKeys.PermitsManualEntry, PermissionKeys.RegistryTrucks, PermissionKeys.RegistryTrailers, PermissionKeys.RegistryDrivers)]
public Task<TruckInfoForPermitDto> TruckInfo([FromQuery] string tn, [FromQuery] bool validate = true, CancellationToken ct = default) =>
lookups.TruckInfoAsync(tn ?? string.Empty, validate, ct);
/// <summary>grains.cfc getTRNinfo.</summary>
[HttpGet("permit-lookups/trailer-info")]
[RequirePermission(PermissionKeys.PermitsList, PermissionKeys.PermitsCreate, PermissionKeys.PermitsTruckOrder, PermissionKeys.PermitsClose, PermissionKeys.PermitsManualEntry, PermissionKeys.RegistryTrucks, PermissionKeys.RegistryTrailers, PermissionKeys.RegistryDrivers)]
public Task<TrailerInfoForPermitDto> TrailerInfo([FromQuery] string trn, CancellationToken ct) => lookups.TrailerInfoAsync(trn ?? string.Empty, ct);
/// <summary>grains.cfc getDRVRinfo.</summary>
[HttpGet("permit-lookups/driver-info")]
[RequirePermission(PermissionKeys.PermitsList, PermissionKeys.PermitsCreate, PermissionKeys.PermitsTruckOrder, PermissionKeys.PermitsClose, PermissionKeys.PermitsManualEntry, PermissionKeys.RegistryTrucks, PermissionKeys.RegistryTrailers, PermissionKeys.RegistryDrivers)]
public Task<DriverInfoForPermitDto> DriverInfo([FromQuery] string nnpn, CancellationToken ct) => lookups.DriverInfoAsync(nnpn ?? string.Empty, ct);
// ------------------------------------------------------------------------------------------ MOT (register.cfc validate*)
/// <summary>validateTNMOT: result '' (ok), 'not_registered' or 'wrongCT'.</summary>
[HttpGet("mot/truck")]
[RequirePermission(PermissionKeys.RegistryTrucks, PermissionKeys.RegistryTrailers)]
public async Task<object> MotTruck([FromQuery] string tn, [FromQuery] long scac, [FromQuery] string? truckType, CancellationToken ct) =>
new { result = await lookups.ValidateTruckMotAsync(tn ?? string.Empty, scac, truckType, ct) };
/// <summary>validateTRNMOT: result '' (ok) or 'not_registered'.</summary>
[HttpGet("mot/trailer")]
[RequirePermission(PermissionKeys.RegistryTrucks, PermissionKeys.RegistryTrailers)]
public async Task<object> MotTrailer([FromQuery] string trn, [FromQuery] long scac, CancellationToken ct) =>
new { result = await lookups.ValidateTrailerMotAsync(trn ?? string.Empty, scac, ct) };
/// <summary>validateOwnerTN: message '' (ok) or the legacy Arabic error.</summary>
[HttpGet("mot/owner")]
[RequirePermission(PermissionKeys.RegistryTrucks, PermissionKeys.RegistryTrailers)]
public async Task<object> MotOwner([FromQuery] string tn, [FromQuery] long scac, CancellationToken ct) =>
new { message = await lookups.ValidateOwnerAsync(scac, tn ?? string.Empty, ct) };
// ------------------------------------------------------------------------------------------ attachments
/// <summary>Temp upload: returns { id, name, size }; the id goes into attachmentIds of a save request.</summary>
[HttpPost("files/temp")]
[RequestSizeLimit(20_000_000)]
[RequirePermission(PermissionKeys.RegistryTrucks, PermissionKeys.RegistryTrailers, PermissionKeys.RegistryDrivers)]
public async Task<RegistryTempFileDto> UploadTemp(IFormFile file, CancellationToken ct)
{
await using var stream = file.OpenReadStream();
return await attachments.UploadTempAsync(stream, file.FileName, file.Length, ct);
}
/// <summary>Downloads a stored attachment (kind: truck | trailer | driver).</summary>
[HttpGet("files/{kind}/{fileName}")]
[RequirePermission(PermissionKeys.RegistryTrucks, PermissionKeys.RegistryTrailers, PermissionKeys.RegistryDrivers)]
public async Task<IActionResult> Download(string kind, string fileName, CancellationToken ct)
{
var download = await attachments.OpenAsync(kind, fileName, ct);
Response.Headers.ContentDisposition = $"inline; filename*=UTF-8''{Uri.EscapeDataString(download.FileName)}";
return File(download.Content, download.ContentType);
}
// ------------------------------------------------------------------------------------------ scheduled jobs (call from the scheduler with a token)
/// <summary>jobs\changeBlacklistStatus.cfm: OPEN entries past their expiry date become EXPIRED.</summary>
[HttpPost("jobs/expire-blacklist")]
[Authorize(Roles = "SU")]
public async Task<object> ExpireBlacklist(CancellationToken ct) => new { expired = await blacklist.ExpireDueAsync(ct) };
/// <summary>jobs\RegisterGrainsQueueForNewTrucks.cfm: PCKD + BULK queue permits for 327 trucks that have none.</summary>
[HttpPost("jobs/register-queue-new-trucks")]
[Authorize(Roles = "SU")]
public async Task<object> RegisterQueueForNewTrucks(CancellationToken ct) => new { trucks = await queuePermits.RegisterQueueForNewTrucksAsync(ct) };
}