@things-factory/warehouse-base 4.1.18 → 4.1.27

package/server/service/inventory-history/inventory-history-types.ts

@@ -267,3 +267,89 @@ export class NewInventoryHistory {
   @Field(type => Float, { nullable: true })
   unitCost?: number
 }
+
+@ObjectType()
+export class RawInventoryHistoryList {
+  @Field(type => [RawInventoryHistory], { nullable: true })
+  items?: RawInventoryHistory[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+}
+@ObjectType()
+export class RawInventoryHistory {
+  @Field({ nullable: true })
+  sku?: string
+
+  @Field({ nullable: true })
+  productName?: string
+
+  @Field({ nullable: true })
+  productDescription?: string
+
+  @Field({ nullable: true })
+  brand?: string
+
+  @Field(type => Int, { nullable: true })
+  seq?: number
+
+  @Field({ nullable: true })
+  palletId?: string
+
+  @Field({ nullable: true })
+  cartonId?: string
+
+  @Field({ nullable: true })
+  batchId?: string
+
+  @Field({ nullable: true })
+  batchIdRef?: string
+
+  @Field(type => Int, { nullable: true })
+  openingQty?: number
+
+  @Field(type => Int, { nullable: true })
+  qty?: number
+
+  @Field(type => Float, { nullable: true })
+  openingUomValue?: number
+
+  @Field(type => Float, { nullable: true })
+  uomValue?: number
+
+  @Field({ nullable: true })
+  uom?: string
+
+  @Field({ nullable: true })
+  zone?: string
+
+  @Field({ nullable: true })
+  orderNo?: string
+
+  @Field({ nullable: true })
+  refNo?: string
+
+  @Field({ nullable: true })
+  status?: string
+
+  @Field({ nullable: true })
+  transactionType?: string
+
+  @Field({ nullable: true })
+  bizplace?: string
+
+  @Field({ nullable: true })
+  warehouse?: string
+
+  @Field({ nullable: true })
+  location?: string
+
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @Field({ nullable: true })
+  updater?: string
+}

package/server/service/inventory-history/inventory-history.ts

@@ -68,8 +68,8 @@ export class InventoryHistory {
   @Field()
   name: string
 
-  @Column({ nullable: true })
-  @Field({ nullable: true })
+  @Column()
+  @Field()
   palletId: string
 
   @Column({ nullable: true })
@@ -171,6 +171,10 @@ export class InventoryHistory {
   @Field({ nullable: true })
   manufactureYear: number
 
+  @Column('date', { nullable: true })
+  @Field(type => ScalarDate, { nullable: true })
+  manufactureDate: Date
+
   @ManyToOne(type => User, { nullable: true })
   @Field({ nullable: true })
   creator: User

package/server/utils/inventory-util.ts

@@ -5,7 +5,7 @@ import { Bizplace } from '@things-factory/biz-base'
 import { Product } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
 
-import { INVENTORY_STATUS, INVENTORY_TRANSACTION_TYPE, LOCATION_STATUS } from '../constants'
+import { INVENTORY_STATUS, INVENTORY_TRANSACTION_TYPE, LOCATION_STATUS, LOCATION_TYPE } from '../constants'
 import { Inventory, InventoryHistory, Location } from '../service'
 import { InventoryNoGenerator } from '../utils'
 
@@ -90,15 +90,7 @@ export class InventoryUtil {
       inventory = await this.createInventory(inventory)
     }
 
-    await generateInventoryHistory(
-      inventory,
-      refOrder,
-      transactionType,
-      changedQty,
-      changedUom,
-      this.user,
-      this.trxMgr
-    )
+    await generateInventoryHistory(inventory, refOrder, transactionType, changedQty, changedUom, this.user, this.trxMgr)
 
     return inventory
   }
@@ -148,11 +140,11 @@ export async function generateInventoryHistory(
   const lastInvHistory: InventoryHistory = await invHistoryRepo.findOne({
     where: {
       domain: inventory.domain,
-      palletId: inventory.palletId,
+      palletId: inventory.palletId
     },
     order: {
       seq: 'DESC'
-    },
+    }
   })
 
   let seq: number = 0
@@ -165,7 +157,7 @@ export async function generateInventoryHistory(
     seq = lastInvHistory.seq + 1
   }
 
-  let remainQty = ((openingQty || 0) + (qty || 0))
+  let remainQty = (openingQty || 0) + (qty || 0)
 
   let inventoryHistory: any = new InventoryHistory()
 
@@ -373,3 +365,134 @@ export async function getProductBundleInventory(
 
   return result
 }
+
+/**
+ * @description This function will return multiple products
+ * and it is different with @inventoriesByStrategy that returns
+ * inventories for one product only
+ * @param {string} bizplaceId
+ * @param {string} worksheetId
+ * @param {any[]} orderProducts
+ * @param {string} pickingStrategy
+ * @param {[Object]} locationSortingRules
+ * @param {EntityManager} trxMgr
+ * @returns inventories for multiple products
+ */
+export async function getInventoriesByStrategy(
+  domainId: string,
+  bizplaceId: string,
+  worksheetId: string,
+  orderProducts: any[],
+  pickingStrategy: string,
+  locationSortingRules: any[],
+  trxMgr: EntityManager
+): Promise<Inventory[]> {
+  let orderProductsJSON: string = JSON.stringify(orderProducts)
+  let orderBy: string = 'ORDER BY op."productId"'
+
+  let locationSortings: string[] = (locationSortingRules || []).map((rule: { name: string; descOrder: boolean }) => {
+    return `, l.${rule.name} ${rule.descOrder ? 'DESC' : ''}`
+  })
+
+  switch (pickingStrategy.toUpperCase()) {
+    case 'FIFO':
+      orderBy += ', i.created_at'
+      if (locationSortingRules?.length) {
+        orderBy += locationSortings.join('')
+      }
+      break
+
+    case 'LIFO':
+      orderBy += ', i.created_at DESC'
+      if (locationSortingRules?.length) {
+        orderBy += locationSortings.join('')
+      }
+      break
+
+    case 'FEFO':
+      orderBy += ', i.expiration_date'
+      if (locationSortingRules?.length) {
+        orderBy += locationSortings.join('')
+      }
+      break
+
+    case 'LOCATION':
+      if (locationSortingRules?.length) {
+        orderBy += locationSortings.join('')
+      } else orderBy += ', l.name DESC'
+      break
+
+    default:
+      orderBy += ', i.created_at'
+      break
+  }
+
+  await trxMgr.query(
+    `
+    CREATE TEMP TABLE temp_op2(
+      "productId" VARCHAR(50),
+      "batchId" VARCHAR(50),
+      "packingType" VARCHAR(50),
+      "packingSize" INT,
+      "uom" VARCHAR(10),
+      "releaseQty" INT
+    );
+  `
+  )
+
+  await trxMgr.query(
+    `
+    INSERT INTO temp_op2
+    SELECT "productId", "batchId", "packingType", "packingSize", "uom", "releaseQty"
+    FROM JSON_POPULATE_RECORDSET(NULL::temp_op2, $1) js
+  `,
+    [orderProductsJSON]
+  )
+
+  await trxMgr.query(
+    `
+    CREATE TEMP TABLE acc_oi2 AS (
+      SELECT oi.inventory_id, SUM(oi.release_qty) AS total_release_qty, SUM(oi.release_uom_value) AS total_release_uom_value
+      FROM order_inventories oi
+      WHERE oi.status IN ('PENDING','PENDING_RECEIVE','PENDING_WORKSHEET','PENDING_SPLIT')
+      AND oi.bizplace_id = $1
+      AND oi.inventory_id NOTNULL 
+      AND oi.ref_worksheet_id != $2
+      GROUP BY oi.inventory_id
+    )
+  `,
+    [bizplaceId, worksheetId]
+  )
+
+  // get inventories
+  let inventories = await trxMgr.query(
+    `
+    SELECT
+    i.id,
+    op."productId",
+    op."batchId",
+    i.qty - COALESCE(i.locked_qty,0) - COALESCE(foo.total_release_qty,0) AS "remainQty",
+    i.uom_value - COALESCE(i.locked_uom_value,0) - COALESCE(foo.total_release_uom_value,0) AS "remainUomValue",
+    op."packingType",
+    op."packingSize",
+    op."uom"
+    FROM inventories i
+    INNER JOIN locations l ON i.location_id = l.id
+      AND l.TYPE NOT IN ($1, $2)
+    INNER JOIN temp_op2 op ON i.product_id = op."productId"::uuid
+      AND i.batch_id = op."batchId"
+      AND i.packing_type = op."packingType"
+      AND i.packing_size = op."packingSize"
+    LEFT JOIN acc_oi2 foo ON i.id = foo.inventory_id
+    WHERE i.domain_id = $3
+    AND i.bizplace_id = $4
+    AND i.status = $5
+    ${orderBy}
+  `,
+    [LOCATION_TYPE.QUARANTINE, LOCATION_TYPE.RESERVE, domainId, bizplaceId, INVENTORY_STATUS.STORED]
+  )
+
+  await trxMgr.query('DROP TABLE temp_op2, acc_oi2')
+
+  return inventories
+}