@rytass/wms-module-core 0.10.1 → 0.11.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/docs/api-reference.md +2 -2
- package/index.cjs.js +887 -70
- package/index.d.ts +1 -0
- package/lib/services/inventory-count-order.service.d.ts +9 -0
- package/lib/services/receive-inventory-order.service.d.ts +0 -6
- package/lib/services/ship-inventory-order.service.d.ts +0 -6
- package/lib/services/stock.service.d.ts +27 -3
- package/lib/services/warehouse-map.service.d.ts +39 -1
- package/lib/typings/consumption-order.input.d.ts +15 -0
- package/lib/typings/find-change-log.input.d.ts +28 -0
- package/lib/typings/find-inventory-count-order.input.d.ts +42 -0
- package/lib/typings/find-loader.input.d.ts +34 -0
- package/lib/typings/find-location.input.d.ts +13 -0
- package/lib/typings/find-material.input.d.ts +16 -0
- package/lib/typings/find-receive-inventory-order.input.d.ts +20 -0
- package/lib/typings/find-ship-inventory-order.input.d.ts +20 -0
- package/lib/typings/find-stock-sort.input.d.ts +52 -0
- package/lib/typings/find-transfer-order.input.d.ts +16 -0
- package/lib/typings/index.d.ts +4 -0
- package/lib/typings/list-sort.d.ts +17 -0
- package/lib/utils/list-sort.d.ts +78 -0
- package/package.json +1 -1
package/index.cjs.js
CHANGED
|
@@ -587,6 +587,53 @@ exports.SequenceEntityClass = tslib.__decorate([
|
|
|
587
587
|
|
|
588
588
|
const WMS_CORE_MODULE_OPTIONS = Symbol('WMS_CORE_MODULE_OPTIONS');
|
|
589
589
|
|
|
590
|
+
/**
|
|
591
|
+
* Columns `LoaderService.findManyLoaders` can sort by. Values are part of the
|
|
592
|
+
* public GraphQL schema (`LoaderSortField`): add freely, never rename or remove.
|
|
593
|
+
*/
|
|
594
|
+
exports.LoaderSortField = void 0;
|
|
595
|
+
(function (LoaderSortField) {
|
|
596
|
+
LoaderSortField["SERIAL_ID"] = "SERIAL_ID";
|
|
597
|
+
/** The loader type's `description`. */
|
|
598
|
+
LoaderSortField["TYPE_DESCRIPTION"] = "TYPE_DESCRIPTION";
|
|
599
|
+
/** The location's `key`. */
|
|
600
|
+
LoaderSortField["LOCATION_KEY"] = "LOCATION_KEY";
|
|
601
|
+
LoaderSortField["LENGTH"] = "LENGTH";
|
|
602
|
+
LoaderSortField["WIDTH"] = "WIDTH";
|
|
603
|
+
LoaderSortField["HEIGHT"] = "HEIGHT";
|
|
604
|
+
LoaderSortField["SIZE_UNIT"] = "SIZE_UNIT";
|
|
605
|
+
LoaderSortField["VOLUME"] = "VOLUME";
|
|
606
|
+
LoaderSortField["VOLUME_UNIT"] = "VOLUME_UNIT";
|
|
607
|
+
LoaderSortField["NOTE"] = "NOTE";
|
|
608
|
+
LoaderSortField["IS_ACTIVE"] = "IS_ACTIVE";
|
|
609
|
+
LoaderSortField["CREATED_AT"] = "CREATED_AT";
|
|
610
|
+
})(exports.LoaderSortField || (exports.LoaderSortField = {}));
|
|
611
|
+
/**
|
|
612
|
+
* Columns `LoaderService.findManyLoaderTypes` can sort by (`LoaderTypeSortField`).
|
|
613
|
+
*/
|
|
614
|
+
exports.LoaderTypeSortField = void 0;
|
|
615
|
+
(function (LoaderTypeSortField) {
|
|
616
|
+
LoaderTypeSortField["KEY"] = "KEY";
|
|
617
|
+
LoaderTypeSortField["DESCRIPTION"] = "DESCRIPTION";
|
|
618
|
+
LoaderTypeSortField["IS_ACTIVE"] = "IS_ACTIVE";
|
|
619
|
+
LoaderTypeSortField["CREATED_AT"] = "CREATED_AT";
|
|
620
|
+
})(exports.LoaderTypeSortField || (exports.LoaderTypeSortField = {}));
|
|
621
|
+
|
|
622
|
+
/**
|
|
623
|
+
* Columns `MaterialService.findMany` can sort by. Values are part of the public
|
|
624
|
+
* GraphQL schema (`MaterialSortField`): adding one is a minor change, renaming
|
|
625
|
+
* or removing one is breaking.
|
|
626
|
+
*/
|
|
627
|
+
exports.MaterialSortField = void 0;
|
|
628
|
+
(function (MaterialSortField) {
|
|
629
|
+
MaterialSortField["KEY"] = "KEY";
|
|
630
|
+
MaterialSortField["DESCRIPTION"] = "DESCRIPTION";
|
|
631
|
+
/** The base unit's `key` (the column stores the unit's id). */
|
|
632
|
+
MaterialSortField["BASE_UNIT"] = "BASE_UNIT";
|
|
633
|
+
MaterialSortField["IS_ACTIVE"] = "IS_ACTIVE";
|
|
634
|
+
MaterialSortField["CREATED_AT"] = "CREATED_AT";
|
|
635
|
+
})(exports.MaterialSortField || (exports.MaterialSortField = {}));
|
|
636
|
+
|
|
590
637
|
exports.ReceiveInventoryOrderStatus = void 0;
|
|
591
638
|
(function (ReceiveInventoryOrderStatus) {
|
|
592
639
|
ReceiveInventoryOrderStatus["PENDING"] = "PENDING";
|
|
@@ -594,6 +641,24 @@ exports.ReceiveInventoryOrderStatus = void 0;
|
|
|
594
641
|
ReceiveInventoryOrderStatus["REMOVED"] = "REMOVED";
|
|
595
642
|
ReceiveInventoryOrderStatus["PARTIAL_RECEIVED"] = "PARTIAL_RECEIVED";
|
|
596
643
|
})(exports.ReceiveInventoryOrderStatus || (exports.ReceiveInventoryOrderStatus = {}));
|
|
644
|
+
/**
|
|
645
|
+
* Columns `ReceiveInventoryOrderService.findMany` can sort by. Values are part
|
|
646
|
+
* of the public GraphQL schema (`ReceiveInventoryOrderSortField`): add freely, never rename or
|
|
647
|
+
* remove. Per-item columns (material, batch, location, loader) are left out:
|
|
648
|
+
* an order has many items, so they have no single value to sort by.
|
|
649
|
+
*/
|
|
650
|
+
exports.ReceiveInventoryOrderSortField = void 0;
|
|
651
|
+
(function (ReceiveInventoryOrderSortField) {
|
|
652
|
+
/**
|
|
653
|
+
* The computed status, in lifecycle order: pending → partially received →
|
|
654
|
+
* received → removed.
|
|
655
|
+
*/
|
|
656
|
+
ReceiveInventoryOrderSortField["STATUS"] = "STATUS";
|
|
657
|
+
ReceiveInventoryOrderSortField["KEY"] = "KEY";
|
|
658
|
+
ReceiveInventoryOrderSortField["CREATED_BY"] = "CREATED_BY";
|
|
659
|
+
ReceiveInventoryOrderSortField["CREATED_AT"] = "CREATED_AT";
|
|
660
|
+
ReceiveInventoryOrderSortField["DESCRIPTION"] = "DESCRIPTION";
|
|
661
|
+
})(exports.ReceiveInventoryOrderSortField || (exports.ReceiveInventoryOrderSortField = {}));
|
|
597
662
|
|
|
598
663
|
exports.ShipInventoryOrderStatus = void 0;
|
|
599
664
|
(function (ShipInventoryOrderStatus) {
|
|
@@ -602,6 +667,180 @@ exports.ShipInventoryOrderStatus = void 0;
|
|
|
602
667
|
ShipInventoryOrderStatus["REMOVED"] = "REMOVED";
|
|
603
668
|
ShipInventoryOrderStatus["PARTIAL_SHIPPED"] = "PARTIAL_SHIPPED";
|
|
604
669
|
})(exports.ShipInventoryOrderStatus || (exports.ShipInventoryOrderStatus = {}));
|
|
670
|
+
/**
|
|
671
|
+
* Columns `ShipInventoryOrderService.findMany` can sort by. Values are part
|
|
672
|
+
* of the public GraphQL schema (`ShipInventoryOrderSortField`): add freely, never rename or
|
|
673
|
+
* remove. Per-item columns (material, batch, location, loader) are left out:
|
|
674
|
+
* an order has many items, so they have no single value to sort by.
|
|
675
|
+
*/
|
|
676
|
+
exports.ShipInventoryOrderSortField = void 0;
|
|
677
|
+
(function (ShipInventoryOrderSortField) {
|
|
678
|
+
/**
|
|
679
|
+
* The computed status, in lifecycle order: pending → partially shipped →
|
|
680
|
+
* shipped → removed.
|
|
681
|
+
*/
|
|
682
|
+
ShipInventoryOrderSortField["STATUS"] = "STATUS";
|
|
683
|
+
ShipInventoryOrderSortField["KEY"] = "KEY";
|
|
684
|
+
ShipInventoryOrderSortField["CREATED_BY"] = "CREATED_BY";
|
|
685
|
+
ShipInventoryOrderSortField["CREATED_AT"] = "CREATED_AT";
|
|
686
|
+
ShipInventoryOrderSortField["DESCRIPTION"] = "DESCRIPTION";
|
|
687
|
+
})(exports.ShipInventoryOrderSortField || (exports.ShipInventoryOrderSortField = {}));
|
|
688
|
+
|
|
689
|
+
/**
|
|
690
|
+
* Columns `StockService.findChangeLogs` can sort by. Values are part of the
|
|
691
|
+
* public GraphQL schema (`ChangeLogSortField`): add freely, never rename or
|
|
692
|
+
* remove.
|
|
693
|
+
*/
|
|
694
|
+
exports.ChangeLogSortField = void 0;
|
|
695
|
+
(function (ChangeLogSortField) {
|
|
696
|
+
/** The computed change type, in `ChangeType` declaration order. */
|
|
697
|
+
ChangeLogSortField["CHANGE_TYPE"] = "CHANGE_TYPE";
|
|
698
|
+
ChangeLogSortField["MATERIAL_KEY"] = "MATERIAL_KEY";
|
|
699
|
+
ChangeLogSortField["MATERIAL_DESCRIPTION"] = "MATERIAL_DESCRIPTION";
|
|
700
|
+
ChangeLogSortField["BATCH_KEY"] = "BATCH_KEY";
|
|
701
|
+
ChangeLogSortField["LOCATION_KEY"] = "LOCATION_KEY";
|
|
702
|
+
/** The quantity's magnitude, as `changeLogs` returns it. */
|
|
703
|
+
ChangeLogSortField["QUANTITY"] = "QUANTITY";
|
|
704
|
+
/** The material's base unit `key`. */
|
|
705
|
+
ChangeLogSortField["BASE_UNIT"] = "BASE_UNIT";
|
|
706
|
+
ChangeLogSortField["CREATED_AT"] = "CREATED_AT";
|
|
707
|
+
})(exports.ChangeLogSortField || (exports.ChangeLogSortField = {}));
|
|
708
|
+
|
|
709
|
+
/**
|
|
710
|
+
* Columns `ConsumptionOrderService.findMany` can sort by. Values are part of
|
|
711
|
+
* the public GraphQL schema (`ConsumptionOrderSortField`): add freely, never
|
|
712
|
+
* rename or remove. Item-derived columns (sources, targets, item count,
|
|
713
|
+
* issued/outstanding/settled totals) are left out: they aggregate many lines
|
|
714
|
+
* and have no column to order by.
|
|
715
|
+
*/
|
|
716
|
+
exports.ConsumptionOrderSortField = void 0;
|
|
717
|
+
(function (ConsumptionOrderSortField) {
|
|
718
|
+
ConsumptionOrderSortField["KEY"] = "KEY";
|
|
719
|
+
ConsumptionOrderSortField["DESCRIPTION"] = "DESCRIPTION";
|
|
720
|
+
ConsumptionOrderSortField["CREATED_AT"] = "CREATED_AT";
|
|
721
|
+
})(exports.ConsumptionOrderSortField || (exports.ConsumptionOrderSortField = {}));
|
|
722
|
+
|
|
723
|
+
/**
|
|
724
|
+
* Columns `InventoryCountOrderService.findMany` can sort by. Values are part of
|
|
725
|
+
* the public GraphQL schema (`InventoryCountOrderSortField`): add freely, never
|
|
726
|
+
* rename or remove. The scope (盤點範圍) is left out: a count covers many
|
|
727
|
+
* locations, so it has no single value to sort by.
|
|
728
|
+
*/
|
|
729
|
+
exports.InventoryCountOrderSortField = void 0;
|
|
730
|
+
(function (InventoryCountOrderSortField) {
|
|
731
|
+
InventoryCountOrderSortField["NAME"] = "NAME";
|
|
732
|
+
/** The PostgreSQL enum's declaration order: pending → counting → completed → cancelled. */
|
|
733
|
+
InventoryCountOrderSortField["STATUS"] = "STATUS";
|
|
734
|
+
InventoryCountOrderSortField["COUNT_DATE"] = "COUNT_DATE";
|
|
735
|
+
InventoryCountOrderSortField["CREATED_BY"] = "CREATED_BY";
|
|
736
|
+
InventoryCountOrderSortField["CREATED_AT"] = "CREATED_AT";
|
|
737
|
+
})(exports.InventoryCountOrderSortField || (exports.InventoryCountOrderSortField = {}));
|
|
738
|
+
/**
|
|
739
|
+
* Columns `InventoryCountOrderService.findItems` (the count sheet) can sort by
|
|
740
|
+
* (`InventoryCountOrderItemSortField`). The quantity columns are left out: the
|
|
741
|
+
* sheet shows them in the line's selected unit, which the operator can change
|
|
742
|
+
* locally before saving, so no server order could match what is on screen.
|
|
743
|
+
*/
|
|
744
|
+
exports.InventoryCountOrderItemSortField = void 0;
|
|
745
|
+
(function (InventoryCountOrderItemSortField) {
|
|
746
|
+
InventoryCountOrderItemSortField["MATERIAL_KEY"] = "MATERIAL_KEY";
|
|
747
|
+
InventoryCountOrderItemSortField["MATERIAL_DESCRIPTION"] = "MATERIAL_DESCRIPTION";
|
|
748
|
+
InventoryCountOrderItemSortField["BATCH_KEY"] = "BATCH_KEY";
|
|
749
|
+
InventoryCountOrderItemSortField["LOCATION_KEY"] = "LOCATION_KEY";
|
|
750
|
+
InventoryCountOrderItemSortField["LOADER_SERIAL_ID"] = "LOADER_SERIAL_ID";
|
|
751
|
+
InventoryCountOrderItemSortField["VENDOR_ID"] = "VENDOR_ID";
|
|
752
|
+
InventoryCountOrderItemSortField["CUSTOMER_ID"] = "CUSTOMER_ID";
|
|
753
|
+
InventoryCountOrderItemSortField["SALE_ID"] = "SALE_ID";
|
|
754
|
+
InventoryCountOrderItemSortField["SALE_SERIAL_ID"] = "SALE_SERIAL_ID";
|
|
755
|
+
/** Lines the operator added during the count. */
|
|
756
|
+
InventoryCountOrderItemSortField["IS_ADDITION"] = "IS_ADDITION";
|
|
757
|
+
/** The 凍結 icon: `held`, a NULL snapshot read as not held. */
|
|
758
|
+
InventoryCountOrderItemSortField["HELD"] = "HELD";
|
|
759
|
+
/** The 調撥 icon: the line had a `transferId`. */
|
|
760
|
+
InventoryCountOrderItemSortField["IN_TRANSFER"] = "IN_TRANSFER";
|
|
761
|
+
/**
|
|
762
|
+
* The 待檢驗 icon, ranked: no mark (0) < failed inspection (1) < awaiting
|
|
763
|
+
* inspection (2, `requiresInspection` and no result yet).
|
|
764
|
+
*/
|
|
765
|
+
InventoryCountOrderItemSortField["INSPECTION"] = "INSPECTION";
|
|
766
|
+
})(exports.InventoryCountOrderItemSortField || (exports.InventoryCountOrderItemSortField = {}));
|
|
767
|
+
|
|
768
|
+
/**
|
|
769
|
+
* Columns `LocationService.findMany` can sort by. Values are part of the public
|
|
770
|
+
* GraphQL schema (`LocationSortField`): add freely, never rename or remove.
|
|
771
|
+
*/
|
|
772
|
+
exports.LocationSortField = void 0;
|
|
773
|
+
(function (LocationSortField) {
|
|
774
|
+
LocationSortField["KEY"] = "KEY";
|
|
775
|
+
LocationSortField["DESCRIPTION"] = "DESCRIPTION";
|
|
776
|
+
LocationSortField["IS_ACTIVE"] = "IS_ACTIVE";
|
|
777
|
+
LocationSortField["CREATED_AT"] = "CREATED_AT";
|
|
778
|
+
})(exports.LocationSortField || (exports.LocationSortField = {}));
|
|
779
|
+
|
|
780
|
+
/**
|
|
781
|
+
* Columns `TransferOrderService.findMany` can sort by. Values are part of the
|
|
782
|
+
* public GraphQL schema (`TransferOrderSortField`): add freely, never rename or
|
|
783
|
+
* remove. Per-item columns (material, batch, locations, loaders) are left out:
|
|
784
|
+
* an order has many items, so they have no single value to sort by.
|
|
785
|
+
*/
|
|
786
|
+
exports.TransferOrderSortField = void 0;
|
|
787
|
+
(function (TransferOrderSortField) {
|
|
788
|
+
TransferOrderSortField["KEY"] = "KEY";
|
|
789
|
+
TransferOrderSortField["RECEIVER"] = "RECEIVER";
|
|
790
|
+
TransferOrderSortField["DESCRIPTION"] = "DESCRIPTION";
|
|
791
|
+
TransferOrderSortField["CREATED_BY"] = "CREATED_BY";
|
|
792
|
+
TransferOrderSortField["CREATED_AT"] = "CREATED_AT";
|
|
793
|
+
})(exports.TransferOrderSortField || (exports.TransferOrderSortField = {}));
|
|
794
|
+
|
|
795
|
+
/**
|
|
796
|
+
* Direction of a list sort. Exposed through GraphQL as the `SortOrder` enum.
|
|
797
|
+
*/
|
|
798
|
+
exports.SortOrder = void 0;
|
|
799
|
+
(function (SortOrder) {
|
|
800
|
+
SortOrder["ASC"] = "ASC";
|
|
801
|
+
SortOrder["DESC"] = "DESC";
|
|
802
|
+
})(exports.SortOrder || (exports.SortOrder = {}));
|
|
803
|
+
|
|
804
|
+
/**
|
|
805
|
+
* Columns `StockService.findAggregatedStocks` can sort by. Values are part of
|
|
806
|
+
* the public GraphQL schema (`AggregatedStockSortField`): adding one is a minor
|
|
807
|
+
* change, renaming or removing one is breaking.
|
|
808
|
+
*
|
|
809
|
+
* Every one is single-valued per aggregated row: a row is one (material, batch,
|
|
810
|
+
* location, loader, status) position, and each joined key is one-to-one with
|
|
811
|
+
* its id.
|
|
812
|
+
*/
|
|
813
|
+
exports.AggregatedStockSortField = void 0;
|
|
814
|
+
(function (AggregatedStockSortField) {
|
|
815
|
+
/** The derived status code (`FREE`, `HELD`, …), compared as text. */
|
|
816
|
+
AggregatedStockSortField["STATUS"] = "STATUS";
|
|
817
|
+
AggregatedStockSortField["MATERIAL_KEY"] = "MATERIAL_KEY";
|
|
818
|
+
AggregatedStockSortField["MATERIAL_DESCRIPTION"] = "MATERIAL_DESCRIPTION";
|
|
819
|
+
/** The batch *group*'s key — what the `batch { key }` field shows. */
|
|
820
|
+
AggregatedStockSortField["BATCH_KEY"] = "BATCH_KEY";
|
|
821
|
+
AggregatedStockSortField["LOCATION_KEY"] = "LOCATION_KEY";
|
|
822
|
+
AggregatedStockSortField["LOADER_SERIAL_ID"] = "LOADER_SERIAL_ID";
|
|
823
|
+
AggregatedStockSortField["QUANTITY"] = "QUANTITY";
|
|
824
|
+
/** The material's base unit `key`. */
|
|
825
|
+
AggregatedStockSortField["BASE_UNIT"] = "BASE_UNIT";
|
|
826
|
+
AggregatedStockSortField["VENDOR_ID"] = "VENDOR_ID";
|
|
827
|
+
AggregatedStockSortField["CUSTOMER_ID"] = "CUSTOMER_ID";
|
|
828
|
+
AggregatedStockSortField["SALE_ID"] = "SALE_ID";
|
|
829
|
+
AggregatedStockSortField["SALE_SERIAL_ID"] = "SALE_SERIAL_ID";
|
|
830
|
+
})(exports.AggregatedStockSortField || (exports.AggregatedStockSortField = {}));
|
|
831
|
+
/**
|
|
832
|
+
* Columns `StockService.findManyGroupedByMaterialId` can sort by. Values are
|
|
833
|
+
* part of the public GraphQL schema (`StockGroupedByMaterialSortField`).
|
|
834
|
+
*/
|
|
835
|
+
exports.StockGroupedByMaterialSortField = void 0;
|
|
836
|
+
(function (StockGroupedByMaterialSortField) {
|
|
837
|
+
StockGroupedByMaterialSortField["MATERIAL_KEY"] = "MATERIAL_KEY";
|
|
838
|
+
StockGroupedByMaterialSortField["MATERIAL_DESCRIPTION"] = "MATERIAL_DESCRIPTION";
|
|
839
|
+
/** The material's total over the matching positions (`SUM(quantity)`). */
|
|
840
|
+
StockGroupedByMaterialSortField["QUANTITY"] = "QUANTITY";
|
|
841
|
+
/** The material's base unit `key`. */
|
|
842
|
+
StockGroupedByMaterialSortField["BASE_UNIT"] = "BASE_UNIT";
|
|
843
|
+
})(exports.StockGroupedByMaterialSortField || (exports.StockGroupedByMaterialSortField = {}));
|
|
605
844
|
|
|
606
845
|
const ReceiveInventoryOrderEntity = Symbol('ReceiveInventoryOrderEntity');
|
|
607
846
|
exports.ReceiveInventoryOrderEntityClass = class ReceiveInventoryOrderEntityClass {
|
|
@@ -3414,6 +3653,96 @@ class BaseOrderService {
|
|
|
3414
3653
|
}
|
|
3415
3654
|
}
|
|
3416
3655
|
|
|
3656
|
+
/**
|
|
3657
|
+
* NULLs sort last in **both** directions.
|
|
3658
|
+
*
|
|
3659
|
+
* PostgreSQL's own default flips with the direction (NULLS LAST for ASC, NULLS
|
|
3660
|
+
* FIRST for DESC), so a column with gaps would open every descending page with
|
|
3661
|
+
* its empty rows. A missing value is "no value", not "the largest value": it
|
|
3662
|
+
* belongs at the end whichever way the user sorts.
|
|
3663
|
+
*/
|
|
3664
|
+
const LIST_SORT_NULLS = 'NULLS LAST';
|
|
3665
|
+
const ENTITY_PATH = /^([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_.]*)$/;
|
|
3666
|
+
const isSortOrder = (value) => value === exports.SortOrder.ASC || value === exports.SortOrder.DESC;
|
|
3667
|
+
/**
|
|
3668
|
+
* The ORDER BY clauses `applyListSort` would apply, without a query builder.
|
|
3669
|
+
* Pure — this is what the unit tests pin down.
|
|
3670
|
+
*
|
|
3671
|
+
* Throws on a field outside the whitelist or an unknown direction: the GraphQL
|
|
3672
|
+
* enums already reject both, so reaching here with one means a host called the
|
|
3673
|
+
* service directly with a bad value, and falling back to the default order would
|
|
3674
|
+
* hand it a plausible-looking wrong answer.
|
|
3675
|
+
*/
|
|
3676
|
+
function resolveListSort(options) {
|
|
3677
|
+
const { sort, fields, defaultOrder, tiebreaker } = options;
|
|
3678
|
+
const requested = sort
|
|
3679
|
+
? [sort]
|
|
3680
|
+
: Array.isArray(defaultOrder)
|
|
3681
|
+
? defaultOrder
|
|
3682
|
+
: [defaultOrder];
|
|
3683
|
+
const clauses = requested.map(({ field, order }) => {
|
|
3684
|
+
if (!Object.prototype.hasOwnProperty.call(fields, field)) {
|
|
3685
|
+
throw new Error(`Unknown sort field "${String(field)}"`);
|
|
3686
|
+
}
|
|
3687
|
+
if (!isSortOrder(order)) {
|
|
3688
|
+
throw new Error(`Unknown sort order "${String(order)}"`);
|
|
3689
|
+
}
|
|
3690
|
+
return { expression: fields[field], order, nulls: LIST_SORT_NULLS };
|
|
3691
|
+
});
|
|
3692
|
+
const tiebreakers = typeof tiebreaker === 'string' ? [tiebreaker] : tiebreaker;
|
|
3693
|
+
// TypeORM keys ORDER BY by expression, so appending a tiebreaker column that
|
|
3694
|
+
// is already a criterion would overwrite that criterion's direction.
|
|
3695
|
+
return [
|
|
3696
|
+
...clauses,
|
|
3697
|
+
...tiebreakers
|
|
3698
|
+
.filter((column) => clauses.every(({ expression }) => expression !== column))
|
|
3699
|
+
.map((expression) => ({ expression, order: exports.SortOrder.ASC })),
|
|
3700
|
+
];
|
|
3701
|
+
}
|
|
3702
|
+
function assertEntityOrderPath(qb, expression) {
|
|
3703
|
+
const match = ENTITY_PATH.exec(expression);
|
|
3704
|
+
if (!match) {
|
|
3705
|
+
throw new Error(`Sort expression "${expression}" must be "alias.propertyPath" in entity mode; use mode 'raw' for SQL expressions`);
|
|
3706
|
+
}
|
|
3707
|
+
const [, aliasName, propertyPath] = match;
|
|
3708
|
+
const alias = qb.expressionMap.aliases.find(({ name }) => name === aliasName);
|
|
3709
|
+
if (!alias?.hasMetadata) {
|
|
3710
|
+
throw new Error(`Sort expression "${expression}": alias "${aliasName}" is not an entity alias of this query — join it (by entity class) before applyListSort`);
|
|
3711
|
+
}
|
|
3712
|
+
if (!alias.metadata.findColumnWithPropertyPath(propertyPath)) {
|
|
3713
|
+
throw new Error(`Sort expression "${expression}": "${propertyPath}" is not a column of ${alias.metadata.name}`);
|
|
3714
|
+
}
|
|
3715
|
+
const isMainAlias = qb.expressionMap.mainAlias?.name === aliasName;
|
|
3716
|
+
const isSelected = qb.expressionMap.selects.some(({ selection }) => selection === aliasName || selection === expression);
|
|
3717
|
+
if (!isMainAlias && !isSelected) {
|
|
3718
|
+
throw new Error(`Sort expression "${expression}": joined alias "${aliasName}" must be selected (addSelect('${expression}')) or the paginated DISTINCT subquery cannot order by it`);
|
|
3719
|
+
}
|
|
3720
|
+
}
|
|
3721
|
+
/**
|
|
3722
|
+
* Replace the query's ORDER BY with the requested sort (or `defaultOrder`),
|
|
3723
|
+
* then the tiebreaker. Call it after every join the sort expressions need.
|
|
3724
|
+
*
|
|
3725
|
+
* ```ts
|
|
3726
|
+
* applyListSort(qb, {
|
|
3727
|
+
* sort: options.sort,
|
|
3728
|
+
* fields: { [MaterialSortField.KEY]: 'material.key', ... },
|
|
3729
|
+
* defaultOrder: { field: MaterialSortField.CREATED_AT, order: SortOrder.DESC },
|
|
3730
|
+
* tiebreaker: 'material.id',
|
|
3731
|
+
* });
|
|
3732
|
+
* ```
|
|
3733
|
+
*/
|
|
3734
|
+
function applyListSort(qb, options) {
|
|
3735
|
+
const clauses = resolveListSort(options);
|
|
3736
|
+
if ((options.mode ?? 'entity') === 'entity') {
|
|
3737
|
+
clauses.forEach(({ expression }) => assertEntityOrderPath(qb, expression));
|
|
3738
|
+
}
|
|
3739
|
+
qb.orderBy();
|
|
3740
|
+
clauses.forEach(({ expression, order, nulls }) => {
|
|
3741
|
+
qb.addOrderBy(expression, order, nulls);
|
|
3742
|
+
});
|
|
3743
|
+
return qb;
|
|
3744
|
+
}
|
|
3745
|
+
|
|
3417
3746
|
/**
|
|
3418
3747
|
* The table an entity actually ended up in, as TypeORM resolved it — after
|
|
3419
3748
|
* `withWmsTablePrefix`, and with its schema if it has one. Use it wherever SQL
|
|
@@ -3450,6 +3779,48 @@ const getWmsTablePrefix = () => readWmsTablePrefixState()?.prefix ?? '';
|
|
|
3450
3779
|
*/
|
|
3451
3780
|
const wmsLogicalTableName = (tableName) => readWmsTablePrefixState()?.logicalNames.get(tableName) ?? tableName;
|
|
3452
3781
|
|
|
3782
|
+
/**
|
|
3783
|
+
* ORDER BY expressions for `findAggregatedStocks`, over the outer query: the
|
|
3784
|
+
* aggregated subquery is `agg`, and the joins a field needs are added by
|
|
3785
|
+
* `joinAggregatedStockSortTarget` under the `sort_*` aliases.
|
|
3786
|
+
*/
|
|
3787
|
+
const AGGREGATED_STOCK_SORT_FIELDS = {
|
|
3788
|
+
[exports.AggregatedStockSortField.STATUS]: 'agg.status',
|
|
3789
|
+
[exports.AggregatedStockSortField.MATERIAL_KEY]: 'sort_material."key"',
|
|
3790
|
+
[exports.AggregatedStockSortField.MATERIAL_DESCRIPTION]: 'sort_material."description"',
|
|
3791
|
+
[exports.AggregatedStockSortField.BATCH_KEY]: 'sort_batch_group."key"',
|
|
3792
|
+
[exports.AggregatedStockSortField.LOCATION_KEY]: 'sort_location."key"',
|
|
3793
|
+
[exports.AggregatedStockSortField.LOADER_SERIAL_ID]: 'sort_loader."serialId"',
|
|
3794
|
+
[exports.AggregatedStockSortField.QUANTITY]: 'agg.quantity',
|
|
3795
|
+
[exports.AggregatedStockSortField.BASE_UNIT]: 'sort_unit."key"',
|
|
3796
|
+
[exports.AggregatedStockSortField.VENDOR_ID]: 'agg."vendorId"',
|
|
3797
|
+
[exports.AggregatedStockSortField.CUSTOMER_ID]: 'agg."customerId"',
|
|
3798
|
+
[exports.AggregatedStockSortField.SALE_ID]: 'agg."saleId"',
|
|
3799
|
+
[exports.AggregatedStockSortField.SALE_SERIAL_ID]: 'agg."saleSerialId"',
|
|
3800
|
+
};
|
|
3801
|
+
/**
|
|
3802
|
+
* What identifies an aggregated row, in the order the list has always used.
|
|
3803
|
+
* The batch columns grouped alongside are functionally dependent on `batchId`,
|
|
3804
|
+
* so these five are unique per row.
|
|
3805
|
+
*/
|
|
3806
|
+
const AGGREGATED_STOCK_GROUP_KEY = [
|
|
3807
|
+
'agg."materialId"',
|
|
3808
|
+
'agg."batchId"',
|
|
3809
|
+
'agg."locationId"',
|
|
3810
|
+
'agg."loaderId"',
|
|
3811
|
+
'agg.status',
|
|
3812
|
+
];
|
|
3813
|
+
/** The parameter TypeORM gives a single-table child's discriminator values. */
|
|
3814
|
+
const TYPEORM_DISCRIMINATOR_PARAMETER = 'discriminatorColumnValues';
|
|
3815
|
+
/** Its renamed copy inside `findManyGroupedByMaterialId`'s stock subquery. */
|
|
3816
|
+
const STOCK_DISCRIMINATOR_PARAMETER = 'stockDiscriminatorColumnValues';
|
|
3817
|
+
/** ORDER BY expressions for `findManyGroupedByMaterialId`. */
|
|
3818
|
+
const STOCK_GROUPED_BY_MATERIAL_SORT_FIELDS = {
|
|
3819
|
+
[exports.StockGroupedByMaterialSortField.MATERIAL_KEY]: 'material."key"',
|
|
3820
|
+
[exports.StockGroupedByMaterialSortField.MATERIAL_DESCRIPTION]: 'material."description"',
|
|
3821
|
+
[exports.StockGroupedByMaterialSortField.QUANTITY]: 'totals.quantity',
|
|
3822
|
+
[exports.StockGroupedByMaterialSortField.BASE_UNIT]: 'sort_unit."key"',
|
|
3823
|
+
};
|
|
3453
3824
|
/**
|
|
3454
3825
|
* A lock taken in autocommit is released by the statement that took it, so a
|
|
3455
3826
|
* check "protected" by one is not protected at all. Refuse instead.
|
|
@@ -3790,27 +4161,76 @@ exports.StockService = class StockService {
|
|
|
3790
4161
|
const queryBuilder = this.pipeSelectOptionsToQueryBuilder(options, this.selectQueryBuilder('stock'));
|
|
3791
4162
|
return queryBuilder.getManyAndCount();
|
|
3792
4163
|
}
|
|
4164
|
+
/**
|
|
4165
|
+
* Materials with stock, one page of them, in one statement.
|
|
4166
|
+
*
|
|
4167
|
+
* A material is listed when any of its (material, batch, location, loader,
|
|
4168
|
+
* status) positions nets to non-zero after the filters — the aggregated
|
|
4169
|
+
* subquery's `HAVING` — not when the material's own total does: +5 in one
|
|
4170
|
+
* place and -5 in another is listed. Soft-deleted materials are left out
|
|
4171
|
+
* (the material repository is the main alias).
|
|
4172
|
+
*
|
|
4173
|
+
* The positions are summed per material in the database, joined to the
|
|
4174
|
+
* material, sorted and paged there; `total` comes from a window count on the
|
|
4175
|
+
* same statement. Only a page past the end, which has no row to carry it,
|
|
4176
|
+
* costs a second query.
|
|
4177
|
+
*/
|
|
3793
4178
|
async findManyGroupedByMaterialId(options) {
|
|
3794
|
-
|
|
3795
|
-
const aggregateSubquery = this.pipeSelectOptionsToQueryBuilder(
|
|
3796
|
-
|
|
3797
|
-
|
|
3798
|
-
|
|
3799
|
-
|
|
3800
|
-
|
|
3801
|
-
|
|
3802
|
-
|
|
3803
|
-
|
|
3804
|
-
|
|
3805
|
-
|
|
4179
|
+
const { sort, offset, limit, ...filters } = options;
|
|
4180
|
+
const aggregateSubquery = this.pipeSelectOptionsToQueryBuilder(filters, this.selectQueryBuilder('stock'), true);
|
|
4181
|
+
/*
|
|
4182
|
+
* Both the stock subquery and the material main alias are single-table
|
|
4183
|
+
* children, and TypeORM names *every* discriminator parameter
|
|
4184
|
+
* `discriminatorColumnValues`. Embedded as is, the outer query's value
|
|
4185
|
+
* (the material's) would overwrite the inner one and the stock filter would
|
|
4186
|
+
* match nothing — so the inner placeholder gets a name of its own.
|
|
4187
|
+
*/
|
|
4188
|
+
const { [TYPEORM_DISCRIMINATOR_PARAMETER]: stockDiscriminatorValues, ...aggregateParameters } = aggregateSubquery.getParameters();
|
|
4189
|
+
const aggregateSql = aggregateSubquery
|
|
4190
|
+
.getQuery()
|
|
4191
|
+
.split(`:...${TYPEORM_DISCRIMINATOR_PARAMETER}`)
|
|
4192
|
+
.join(`:...${STOCK_DISCRIMINATOR_PARAMETER}`);
|
|
4193
|
+
const queryBuilder = () => this.dataSource
|
|
3806
4194
|
.getRepository(this.materialEntity)
|
|
3807
4195
|
.createQueryBuilder('material')
|
|
3808
|
-
.
|
|
3809
|
-
|
|
3810
|
-
|
|
3811
|
-
|
|
3812
|
-
|
|
3813
|
-
|
|
4196
|
+
.innerJoin((subQuery) => subQuery
|
|
4197
|
+
.select('agg."materialId"', 'materialId')
|
|
4198
|
+
.addSelect('SUM(agg.quantity)', 'quantity')
|
|
4199
|
+
.from(`(${aggregateSql})`, 'agg')
|
|
4200
|
+
.groupBy('agg."materialId"'), 'totals', 'totals."materialId" = material.id')
|
|
4201
|
+
.setParameters({
|
|
4202
|
+
...aggregateParameters,
|
|
4203
|
+
...(stockDiscriminatorValues === undefined
|
|
4204
|
+
? {}
|
|
4205
|
+
: { [STOCK_DISCRIMINATOR_PARAMETER]: stockDiscriminatorValues }),
|
|
4206
|
+
});
|
|
4207
|
+
const pageBuilder = queryBuilder().addSelect('COUNT(*) OVER ()', 'total');
|
|
4208
|
+
// `materials.baseUnit` holds the unit's id, so its key needs a join; one
|
|
4209
|
+
// unit per material, so the join keeps one row per material.
|
|
4210
|
+
if (sort?.field === exports.StockGroupedByMaterialSortField.BASE_UNIT) {
|
|
4211
|
+
pageBuilder.leftJoin(exports.UnitEntityClass, 'sort_unit', 'CAST(sort_unit.id AS text) = material."baseUnit"');
|
|
4212
|
+
}
|
|
4213
|
+
applyListSort(pageBuilder, {
|
|
4214
|
+
sort,
|
|
4215
|
+
fields: STOCK_GROUPED_BY_MATERIAL_SORT_FIELDS,
|
|
4216
|
+
defaultOrder: {
|
|
4217
|
+
field: exports.StockGroupedByMaterialSortField.MATERIAL_KEY,
|
|
4218
|
+
order: exports.SortOrder.ASC,
|
|
4219
|
+
},
|
|
4220
|
+
tiebreaker: 'material.id',
|
|
4221
|
+
mode: 'raw',
|
|
4222
|
+
});
|
|
4223
|
+
// `totals` is one row per material, so LIMIT/OFFSET cut whole materials.
|
|
4224
|
+
if (offset !== undefined && offset >= 0)
|
|
4225
|
+
pageBuilder.offset(offset);
|
|
4226
|
+
if (limit !== undefined && limit > 0)
|
|
4227
|
+
pageBuilder.limit(limit);
|
|
4228
|
+
const { entities, raw } = await pageBuilder.getRawAndEntities();
|
|
4229
|
+
if (raw.length)
|
|
4230
|
+
return [entities, parseInt(raw[0].total, 10)];
|
|
4231
|
+
if (!offset)
|
|
4232
|
+
return [[], 0];
|
|
4233
|
+
return [[], await queryBuilder().getCount()];
|
|
3814
4234
|
}
|
|
3815
4235
|
async findAggregatedStock(options, manager = this.dataSource.manager) {
|
|
3816
4236
|
const queryBuilder = this.pipeSelectOptionsToQueryBuilder(options, this.selectQueryBuilder('stock', manager.getRepository(this.stockEntity).createQueryBuilder('stock')), true);
|
|
@@ -3872,6 +4292,39 @@ exports.StockService = class StockService {
|
|
|
3872
4292
|
throw new Error(`Insufficient stock: available ${available}, requested ${quantity} (materialId=${materialId}, batchId=${batchId}, loaderId=${loaderId})`);
|
|
3873
4293
|
}
|
|
3874
4294
|
}
|
|
4295
|
+
/**
|
|
4296
|
+
* Join what a sort field of `findAggregatedStocks` orders by, and nothing
|
|
4297
|
+
* else: an unsorted call (every internal caller) keeps its plain query.
|
|
4298
|
+
* Each join is on a primary key, so the outer query stays one row per
|
|
4299
|
+
* aggregated position and LIMIT/OFFSET still cut whole rows. Entities, not
|
|
4300
|
+
* table names, so a table prefix and an overridden entity both follow.
|
|
4301
|
+
*/
|
|
4302
|
+
joinAggregatedStockSortTarget(queryBuilder, field) {
|
|
4303
|
+
switch (field) {
|
|
4304
|
+
case exports.AggregatedStockSortField.MATERIAL_KEY:
|
|
4305
|
+
case exports.AggregatedStockSortField.MATERIAL_DESCRIPTION:
|
|
4306
|
+
queryBuilder.leftJoin(this.materialEntity, 'sort_material', 'sort_material.id = agg."materialId"');
|
|
4307
|
+
break;
|
|
4308
|
+
case exports.AggregatedStockSortField.BASE_UNIT:
|
|
4309
|
+
queryBuilder
|
|
4310
|
+
.leftJoin(this.materialEntity, 'sort_material', 'sort_material.id = agg."materialId"')
|
|
4311
|
+
.leftJoin(exports.UnitEntityClass, 'sort_unit', 'CAST(sort_unit.id AS text) = sort_material."baseUnit"');
|
|
4312
|
+
break;
|
|
4313
|
+
case exports.AggregatedStockSortField.BATCH_KEY:
|
|
4314
|
+
// What `batch { key }` shows is the batch *group*'s key.
|
|
4315
|
+
queryBuilder
|
|
4316
|
+
.leftJoin(this.entities.batch, 'sort_batch', 'sort_batch.id = agg."batchId"')
|
|
4317
|
+
.leftJoin(exports.BatchGroupEntityClass, 'sort_batch_group', 'CAST(sort_batch_group.id AS text) = CAST(sort_batch."groupId" AS text)');
|
|
4318
|
+
break;
|
|
4319
|
+
case exports.AggregatedStockSortField.LOCATION_KEY:
|
|
4320
|
+
queryBuilder.leftJoin(this.entities.location, 'sort_location', 'sort_location.id = agg."locationId"');
|
|
4321
|
+
break;
|
|
4322
|
+
case exports.AggregatedStockSortField.LOADER_SERIAL_ID:
|
|
4323
|
+
// `stocks.loaderId` is varchar, `loaders.id` uuid.
|
|
4324
|
+
queryBuilder.leftJoin(exports.LoadersEntityClass, 'sort_loader', 'CAST(sort_loader.id AS text) = agg."loaderId"');
|
|
4325
|
+
break;
|
|
4326
|
+
}
|
|
4327
|
+
}
|
|
3875
4328
|
async findAggregatedStocks(options, manager = this.dataSource.manager) {
|
|
3876
4329
|
// Create the aggregated subquery without pagination
|
|
3877
4330
|
const aggregateSubquery = this.pipeSelectOptionsToQueryBuilder({ ...options, offset: undefined, limit: undefined }, this.selectQueryBuilder('stock', manager.getRepository(this.stockEntity).createQueryBuilder('stock')),
|
|
@@ -3907,12 +4360,26 @@ exports.StockService = class StockService {
|
|
|
3907
4360
|
// (material, batch, location, loader) plus the derived status -- which is
|
|
3908
4361
|
// what makes a row unique here; without a total order LIMIT/OFFSET pages
|
|
3909
4362
|
// can repeat or skip rows.
|
|
3910
|
-
|
|
3911
|
-
.
|
|
3912
|
-
|
|
3913
|
-
|
|
3914
|
-
|
|
3915
|
-
|
|
4363
|
+
if (options.sort) {
|
|
4364
|
+
this.joinAggregatedStockSortTarget(paginatedQueryBuilder, options.sort.field);
|
|
4365
|
+
applyListSort(paginatedQueryBuilder, {
|
|
4366
|
+
sort: options.sort,
|
|
4367
|
+
fields: AGGREGATED_STOCK_SORT_FIELDS,
|
|
4368
|
+
defaultOrder: options.sort,
|
|
4369
|
+
tiebreaker: AGGREGATED_STOCK_GROUP_KEY,
|
|
4370
|
+
mode: 'raw',
|
|
4371
|
+
});
|
|
4372
|
+
}
|
|
4373
|
+
else {
|
|
4374
|
+
// The order this list has always had, kept verbatim (NULLS FIRST
|
|
4375
|
+
// included) so callers paging without a sort see no change.
|
|
4376
|
+
paginatedQueryBuilder
|
|
4377
|
+
.orderBy('agg."materialId"', 'ASC')
|
|
4378
|
+
.addOrderBy('agg."batchId"', 'ASC')
|
|
4379
|
+
.addOrderBy('agg."locationId"', 'ASC', 'NULLS FIRST')
|
|
4380
|
+
.addOrderBy('agg."loaderId"', 'ASC', 'NULLS FIRST')
|
|
4381
|
+
.addOrderBy('agg.status', 'ASC', 'NULLS FIRST');
|
|
4382
|
+
}
|
|
3916
4383
|
if (options.offset !== undefined && options.offset >= 0) {
|
|
3917
4384
|
paginatedQueryBuilder.offset(options.offset);
|
|
3918
4385
|
}
|
|
@@ -3939,10 +4406,11 @@ exports.StockService = class StockService {
|
|
|
3939
4406
|
return [items, count];
|
|
3940
4407
|
}
|
|
3941
4408
|
async findChangeLogs(options) {
|
|
4409
|
+
const { sort, ...filters } = options;
|
|
3942
4410
|
// Our own change tables, named as they ended up under `withWmsTablePrefix`.
|
|
3943
4411
|
const prefix = getWmsTablePrefix();
|
|
3944
4412
|
// Build base query with all change entity joins
|
|
3945
|
-
const changesQueryBuilder = this.pipeSelectOptionsToQueryBuilder({ ...
|
|
4413
|
+
const changesQueryBuilder = this.pipeSelectOptionsToQueryBuilder({ ...filters, offset: undefined, limit: undefined }, this.selectQueryBuilder('stock'), false)
|
|
3946
4414
|
.leftJoin(`${prefix}receive_inventory_order_changes`, 'receive_change', 'stock."orderId" = receive_change.id')
|
|
3947
4415
|
.leftJoin(`${prefix}ship_inventory_order_changes`, 'ship_change', 'stock."orderId" = ship_change.id')
|
|
3948
4416
|
.leftJoin(`${prefix}transfer_order_changes`, 'transfer_change', 'stock."orderId" = transfer_change.id')
|
|
@@ -3992,16 +4460,9 @@ exports.StockService = class StockService {
|
|
|
3992
4460
|
if (options.limit !== undefined && options.limit > 0) {
|
|
3993
4461
|
resultQueryBuilder.limit(options.limit);
|
|
3994
4462
|
}
|
|
3995
|
-
//
|
|
3996
|
-
|
|
3997
|
-
|
|
3998
|
-
.addSelect('stock.quantity', 'quantity')
|
|
3999
|
-
.addSelect('stock_status.status', 'status')
|
|
4000
|
-
.addSelect('stock."materialId"', 'materialId')
|
|
4001
|
-
.addSelect('stock."batchId"', 'batchId')
|
|
4002
|
-
.addSelect('stock."locationId"', 'locationId')
|
|
4003
|
-
.addSelect('stock."loaderId"', 'loaderId')
|
|
4004
|
-
.addSelect(`CASE
|
|
4463
|
+
// Also the ORDER BY for CHANGE_TYPE: PostgreSQL accepts an output alias
|
|
4464
|
+
// in ORDER BY only on its own, never inside an expression.
|
|
4465
|
+
const changeTypeSql = `CASE
|
|
4005
4466
|
WHEN receive_change.id IS NOT NULL THEN '${exports.ChangeType.RECEIVED}'
|
|
4006
4467
|
WHEN ship_change.id IS NOT NULL THEN
|
|
4007
4468
|
CASE WHEN ship_change."quantityChanged" > 0 THEN '${exports.ChangeType.IN_SHIPMENT}'
|
|
@@ -4026,13 +4487,61 @@ exports.StockService = class StockService {
|
|
|
4026
4487
|
WHEN reclassify_change.id IS NOT NULL THEN '${exports.ChangeType.RECLASSIFIED}'
|
|
4027
4488
|
WHEN scrape_change.id IS NOT NULL THEN '${exports.ChangeType.SCRAPED}'
|
|
4028
4489
|
ELSE NULL
|
|
4029
|
-
END
|
|
4490
|
+
END`;
|
|
4491
|
+
// Explicitly select only the fields needed for ChangeLog
|
|
4492
|
+
resultQueryBuilder
|
|
4493
|
+
.select('stock.id', 'id')
|
|
4494
|
+
.addSelect('stock.quantity', 'quantity')
|
|
4495
|
+
.addSelect('stock_status.status', 'status')
|
|
4496
|
+
.addSelect('stock."materialId"', 'materialId')
|
|
4497
|
+
.addSelect('stock."batchId"', 'batchId')
|
|
4498
|
+
.addSelect('stock."locationId"', 'locationId')
|
|
4499
|
+
.addSelect('stock."loaderId"', 'loaderId')
|
|
4500
|
+
.addSelect(changeTypeSql, 'changeType');
|
|
4501
|
+
// Joined only for the column asked for, by entity (the overridable ones
|
|
4502
|
+
// through `WmsEntities`) so the table prefix applies; every join is on a
|
|
4503
|
+
// primary key, so no row is multiplied. Aliases avoid the filter joins'.
|
|
4504
|
+
if (sort?.field === exports.ChangeLogSortField.MATERIAL_KEY ||
|
|
4505
|
+
sort?.field === exports.ChangeLogSortField.MATERIAL_DESCRIPTION ||
|
|
4506
|
+
sort?.field === exports.ChangeLogSortField.BASE_UNIT) {
|
|
4507
|
+
resultQueryBuilder.leftJoin(this.entities.material, 'cl_material', 'cl_material.id = stock."materialId"');
|
|
4508
|
+
}
|
|
4509
|
+
if (sort?.field === exports.ChangeLogSortField.BASE_UNIT) {
|
|
4510
|
+
resultQueryBuilder.leftJoin(exports.UnitEntityClass, 'cl_unit', 'CAST(cl_unit.id AS text) = cl_material."baseUnit"');
|
|
4511
|
+
}
|
|
4512
|
+
if (sort?.field === exports.ChangeLogSortField.BATCH_KEY) {
|
|
4513
|
+
resultQueryBuilder.leftJoin(this.entities.batch, 'cl_batch', 'cl_batch.id = stock."batchId"');
|
|
4514
|
+
}
|
|
4515
|
+
if (sort?.field === exports.ChangeLogSortField.LOCATION_KEY) {
|
|
4516
|
+
resultQueryBuilder.leftJoin(this.entities.location, 'cl_location', 'cl_location.id = stock."locationId"');
|
|
4517
|
+
}
|
|
4518
|
+
const changeTypeRank = `(CASE ${changeTypeSql} ${Object.values(exports.ChangeType)
|
|
4519
|
+
.map((type, rank) => `WHEN '${type}' THEN ${rank}`)
|
|
4520
|
+
.join(' ')} END)`;
|
|
4030
4521
|
// The id tiebreaker is what keeps two pages from overlapping when several
|
|
4031
4522
|
// rows share a timestamp, which a multi-line order always produces.
|
|
4032
|
-
|
|
4033
|
-
|
|
4034
|
-
|
|
4035
|
-
|
|
4523
|
+
applyListSort(resultQueryBuilder, {
|
|
4524
|
+
sort,
|
|
4525
|
+
fields: {
|
|
4526
|
+
[exports.ChangeLogSortField.CHANGE_TYPE]: changeTypeRank,
|
|
4527
|
+
[exports.ChangeLogSortField.MATERIAL_KEY]: 'cl_material.key',
|
|
4528
|
+
[exports.ChangeLogSortField.MATERIAL_DESCRIPTION]: 'cl_material.description',
|
|
4529
|
+
[exports.ChangeLogSortField.BATCH_KEY]: 'cl_batch.key',
|
|
4530
|
+
[exports.ChangeLogSortField.LOCATION_KEY]: 'cl_location.key',
|
|
4531
|
+
// The magnitude, as `changeLogs` displays it: the sign is the change
|
|
4532
|
+
// type's to carry, and sorting it would put every outflow first.
|
|
4533
|
+
[exports.ChangeLogSortField.QUANTITY]: 'ABS(stock.quantity)',
|
|
4534
|
+
[exports.ChangeLogSortField.BASE_UNIT]: 'cl_unit.key',
|
|
4535
|
+
[exports.ChangeLogSortField.CREATED_AT]: 'stock."createdAt"',
|
|
4536
|
+
},
|
|
4537
|
+
defaultOrder: {
|
|
4538
|
+
field: exports.ChangeLogSortField.CREATED_AT,
|
|
4539
|
+
order: exports.SortOrder.DESC,
|
|
4540
|
+
},
|
|
4541
|
+
tiebreaker: 'stock.id',
|
|
4542
|
+
mode: 'raw',
|
|
4543
|
+
});
|
|
4544
|
+
const items = await resultQueryBuilder.getRawMany();
|
|
4036
4545
|
return [items, count];
|
|
4037
4546
|
}
|
|
4038
4547
|
};
|
|
@@ -4214,6 +4723,27 @@ exports.WmsSequenceService = tslib.__decorate([
|
|
|
4214
4723
|
tslib.__metadata("design:paramtypes", [typeorm.DataSource, Object])
|
|
4215
4724
|
], exports.WmsSequenceService);
|
|
4216
4725
|
|
|
4726
|
+
/** ORDER BY per sort field; `sort_type` / `sort_location` are joined on demand. */
|
|
4727
|
+
const LOADER_SORT_FIELDS = {
|
|
4728
|
+
[exports.LoaderSortField.SERIAL_ID]: 'loader.serialId',
|
|
4729
|
+
[exports.LoaderSortField.TYPE_DESCRIPTION]: 'sort_type.description',
|
|
4730
|
+
[exports.LoaderSortField.LOCATION_KEY]: 'sort_location.key',
|
|
4731
|
+
[exports.LoaderSortField.LENGTH]: 'loader.length',
|
|
4732
|
+
[exports.LoaderSortField.WIDTH]: 'loader.width',
|
|
4733
|
+
[exports.LoaderSortField.HEIGHT]: 'loader.height',
|
|
4734
|
+
[exports.LoaderSortField.SIZE_UNIT]: 'loader.sizeUnit',
|
|
4735
|
+
[exports.LoaderSortField.VOLUME]: 'loader.volume',
|
|
4736
|
+
[exports.LoaderSortField.VOLUME_UNIT]: 'loader.volumeUnit',
|
|
4737
|
+
[exports.LoaderSortField.NOTE]: 'loader.note',
|
|
4738
|
+
[exports.LoaderSortField.IS_ACTIVE]: 'loader.isActive',
|
|
4739
|
+
[exports.LoaderSortField.CREATED_AT]: 'loader.createdAt',
|
|
4740
|
+
};
|
|
4741
|
+
const LOADER_TYPE_SORT_FIELDS = {
|
|
4742
|
+
[exports.LoaderTypeSortField.KEY]: 'loader_type.key',
|
|
4743
|
+
[exports.LoaderTypeSortField.DESCRIPTION]: 'loader_type.description',
|
|
4744
|
+
[exports.LoaderTypeSortField.IS_ACTIVE]: 'loader_type.isActive',
|
|
4745
|
+
[exports.LoaderTypeSortField.CREATED_AT]: 'loader_type.createdAt',
|
|
4746
|
+
};
|
|
4217
4747
|
/**
|
|
4218
4748
|
* Service for managing loaders and their types
|
|
4219
4749
|
* Supports dynamic entity injection for customization
|
|
@@ -4327,7 +4857,7 @@ exports.LoaderService = class LoaderService {
|
|
|
4327
4857
|
return this.sequenceService.reserve(`${prefix}_SEQ`, count, transactionManager, { consecutive: true, maxValue });
|
|
4328
4858
|
});
|
|
4329
4859
|
}
|
|
4330
|
-
findManyLoaders(options) {
|
|
4860
|
+
async findManyLoaders(options) {
|
|
4331
4861
|
const queryBuilder = this.dataSource
|
|
4332
4862
|
.getRepository(this.loaderEntity)
|
|
4333
4863
|
.createQueryBuilder('loader');
|
|
@@ -4386,13 +4916,38 @@ exports.LoaderService = class LoaderService {
|
|
|
4386
4916
|
value: `%${value}%`,
|
|
4387
4917
|
});
|
|
4388
4918
|
}
|
|
4919
|
+
// Joined by class (the location through `WmsEntities`: it may be a host override) and only when that
|
|
4920
|
+
// column is asked for; both joins are on a primary key, one row per loader.
|
|
4921
|
+
// Selected because the paginated DISTINCT subquery must see the column.
|
|
4922
|
+
if (options.sort?.field === exports.LoaderSortField.TYPE_DESCRIPTION) {
|
|
4923
|
+
queryBuilder
|
|
4924
|
+
.leftJoin(
|
|
4925
|
+
// Loader types are owned by this package (no base override), so the
|
|
4926
|
+
// class is the table; a host subclass would share it.
|
|
4927
|
+
exports.LoaderTypeEntityClass, 'sort_type', 'sort_type.id = loader.typeId')
|
|
4928
|
+
.addSelect('sort_type.description');
|
|
4929
|
+
}
|
|
4930
|
+
if (options.sort?.field === exports.LoaderSortField.LOCATION_KEY) {
|
|
4931
|
+
queryBuilder
|
|
4932
|
+
.leftJoin(this.entities.location, 'sort_location', 'sort_location.id = loader.locationId')
|
|
4933
|
+
.addSelect('sort_location.key');
|
|
4934
|
+
}
|
|
4935
|
+
applyListSort(queryBuilder, {
|
|
4936
|
+
sort: options.sort,
|
|
4937
|
+
fields: LOADER_SORT_FIELDS,
|
|
4938
|
+
defaultOrder: {
|
|
4939
|
+
field: exports.LoaderSortField.CREATED_AT,
|
|
4940
|
+
order: exports.SortOrder.DESC,
|
|
4941
|
+
},
|
|
4942
|
+
tiebreaker: 'loader.id',
|
|
4943
|
+
});
|
|
4389
4944
|
if (options.offset !== undefined && options.offset >= 0)
|
|
4390
4945
|
queryBuilder.skip(options.offset);
|
|
4391
4946
|
if (options.limit !== undefined && options.limit > 0)
|
|
4392
4947
|
queryBuilder.take(options.limit);
|
|
4393
4948
|
return queryBuilder.getManyAndCount();
|
|
4394
4949
|
}
|
|
4395
|
-
findManyLoaderTypes(options) {
|
|
4950
|
+
async findManyLoaderTypes(options) {
|
|
4396
4951
|
const queryBuilder = this.dataSource
|
|
4397
4952
|
.getRepository(this.loaderTypeEntity)
|
|
4398
4953
|
.createQueryBuilder('loader_type');
|
|
@@ -4415,6 +4970,15 @@ exports.LoaderService = class LoaderService {
|
|
|
4415
4970
|
value: `%${value}%`,
|
|
4416
4971
|
});
|
|
4417
4972
|
}
|
|
4973
|
+
applyListSort(queryBuilder, {
|
|
4974
|
+
sort: options.sort,
|
|
4975
|
+
fields: LOADER_TYPE_SORT_FIELDS,
|
|
4976
|
+
defaultOrder: {
|
|
4977
|
+
field: exports.LoaderTypeSortField.CREATED_AT,
|
|
4978
|
+
order: exports.SortOrder.DESC,
|
|
4979
|
+
},
|
|
4980
|
+
tiebreaker: 'loader_type.id',
|
|
4981
|
+
});
|
|
4418
4982
|
if (options.offset !== undefined && options.offset >= 0)
|
|
4419
4983
|
queryBuilder.skip(options.offset);
|
|
4420
4984
|
if (options.limit !== undefined && options.limit > 0)
|
|
@@ -4432,6 +4996,14 @@ exports.LoaderService = tslib.__decorate([
|
|
|
4432
4996
|
exports.WmsEntities, Object, Object, Object])
|
|
4433
4997
|
], exports.LoaderService);
|
|
4434
4998
|
|
|
4999
|
+
/** ORDER BY expressions per sort field; `baseUnit` is joined on demand. */
|
|
5000
|
+
const MATERIAL_SORT_FIELDS = {
|
|
5001
|
+
[exports.MaterialSortField.KEY]: 'material.key',
|
|
5002
|
+
[exports.MaterialSortField.DESCRIPTION]: 'material.description',
|
|
5003
|
+
[exports.MaterialSortField.BASE_UNIT]: 'baseUnit.key',
|
|
5004
|
+
[exports.MaterialSortField.IS_ACTIVE]: 'material.isActive',
|
|
5005
|
+
[exports.MaterialSortField.CREATED_AT]: 'material.createdAt',
|
|
5006
|
+
};
|
|
4435
5007
|
/**
|
|
4436
5008
|
* Service for managing materials and their units
|
|
4437
5009
|
* Supports dynamic entity injection for customization
|
|
@@ -4515,7 +5087,7 @@ exports.MaterialService = class MaterialService {
|
|
|
4515
5087
|
}
|
|
4516
5088
|
return updated;
|
|
4517
5089
|
}
|
|
4518
|
-
findMany(options) {
|
|
5090
|
+
async findMany(options) {
|
|
4519
5091
|
const queryBuilder = this.dataSource
|
|
4520
5092
|
.getRepository(this.materialEntity)
|
|
4521
5093
|
.createQueryBuilder('material');
|
|
@@ -4537,6 +5109,27 @@ exports.MaterialService = class MaterialService {
|
|
|
4537
5109
|
value: `%${value}%`,
|
|
4538
5110
|
});
|
|
4539
5111
|
}
|
|
5112
|
+
// `materials.baseUnit` holds the unit's id; sorting by it would order by
|
|
5113
|
+
// uuid. Join the unit (by class, so the table prefix and the paginated
|
|
5114
|
+
// DISTINCT subquery both resolve it) and select its key, only when asked —
|
|
5115
|
+
// the join is one row per material (`units.id` is the primary key).
|
|
5116
|
+
if (options.sort?.field === exports.MaterialSortField.BASE_UNIT) {
|
|
5117
|
+
queryBuilder
|
|
5118
|
+
.leftJoin(exports.UnitEntityClass, 'baseUnit',
|
|
5119
|
+
// `CAST(...)`, not `::text`: TypeORM only rewrites `alias.property`
|
|
5120
|
+
// when a space, `=`, `)` or `,` follows it.
|
|
5121
|
+
'CAST(baseUnit.id AS text) = material.baseUnit')
|
|
5122
|
+
.addSelect('baseUnit.key');
|
|
5123
|
+
}
|
|
5124
|
+
applyListSort(queryBuilder, {
|
|
5125
|
+
sort: options.sort,
|
|
5126
|
+
fields: MATERIAL_SORT_FIELDS,
|
|
5127
|
+
defaultOrder: {
|
|
5128
|
+
field: exports.MaterialSortField.CREATED_AT,
|
|
5129
|
+
order: exports.SortOrder.DESC,
|
|
5130
|
+
},
|
|
5131
|
+
tiebreaker: 'material.id',
|
|
5132
|
+
});
|
|
4540
5133
|
if (options.offset !== undefined && options.offset >= 0)
|
|
4541
5134
|
queryBuilder.skip(options.offset);
|
|
4542
5135
|
if (options.limit !== undefined && options.limit > 0)
|
|
@@ -4826,6 +5419,23 @@ exports.HelperService = tslib.__decorate([
|
|
|
4826
5419
|
* T - Receive Inventory Order entity type
|
|
4827
5420
|
* K - Receive Inventory Order Item entity type
|
|
4828
5421
|
*/
|
|
5422
|
+
/**
|
|
5423
|
+
* ORDER BY per sort field. Raw mode: the list reads with `getRawMany`, and
|
|
5424
|
+
* `status` is the `order_status` join's computed column — ranked by lifecycle
|
|
5425
|
+
* rather than spelled, since its values sort alphabetically into nonsense.
|
|
5426
|
+
*/
|
|
5427
|
+
const RECEIVE_ORDER_SORT_FIELDS = {
|
|
5428
|
+
[exports.ReceiveInventoryOrderSortField.STATUS]: `(CASE order_status.status
|
|
5429
|
+
WHEN '${exports.ReceiveInventoryOrderStatus.PENDING}' THEN 0
|
|
5430
|
+
WHEN '${exports.ReceiveInventoryOrderStatus.PARTIAL_RECEIVED}' THEN 1
|
|
5431
|
+
WHEN '${exports.ReceiveInventoryOrderStatus.RECEIVED}' THEN 2
|
|
5432
|
+
WHEN '${exports.ReceiveInventoryOrderStatus.REMOVED}' THEN 3
|
|
5433
|
+
END)`,
|
|
5434
|
+
[exports.ReceiveInventoryOrderSortField.KEY]: 'orders.key',
|
|
5435
|
+
[exports.ReceiveInventoryOrderSortField.CREATED_BY]: 'orders."createdBy"',
|
|
5436
|
+
[exports.ReceiveInventoryOrderSortField.CREATED_AT]: 'orders."createdAt"',
|
|
5437
|
+
[exports.ReceiveInventoryOrderSortField.DESCRIPTION]: 'orders.description',
|
|
5438
|
+
};
|
|
4829
5439
|
exports.ReceiveInventoryOrderService = class ReceiveInventoryOrderService {
|
|
4830
5440
|
dataSource;
|
|
4831
5441
|
entities;
|
|
@@ -5068,9 +5678,18 @@ exports.ReceiveInventoryOrderService = class ReceiveInventoryOrderService {
|
|
|
5068
5678
|
// `offset`/`limit` go straight into the SQL. The join is one row per
|
|
5069
5679
|
// order, so a page is exactly `limit` orders — and a page is only a page
|
|
5070
5680
|
// with a stable order underneath it.
|
|
5071
|
-
|
|
5072
|
-
|
|
5073
|
-
|
|
5681
|
+
// After `getCount()`, which cannot carry an ORDER BY on the computed
|
|
5682
|
+
// column. The join is one row per order, so a page is exactly `limit`.
|
|
5683
|
+
applyListSort(queryBuilder, {
|
|
5684
|
+
sort: options.sort,
|
|
5685
|
+
fields: RECEIVE_ORDER_SORT_FIELDS,
|
|
5686
|
+
defaultOrder: {
|
|
5687
|
+
field: exports.ReceiveInventoryOrderSortField.CREATED_AT,
|
|
5688
|
+
order: exports.SortOrder.DESC,
|
|
5689
|
+
},
|
|
5690
|
+
tiebreaker: 'orders.id',
|
|
5691
|
+
mode: 'raw',
|
|
5692
|
+
});
|
|
5074
5693
|
if (options.offset !== undefined && options.offset >= 0)
|
|
5075
5694
|
queryBuilder.offset(options.offset);
|
|
5076
5695
|
if (options.limit !== undefined && options.limit > 0)
|
|
@@ -5251,6 +5870,23 @@ exports.ReceiveInventoryOrderService = tslib.__decorate([
|
|
|
5251
5870
|
* T - Ship Inventory Order entity type
|
|
5252
5871
|
* K - Ship Inventory Order Item entity type
|
|
5253
5872
|
*/
|
|
5873
|
+
/**
|
|
5874
|
+
* ORDER BY per sort field. Raw mode: the list reads with `getRawMany`, and
|
|
5875
|
+
* `status` is the `order_status` join's computed column — ranked by lifecycle
|
|
5876
|
+
* rather than spelled, since its values sort alphabetically into nonsense.
|
|
5877
|
+
*/
|
|
5878
|
+
const SHIP_ORDER_SORT_FIELDS = {
|
|
5879
|
+
[exports.ShipInventoryOrderSortField.STATUS]: `(CASE order_status.status
|
|
5880
|
+
WHEN '${exports.ShipInventoryOrderStatus.PENDING}' THEN 0
|
|
5881
|
+
WHEN '${exports.ShipInventoryOrderStatus.PARTIAL_SHIPPED}' THEN 1
|
|
5882
|
+
WHEN '${exports.ShipInventoryOrderStatus.SHIPPED}' THEN 2
|
|
5883
|
+
WHEN '${exports.ShipInventoryOrderStatus.REMOVED}' THEN 3
|
|
5884
|
+
END)`,
|
|
5885
|
+
[exports.ShipInventoryOrderSortField.KEY]: 'orders.key',
|
|
5886
|
+
[exports.ShipInventoryOrderSortField.CREATED_BY]: 'orders."createdBy"',
|
|
5887
|
+
[exports.ShipInventoryOrderSortField.CREATED_AT]: 'orders."createdAt"',
|
|
5888
|
+
[exports.ShipInventoryOrderSortField.DESCRIPTION]: 'orders.description',
|
|
5889
|
+
};
|
|
5254
5890
|
exports.ShipInventoryOrderService = class ShipInventoryOrderService {
|
|
5255
5891
|
dataSource;
|
|
5256
5892
|
entities;
|
|
@@ -5702,9 +6338,18 @@ exports.ShipInventoryOrderService = class ShipInventoryOrderService {
|
|
|
5702
6338
|
// Raw query with a join (see ReceiveInventoryOrderService.findMany):
|
|
5703
6339
|
// `skip`/`take` would be dropped silently, `offset`/`limit` are honoured.
|
|
5704
6340
|
// `order_status` is one row per order, so the page size is exact.
|
|
5705
|
-
|
|
5706
|
-
|
|
5707
|
-
|
|
6341
|
+
// After `getCount()`, which cannot carry an ORDER BY on the computed
|
|
6342
|
+
// column. The join is one row per order, so a page is exactly `limit`.
|
|
6343
|
+
applyListSort(queryBuilder, {
|
|
6344
|
+
sort: options.sort,
|
|
6345
|
+
fields: SHIP_ORDER_SORT_FIELDS,
|
|
6346
|
+
defaultOrder: {
|
|
6347
|
+
field: exports.ShipInventoryOrderSortField.CREATED_AT,
|
|
6348
|
+
order: exports.SortOrder.DESC,
|
|
6349
|
+
},
|
|
6350
|
+
tiebreaker: 'orders.id',
|
|
6351
|
+
mode: 'raw',
|
|
6352
|
+
});
|
|
5708
6353
|
if (options.offset !== undefined && options.offset >= 0)
|
|
5709
6354
|
queryBuilder.offset(options.offset);
|
|
5710
6355
|
if (options.limit !== undefined && options.limit > 0)
|
|
@@ -5823,6 +6468,12 @@ exports.ShipInventoryOrderService = tslib.__decorate([
|
|
|
5823
6468
|
exports.StockService, Object, Object, Object, Object])
|
|
5824
6469
|
], exports.ShipInventoryOrderService);
|
|
5825
6470
|
|
|
6471
|
+
const LOCATION_SORT_FIELDS = {
|
|
6472
|
+
[exports.LocationSortField.KEY]: 'location.key',
|
|
6473
|
+
[exports.LocationSortField.DESCRIPTION]: 'location.description',
|
|
6474
|
+
[exports.LocationSortField.IS_ACTIVE]: 'location.isActive',
|
|
6475
|
+
[exports.LocationSortField.CREATED_AT]: 'location.createdAt',
|
|
6476
|
+
};
|
|
5826
6477
|
exports.LocationService = class LocationService {
|
|
5827
6478
|
dataSource;
|
|
5828
6479
|
locationEntity;
|
|
@@ -5887,6 +6538,15 @@ exports.LocationService = class LocationService {
|
|
|
5887
6538
|
value: `%${value}%`,
|
|
5888
6539
|
});
|
|
5889
6540
|
}
|
|
6541
|
+
applyListSort(queryBuilder, {
|
|
6542
|
+
sort: options.sort,
|
|
6543
|
+
fields: LOCATION_SORT_FIELDS,
|
|
6544
|
+
defaultOrder: {
|
|
6545
|
+
field: exports.LocationSortField.CREATED_AT,
|
|
6546
|
+
order: exports.SortOrder.DESC,
|
|
6547
|
+
},
|
|
6548
|
+
tiebreaker: 'location.id',
|
|
6549
|
+
});
|
|
5890
6550
|
if (options.offset !== undefined && options.offset >= 0)
|
|
5891
6551
|
queryBuilder.skip(options.offset);
|
|
5892
6552
|
if (options.limit !== undefined && options.limit > 0)
|
|
@@ -5914,6 +6574,13 @@ exports.UnitService = tslib.__decorate([
|
|
|
5914
6574
|
tslib.__metadata("design:paramtypes", [typeorm.DataSource])
|
|
5915
6575
|
], exports.UnitService);
|
|
5916
6576
|
|
|
6577
|
+
const TRANSFER_ORDER_SORT_FIELDS = {
|
|
6578
|
+
[exports.TransferOrderSortField.KEY]: 'to.key',
|
|
6579
|
+
[exports.TransferOrderSortField.RECEIVER]: 'to.receiver',
|
|
6580
|
+
[exports.TransferOrderSortField.DESCRIPTION]: 'to.description',
|
|
6581
|
+
[exports.TransferOrderSortField.CREATED_BY]: 'to.createdBy',
|
|
6582
|
+
[exports.TransferOrderSortField.CREATED_AT]: 'to.createdAt',
|
|
6583
|
+
};
|
|
5917
6584
|
/**
|
|
5918
6585
|
* What an item still has reserved and not yet executed, in base units.
|
|
5919
6586
|
*
|
|
@@ -6256,7 +6923,7 @@ exports.TransferOrderService = class TransferOrderService {
|
|
|
6256
6923
|
}
|
|
6257
6924
|
return updated;
|
|
6258
6925
|
}
|
|
6259
|
-
findMany(options) {
|
|
6926
|
+
async findMany(options) {
|
|
6260
6927
|
const queryBuilder = this.dataSource
|
|
6261
6928
|
.getRepository(this.transferOrderEntity)
|
|
6262
6929
|
.createQueryBuilder('to');
|
|
@@ -6333,6 +7000,15 @@ exports.TransferOrderService = class TransferOrderService {
|
|
|
6333
7000
|
WHERE to_tgt_ldr_items."orderId" = to.id
|
|
6334
7001
|
AND to_tgt_ldr."serialId" ILIKE :targetLoaderKey
|
|
6335
7002
|
)`, { targetLoaderKey: `%${options.targetLoaderKey}%` });
|
|
7003
|
+
applyListSort(queryBuilder, {
|
|
7004
|
+
sort: options.sort,
|
|
7005
|
+
fields: TRANSFER_ORDER_SORT_FIELDS,
|
|
7006
|
+
defaultOrder: {
|
|
7007
|
+
field: exports.TransferOrderSortField.CREATED_AT,
|
|
7008
|
+
order: exports.SortOrder.DESC,
|
|
7009
|
+
},
|
|
7010
|
+
tiebreaker: 'to.id',
|
|
7011
|
+
});
|
|
6336
7012
|
if (options.offset !== undefined && options.offset >= 0)
|
|
6337
7013
|
queryBuilder.skip(options.offset);
|
|
6338
7014
|
if (options.limit !== undefined && options.limit > 0)
|
|
@@ -6678,6 +7354,11 @@ exports.HoldInventoryOrderService = class HoldInventoryOrderService {
|
|
|
6678
7354
|
queryBuilder.innerJoin('to.items', 'ld_items', 'ld_items.loaderId = :loaderId', {
|
|
6679
7355
|
loaderId: options.loaderId,
|
|
6680
7356
|
});
|
|
7357
|
+
// No UI sorts this list, so it takes no `sort`; it still needs a fixed
|
|
7358
|
+
// order or `skip`/`take` pages can repeat or skip orders. Property paths,
|
|
7359
|
+
// not quoted columns: the item joins above put the paginated DISTINCT
|
|
7360
|
+
// subquery in play, which can only carry those.
|
|
7361
|
+
queryBuilder.orderBy('to.createdAt', 'DESC').addOrderBy('to.id', 'ASC');
|
|
6681
7362
|
if (options.offset !== undefined && options.offset >= 0)
|
|
6682
7363
|
queryBuilder.skip(options.offset);
|
|
6683
7364
|
if (options.limit !== undefined && options.limit > 0)
|
|
@@ -7006,6 +7687,11 @@ exports.AllocateInventoryOrderService = class AllocateInventoryOrderService {
|
|
|
7006
7687
|
queryBuilder.innerJoin('to.items', 'ld_items', 'ld_items.loaderId = :loaderId', {
|
|
7007
7688
|
loaderId: options.loaderId,
|
|
7008
7689
|
});
|
|
7690
|
+
// No UI sorts this list, so it takes no `sort`; it still needs a fixed
|
|
7691
|
+
// order or `skip`/`take` pages can repeat or skip orders. Property paths,
|
|
7692
|
+
// not quoted columns: the item joins above put the paginated DISTINCT
|
|
7693
|
+
// subquery in play, which can only carry those.
|
|
7694
|
+
queryBuilder.orderBy('to.createdAt', 'DESC').addOrderBy('to.id', 'ASC');
|
|
7009
7695
|
if (options.offset !== undefined && options.offset >= 0)
|
|
7010
7696
|
queryBuilder.skip(options.offset);
|
|
7011
7697
|
if (options.limit !== undefined && options.limit > 0)
|
|
@@ -7301,6 +7987,11 @@ exports.MergeBatchOrderService = tslib.__decorate([
|
|
|
7301
7987
|
exports.StockService, Object, Object])
|
|
7302
7988
|
], exports.MergeBatchOrderService);
|
|
7303
7989
|
|
|
7990
|
+
const CONSUMPTION_ORDER_SORT_FIELDS = {
|
|
7991
|
+
[exports.ConsumptionOrderSortField.KEY]: 'consumption.key',
|
|
7992
|
+
[exports.ConsumptionOrderSortField.DESCRIPTION]: 'consumption.description',
|
|
7993
|
+
[exports.ConsumptionOrderSortField.CREATED_AT]: 'consumption.createdAt',
|
|
7994
|
+
};
|
|
7304
7995
|
/**
|
|
7305
7996
|
* Material handed to a process that consumes it: issue it out, take back what
|
|
7306
7997
|
* came home, settle what was used.
|
|
@@ -7697,16 +8388,18 @@ exports.ConsumptionOrderService = class ConsumptionOrderService {
|
|
|
7697
8388
|
createdAtTo: options.createdAtTo,
|
|
7698
8389
|
});
|
|
7699
8390
|
}
|
|
7700
|
-
|
|
7701
|
-
|
|
7702
|
-
|
|
7703
|
-
|
|
7704
|
-
|
|
7705
|
-
|
|
7706
|
-
|
|
7707
|
-
|
|
7708
|
-
|
|
7709
|
-
|
|
8391
|
+
// Property paths only (entity mode): `getManyAndCount` with the joined
|
|
8392
|
+
// items and a limit wraps the query in a `SELECT DISTINCT` over the root
|
|
8393
|
+
// ids, and raw SQL there renders `distinctAlias.consumption_"createdAt"`.
|
|
8394
|
+
applyListSort(queryBuilder, {
|
|
8395
|
+
sort: options.sort,
|
|
8396
|
+
fields: CONSUMPTION_ORDER_SORT_FIELDS,
|
|
8397
|
+
defaultOrder: {
|
|
8398
|
+
field: exports.ConsumptionOrderSortField.CREATED_AT,
|
|
8399
|
+
order: exports.SortOrder.DESC,
|
|
8400
|
+
},
|
|
8401
|
+
tiebreaker: 'consumption.id',
|
|
8402
|
+
});
|
|
7710
8403
|
if (options.offset !== undefined && options.offset >= 0) {
|
|
7711
8404
|
queryBuilder.skip(options.offset);
|
|
7712
8405
|
}
|
|
@@ -8588,6 +9281,38 @@ exports.SaleOrderService = tslib.__decorate([
|
|
|
8588
9281
|
tslib.__metadata("design:paramtypes", [typeorm.DataSource])
|
|
8589
9282
|
], exports.SaleOrderService);
|
|
8590
9283
|
|
|
9284
|
+
const INVENTORY_COUNT_ORDER_SORT_FIELDS = {
|
|
9285
|
+
[exports.InventoryCountOrderSortField.NAME]: 'count_order.name',
|
|
9286
|
+
// A PostgreSQL enum: ORDER BY follows its declaration order (the lifecycle).
|
|
9287
|
+
[exports.InventoryCountOrderSortField.STATUS]: 'count_order.status',
|
|
9288
|
+
[exports.InventoryCountOrderSortField.COUNT_DATE]: 'count_order.countDate',
|
|
9289
|
+
[exports.InventoryCountOrderSortField.CREATED_BY]: 'count_order.createdBy',
|
|
9290
|
+
[exports.InventoryCountOrderSortField.CREATED_AT]: 'count_order.createdAt',
|
|
9291
|
+
};
|
|
9292
|
+
/**
|
|
9293
|
+
* The count sheet reads with `getMany` + `offset`/`limit` over string-table
|
|
9294
|
+
* joins, so these are SQL (raw mode). The three flag fields sort by the same
|
|
9295
|
+
* test the sheet's icons render from.
|
|
9296
|
+
*/
|
|
9297
|
+
const INVENTORY_COUNT_ORDER_ITEM_SORT_FIELDS = {
|
|
9298
|
+
[exports.InventoryCountOrderItemSortField.MATERIAL_KEY]: 'material.key',
|
|
9299
|
+
[exports.InventoryCountOrderItemSortField.MATERIAL_DESCRIPTION]: 'material.description',
|
|
9300
|
+
[exports.InventoryCountOrderItemSortField.BATCH_KEY]: 'batch.key',
|
|
9301
|
+
[exports.InventoryCountOrderItemSortField.LOCATION_KEY]: 'location.key',
|
|
9302
|
+
[exports.InventoryCountOrderItemSortField.LOADER_SERIAL_ID]: 'loader."serialId"',
|
|
9303
|
+
[exports.InventoryCountOrderItemSortField.VENDOR_ID]: 'item."vendorId"',
|
|
9304
|
+
[exports.InventoryCountOrderItemSortField.CUSTOMER_ID]: 'item."customerId"',
|
|
9305
|
+
[exports.InventoryCountOrderItemSortField.SALE_ID]: 'item."saleId"',
|
|
9306
|
+
[exports.InventoryCountOrderItemSortField.SALE_SERIAL_ID]: 'item."saleSerialId"',
|
|
9307
|
+
[exports.InventoryCountOrderItemSortField.IS_ADDITION]: 'item."isAddition"',
|
|
9308
|
+
[exports.InventoryCountOrderItemSortField.HELD]: 'COALESCE(item.held, false)',
|
|
9309
|
+
[exports.InventoryCountOrderItemSortField.IN_TRANSFER]: '(item."transferId" IS NOT NULL)',
|
|
9310
|
+
[exports.InventoryCountOrderItemSortField.INSPECTION]: `(CASE
|
|
9311
|
+
WHEN item."requiresInspection" = true AND item."inspectionResult" IS NULL THEN 2
|
|
9312
|
+
WHEN item."inspectionResult" = false THEN 1
|
|
9313
|
+
ELSE 0
|
|
9314
|
+
END)`,
|
|
9315
|
+
};
|
|
8591
9316
|
/**
|
|
8592
9317
|
* Inventory counting: compare the ledger against what is physically there, then
|
|
8593
9318
|
* adjust the ledger to match.
|
|
@@ -8825,9 +9550,7 @@ exports.InventoryCountOrderService = class InventoryCountOrderService {
|
|
|
8825
9550
|
// `order."countDate"` and fail to parse; and a camelCase alias would be
|
|
8826
9551
|
// emitted quoted by the query builder while the unquoted references here
|
|
8827
9552
|
// fold to lowercase, so the two would never match.
|
|
8828
|
-
.order.createQueryBuilder('count_order')
|
|
8829
|
-
.orderBy('count_order."countDate"', 'DESC')
|
|
8830
|
-
.addOrderBy('count_order."createdAt"', 'DESC');
|
|
9553
|
+
.order.createQueryBuilder('count_order');
|
|
8831
9554
|
if (options.name) {
|
|
8832
9555
|
query.andWhere('count_order.name ILIKE :name', {
|
|
8833
9556
|
name: `%${options.name}%`,
|
|
@@ -8862,6 +9585,21 @@ exports.InventoryCountOrderService = class InventoryCountOrderService {
|
|
|
8862
9585
|
AND scope."locationId" IN (:...locationIds)
|
|
8863
9586
|
)`, { locationIds: options.locationIds });
|
|
8864
9587
|
}
|
|
9588
|
+
applyListSort(query, {
|
|
9589
|
+
sort: options.sort,
|
|
9590
|
+
fields: INVENTORY_COUNT_ORDER_SORT_FIELDS,
|
|
9591
|
+
defaultOrder: [
|
|
9592
|
+
{
|
|
9593
|
+
field: exports.InventoryCountOrderSortField.COUNT_DATE,
|
|
9594
|
+
order: exports.SortOrder.DESC,
|
|
9595
|
+
},
|
|
9596
|
+
{
|
|
9597
|
+
field: exports.InventoryCountOrderSortField.CREATED_AT,
|
|
9598
|
+
order: exports.SortOrder.DESC,
|
|
9599
|
+
},
|
|
9600
|
+
],
|
|
9601
|
+
tiebreaker: 'count_order.id',
|
|
9602
|
+
});
|
|
8865
9603
|
if (options.offset !== undefined && options.offset >= 0) {
|
|
8866
9604
|
query.skip(options.offset);
|
|
8867
9605
|
}
|
|
@@ -8923,13 +9661,28 @@ exports.InventoryCountOrderService = class InventoryCountOrderService {
|
|
|
8923
9661
|
// into a COUNT, and an ORDER BY on a joined column it does not select makes
|
|
8924
9662
|
// that rewrite fail.
|
|
8925
9663
|
const total = await query.getCount();
|
|
8926
|
-
//
|
|
8927
|
-
//
|
|
8928
|
-
query
|
|
8929
|
-
.
|
|
8930
|
-
|
|
8931
|
-
|
|
8932
|
-
|
|
9664
|
+
// Default: additions first — they are what the operator just typed — then
|
|
9665
|
+
// material and batch; `id` last so paging cannot repeat or skip a line.
|
|
9666
|
+
applyListSort(query, {
|
|
9667
|
+
sort: options.sort,
|
|
9668
|
+
fields: INVENTORY_COUNT_ORDER_ITEM_SORT_FIELDS,
|
|
9669
|
+
defaultOrder: [
|
|
9670
|
+
{
|
|
9671
|
+
field: exports.InventoryCountOrderItemSortField.IS_ADDITION,
|
|
9672
|
+
order: exports.SortOrder.DESC,
|
|
9673
|
+
},
|
|
9674
|
+
{
|
|
9675
|
+
field: exports.InventoryCountOrderItemSortField.MATERIAL_KEY,
|
|
9676
|
+
order: exports.SortOrder.ASC,
|
|
9677
|
+
},
|
|
9678
|
+
{
|
|
9679
|
+
field: exports.InventoryCountOrderItemSortField.BATCH_KEY,
|
|
9680
|
+
order: exports.SortOrder.ASC,
|
|
9681
|
+
},
|
|
9682
|
+
],
|
|
9683
|
+
tiebreaker: 'item.id',
|
|
9684
|
+
mode: 'raw',
|
|
9685
|
+
});
|
|
8933
9686
|
// `limit`/`offset` rather than `take`/`skip`: the latter wraps the query in a
|
|
8934
9687
|
// DISTINCT subquery to survive one-to-many joins, and then cannot map an
|
|
8935
9688
|
// ORDER BY on a joined column into it. Every join here is many-to-one, so no
|
|
@@ -9327,6 +10080,8 @@ exports.ScrapeService = tslib.__decorate([
|
|
|
9327
10080
|
exports.StockService, Object, Object])
|
|
9328
10081
|
], exports.ScrapeService);
|
|
9329
10082
|
|
|
10083
|
+
/** Ancestor walk limit; a deeper chain than this is treated as corrupt data. */
|
|
10084
|
+
const LOCATION_MAP_PREVIEW_MAX_DEPTH = 32;
|
|
9330
10085
|
exports.WarehouseMapDataService = class WarehouseMapDataService {
|
|
9331
10086
|
dataSource;
|
|
9332
10087
|
entities;
|
|
@@ -9337,6 +10092,64 @@ exports.WarehouseMapDataService = class WarehouseMapDataService {
|
|
|
9337
10092
|
this.entities = entities;
|
|
9338
10093
|
this.warehouseMapDataRepository = this.dataSource.getRepository(this.entities.warehouseMap);
|
|
9339
10094
|
}
|
|
10095
|
+
/**
|
|
10096
|
+
* The map that draws `locationKey`, plus the breadcrumb from the root to it.
|
|
10097
|
+
*
|
|
10098
|
+
* The map hierarchy is kept apart from `locations.parentId`: a map's id is the
|
|
10099
|
+
* key of the location it drills into, and `mapData.ranges[].id` names the
|
|
10100
|
+
* child locations drawn on it. So "where is X drawn" is "which map has a range
|
|
10101
|
+
* whose id is X", and a map's parent is the map that draws the map's own id.
|
|
10102
|
+
*
|
|
10103
|
+
* Returns `null` when no map draws the location.
|
|
10104
|
+
*
|
|
10105
|
+
* When a key is drawn on several maps (the editor does not forbid it), the map
|
|
10106
|
+
* with the lowest id wins — byte order (`COLLATE "C"`), so every deployment
|
|
10107
|
+
* agrees regardless of its database locale, rather than whatever the planner
|
|
10108
|
+
* returns first. The same rule picks a parent at every step of the walk.
|
|
10109
|
+
*
|
|
10110
|
+
* The walk stops at a map nobody draws, at an id it has already visited
|
|
10111
|
+
* (a cycle in hand-edited map data), or after
|
|
10112
|
+
* `LOCATION_MAP_PREVIEW_MAX_DEPTH` maps.
|
|
10113
|
+
*/
|
|
10114
|
+
async findLocationMapPreview(locationKey, manager) {
|
|
10115
|
+
const repository = (manager ?? this.dataSource.manager).getRepository(this.entities.warehouseMap);
|
|
10116
|
+
const holder = await this.findMapDrawing(repository, locationKey);
|
|
10117
|
+
if (!holder)
|
|
10118
|
+
return null;
|
|
10119
|
+
// `ancestors` doubles as the visited set: the walk only ever prepends.
|
|
10120
|
+
const walk = async (ancestors, currentId) => {
|
|
10121
|
+
if (ancestors.length >= LOCATION_MAP_PREVIEW_MAX_DEPTH)
|
|
10122
|
+
return ancestors;
|
|
10123
|
+
const parent = await this.findMapDrawing(repository, currentId);
|
|
10124
|
+
if (!parent || ancestors.includes(parent.id))
|
|
10125
|
+
return ancestors;
|
|
10126
|
+
return walk([parent.id, ...ancestors], parent.id);
|
|
10127
|
+
};
|
|
10128
|
+
const path = await walk([holder.id], holder.id);
|
|
10129
|
+
return {
|
|
10130
|
+
locationKey,
|
|
10131
|
+
mapKey: holder.id,
|
|
10132
|
+
path,
|
|
10133
|
+
mapData: holder.mapData,
|
|
10134
|
+
};
|
|
10135
|
+
}
|
|
10136
|
+
/** The lowest-id map whose ranges include one with `id = rangeId`. */
|
|
10137
|
+
async findMapDrawing(repository, rangeId) {
|
|
10138
|
+
const alias = 'map';
|
|
10139
|
+
const { metadata } = repository;
|
|
10140
|
+
const escape = (name) => repository.manager.connection.driver.escape(name);
|
|
10141
|
+
const mapDataColumn = metadata.findColumnWithPropertyName('mapData')?.databaseName;
|
|
10142
|
+
const idColumn = metadata.findColumnWithPropertyName('id')?.databaseName;
|
|
10143
|
+
if (!mapDataColumn || !idColumn) {
|
|
10144
|
+
throw new Error(`${metadata.name} has no mapData/id column; cannot resolve map previews`);
|
|
10145
|
+
}
|
|
10146
|
+
return repository
|
|
10147
|
+
.createQueryBuilder(alias)
|
|
10148
|
+
.where(`${escape(alias)}.${escape(mapDataColumn)} @> CAST(:needle AS jsonb)`, { needle: JSON.stringify({ ranges: [{ id: rangeId }] }) })
|
|
10149
|
+
.orderBy(`${escape(alias)}.${escape(idColumn)} COLLATE "C"`, 'ASC')
|
|
10150
|
+
.limit(1)
|
|
10151
|
+
.getOne();
|
|
10152
|
+
}
|
|
9340
10153
|
/**
|
|
9341
10154
|
* Seed the default map row.
|
|
9342
10155
|
*
|
|
@@ -10390,6 +11203,8 @@ exports.InventoryCountOrderChangeEntity = InventoryCountOrderChangeEntity;
|
|
|
10390
11203
|
exports.InventoryCountOrderEntity = InventoryCountOrderEntity;
|
|
10391
11204
|
exports.InventoryCountOrderItemEntity = InventoryCountOrderItemEntity;
|
|
10392
11205
|
exports.InventoryCountOrderLocationEntity = InventoryCountOrderLocationEntity;
|
|
11206
|
+
exports.LIST_SORT_NULLS = LIST_SORT_NULLS;
|
|
11207
|
+
exports.LOCATION_MAP_PREVIEW_MAX_DEPTH = LOCATION_MAP_PREVIEW_MAX_DEPTH;
|
|
10393
11208
|
exports.LoaderTypeEntity = LoaderTypeEntity;
|
|
10394
11209
|
exports.LoaderUnitEntity = LoaderUnitEntity;
|
|
10395
11210
|
exports.LoadersEntity = LoadersEntity;
|
|
@@ -10441,9 +11256,11 @@ exports.WMS_EVENT_OPTIONS = WMS_EVENT_OPTIONS;
|
|
|
10441
11256
|
exports.WMS_OPERATION_NAMES = WMS_OPERATION_NAMES;
|
|
10442
11257
|
exports.WMS_STOCK_ENRICH = WMS_STOCK_ENRICH;
|
|
10443
11258
|
exports.WarehouseMapEntity = WarehouseMapEntity;
|
|
11259
|
+
exports.applyListSort = applyListSort;
|
|
10444
11260
|
exports.applyWmsTablePrefix = applyWmsTablePrefix;
|
|
10445
11261
|
exports.collectToScope = collectToScope;
|
|
10446
11262
|
exports.getWmsTablePrefix = getWmsTablePrefix;
|
|
11263
|
+
exports.resolveListSort = resolveListSort;
|
|
10447
11264
|
exports.runInDispatchScope = runInDispatchScope;
|
|
10448
11265
|
exports.runInTransaction = runInTransaction;
|
|
10449
11266
|
exports.withWmsTablePrefix = withWmsTablePrefix;
|