@things-factory/sales-base 4.0.22 → 4.0.26

package/server/service/release-good/release-good-query.ts

@@ -7,7 +7,7 @@ import { User } from '@things-factory/auth-base'
 import { Bizplace, getCompanyBizplace, getMyBizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
 import { Product } from '@things-factory/product-base'
 import { buildQuery, Domain, Filter, ListParam, Pagination, Sorting } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
+import { Inventory, LOCATION_TYPE } from '@things-factory/warehouse-base'
 
 import {
   InventoryInfos,
@@ -477,120 +477,10 @@ export class ReleaseGoodQuery {
     @Arg('rawReleaseGoods', type => [NewReleaseGood], { nullable: true }) rawReleaseGoods: NewReleaseGood[],
     @Arg('bizplaceId', type => String) bizplaceId: string
   ): Promise<ReleaseGood[]> {
-    const { domain, tx } = context.state
-    const companyBizplaceId: Bizplace = await getCompanyBizplace(null, null, bizplaceId)
-
-    if (!rawReleaseGoods) return
-
-    const json_oi = JSON.stringify(
-      rawReleaseGoods.map(raw => {
-        return {
-          sku: raw.sku,
-          packing_type: raw.packingType,
-          packing_size: raw.packingSize,
-          uom: raw.uom,
-          release_qty: raw.releaseQty
-        }
-      })
-    )
+    const { tx }: { tx: EntityManager } = context.state
+    const availableItems: any[] = await bulkReleaseGoodsAvailableItemsFunction(rawReleaseGoods, bizplaceId, context, tx)
 
-    await tx.query(
-      `
-        CREATE TEMP TABLE temp_order_products(
-          product_id VARCHAR(50),
-          sku VARCHAR(150),
-          packing_type VARCHAR(50),
-          packing_size INT,
-          uom VARCHAR(10),
-          release_qty INT
-          );
-      `
-    )
-
-    await tx.query(
-      `
-        INSERT INTO temp_order_products
-        SELECT p.id AS product_id, js.sku,
-        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_type ELSE pd.packing_type END,
-        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_size ELSE pd.packing_size END,
-        CASE WHEN js.uom NOTNULL THEN js.uom ELSE pd.uom END,
-        js.release_qty
-        FROM JSON_POPULATE_RECORDSET(NULL::temp_order_products,'${json_oi}') js
-        LEFT JOIN products p ON js.sku = p.sku AND p.bizplace_id = $1
-        LEFT JOIN product_details pd ON p.id = pd.product_id AND pd.is_default = TRUE;
-      `,
-      [companyBizplaceId.id]
-    )
-
-    let availableItems = await tx.query(
-      `
-        SELECT i.product_id, foo.sku, i.batch_id, i.packing_type, i.packing_size, i.uom,
-          SUM(i.qty - COALESCE(i.locked_qty, 0)) - COALESCE(
-            (
-              SELECT SUM(oi.release_qty) FROM order_inventories oi 
-              WHERE (
-                oi.status = 'PENDING'
-                OR oi.status = 'PENDING_RECEIVE'
-                OR oi.status = 'PENDING_WORKSHEET'
-                OR oi.status = 'PENDING_SPLIT'
-              )
-              AND oi.inventory_id IS null
-              AND oi.product_id = i.product_id::uuid
-              AND oi.packing_type = i.packing_type
-              AND oi.uom = i.uom
-              AND oi.domain_id = $1
-              AND oi.bizplace_id = $2
-            ), 0) as "remain_qty",
-          SUM(i.uom_value - COALESCE(i.locked_uom_value, 0)) - COALESCE(
-            (
-              SELECT SUM(oi.release_uom_value) FROM order_inventories oi 
-              WHERE (
-                oi.status = 'PENDING'
-                OR oi.status = 'PENDING_RECEIVE'
-                OR oi.status = 'PENDING_WORKSHEET'
-                OR oi.status = 'PENDING_SPLIT'
-              )
-              AND oi.inventory_id IS null
-              AND oi.product_id = i.product_id::uuid
-              AND oi.packing_type = i.packing_type
-              AND oi.uom = i.uom
-              AND oi.domain_id = $1
-              AND oi.bizplace_id = $2
-            ), 0) as "remain_uom_value"
-        FROM inventories i
-        INNER JOIN (
-          SELECT top.product_id, top.sku, top.packing_type, top.packing_size, top.uom 
-          FROM temp_order_products top
-          GROUP BY top.product_id, top.sku, top.packing_type, top.packing_size, top.uom
-        ) AS foo
-        ON i.product_id = foo.product_id::uuid
-        AND i.packing_type = foo.packing_type
-        AND i.packing_size = foo.packing_size
-        AND i.uom = foo.uom
-        AND i.domain_id = $1
-        AND i.bizplace_id = $2
-        GROUP BY i.product_id, foo.sku, i.batch_id, i.packing_type, i.packing_size, i.uom
-        ORDER BY foo.sku, remain_qty
-      `,
-      [domain.id, bizplaceId]
-    )
-
-    await tx.query('DROP TABLE temp_order_products')
-
-    availableItems = availableItems.map(item => {
-      return {
-        productId: item.product_id,
-        sku: item.sku,
-        batchId: item.batch_id,
-        packingType: item.packing_type,
-        packingSize: item.packing_size,
-        uom: item.uom,
-        remainQty: item.remain_qty,
-        remainUomValue: item.remain_uom_value
-      }
-    })
-
-    return _extractData(rawReleaseGoods, availableItems)
+    return availableItems
   }
 
   @FieldResolver(type => Domain)
@@ -689,6 +579,134 @@ async function dropOITempTable(domain: Domain, tx: EntityManager) {
   await tx.query(`DROP TABLE oi`)
 }
 
+export async function bulkReleaseGoodsAvailableItemsFunction(
+  rawReleaseGoods: any[],
+  bizplaceId: string,
+  context: any,
+  tx?: EntityManager
+): Promise<any[]> {
+  const { domain }: { domain: Domain } = context.state
+  const companyBizplaceId: Bizplace = await getCompanyBizplace(null, null, bizplaceId)
+
+  if (!rawReleaseGoods) return
+  const json_oi = JSON.stringify(
+    rawReleaseGoods.map(raw => {
+      return {
+        sku: raw.sku,
+        packing_type: raw.packingType,
+        packing_size: raw.packingSize,
+        uom: raw.uom,
+        release_qty: raw.releaseQty
+      }
+    })
+  )
+
+  await tx.query(
+    `
+        CREATE TEMP TABLE raw_release_goods(
+          product_id VARCHAR(50),
+          product_detail_id VARCHAR(50),
+          sku VARCHAR(150),
+          product_info VARCHAR(250),
+          packing_type VARCHAR(50),
+          packing_size INT,
+          uom VARCHAR(10),
+          release_qty INT
+        );
+      `
+  )
+
+  await tx.query(
+    `
+        INSERT INTO raw_release_goods
+        SELECT p.id AS product_id,
+        pd.id AS product_detail_id,
+        js.sku,
+        CASE WHEN p.description NOT IN (NULL, '', '-') THEN CONCAT(p.name, '(', p.description, ')')
+          ELSE p.name END AS product_info,
+        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_type ELSE pd.packing_type END,
+        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_size ELSE pd.packing_size END,
+        CASE WHEN js.uom NOTNULL THEN js.uom ELSE pd.uom END
+        FROM JSON_POPULATE_RECORDSET(NULL::raw_release_goods, $1) js
+        LEFT JOIN products p ON js.sku = p.sku AND p.bizplace_id = $2
+        LEFT JOIN product_details pd ON p.id = pd.product_id
+        AND CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL AND js.uom NOTNULL
+          THEN pd.packing_type = js.packing_type AND pd.packing_size = js.packing_size AND pd.uom = js.uom 
+          WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL AND js.uom ISNULL 	
+            THEN pd.packing_type = js.packing_type AND pd.packing_size = js.packing_size AND pd.is_default IS TRUE
+            WHEN js.packing_type ISNULL AND js.packing_size ISNULL AND js.uom NOTNULL
+              THEN pd.uom = js.uom AND pd.is_default IS TRUE ELSE pd.is_default IS TRUE 
+        END;
+      `,
+    [json_oi, companyBizplaceId.id]
+  )
+
+  let availableItems = await tx.query(
+    `
+        WITH inv AS (
+        SELECT i.product_id, foo.product_detail_id, foo.sku, foo.product_info, i.batch_id, i.packing_type, i.packing_size, i.uom,
+          SUM(i.qty - COALESCE(i.locked_qty, 0)) - COALESCE(
+            (
+              SELECT SUM(oi.release_qty) FROM order_inventories oi 
+              WHERE oi.status IN ('PENDING', 'PENDING_RECEIVE', 'PENDING_WORKSHEET', 'PENDING_SPLIT')
+              AND oi.inventory_id IS null
+              AND oi.product_id = i.product_id::uuid
+              AND oi.packing_type = i.packing_type
+              AND oi.uom = i.uom
+              AND oi.domain_id = $1
+              AND oi.bizplace_id = $2
+            ), 0) as "remain_qty",
+          SUM(i.uom_value - COALESCE(i.locked_uom_value, 0)) - COALESCE(
+            (
+              SELECT SUM(oi.release_uom_value) FROM order_inventories oi 
+              WHERE oi.status IN ('PENDING', 'PENDING_RECEIVE', 'PENDING_WORKSHEET', 'PENDING_SPLIT')
+              AND oi.inventory_id IS null
+              AND oi.product_id = i.product_id::uuid
+              AND oi.packing_type = i.packing_type
+              AND oi.uom = i.uom
+              AND oi.domain_id = $1
+              AND oi.bizplace_id = $2
+            ), 0) as "remain_uom_value"
+        FROM inventories i
+        LEFT JOIN locations l
+        ON i.location_id = l.id
+        INNER JOIN (
+          SELECT rrg.product_id, rrg.product_detail_id, rrg.sku, rrg.product_info, rrg.packing_type, rrg.packing_size, rrg.uom 
+          FROM raw_release_goods rrg
+          GROUP BY rrg.product_id, rrg.product_detail_id, rrg.sku, rrg.product_info, rrg.packing_type, rrg.packing_size, rrg.uom
+        ) AS foo
+        ON i.product_id = foo.product_id::uuid
+        AND i.packing_type = foo.packing_type
+        AND i.packing_size = foo.packing_size
+        AND i.uom = foo.uom
+        AND i.domain_id = $1
+        AND i.bizplace_id = $2
+        WHERE l.type NOT IN ($3, $4)
+        GROUP BY i.product_id, foo.product_detail_id, foo.sku,foo.product_info, i.batch_id, i.packing_type, i.packing_size, i.uom
+        ORDER BY foo.sku, remain_qty
+      ) SELECT * FROM inv WHERE remain_qty > 0
+      `,
+    [domain.id, bizplaceId, LOCATION_TYPE.QUARANTINE, LOCATION_TYPE.RESERVE]
+  )
+
+  availableItems = availableItems.map(item => {
+    return {
+      productId: item.product_id,
+      productDetailId: item.product_detail_id,
+      productInfo: item.product_info,
+      sku: item.sku,
+      batchId: item.batch_id,
+      packingType: item.packing_type,
+      packingSize: item.packing_size,
+      uom: item.uom,
+      remainQty: item.remain_qty,
+      remainUomValue: item.remain_uom_value
+    }
+  })
+
+  return _extractData(rawReleaseGoods, availableItems)
+}
+
 function _extractData(rawData, validatedData) {
   return rawData.map(raw => {
     const idx = validatedData.findIndex(val => {
@@ -737,6 +755,7 @@ function _extractData(rawData, validatedData) {
       validatedData[idx].remainUomValue -= raw.assignedUomValue
 
       raw.productId = validatedData[idx].productId
+      raw.productDetailId = validatedData[idx].productDetailId
       raw.packingType = validatedData[idx].packingType
       raw.packingSize = validatedData[idx].packingSize
       raw.uom = validatedData[idx].uom
@@ -747,9 +766,25 @@ function _extractData(rawData, validatedData) {
       raw.productId = null
     }
 
+    let releaseDate = _getStdDateStr(new Date(raw.releaseDate || ''))
+
     return {
       ...raw,
-      releaseUomValue
+      releaseUomValue,
+      errorMsg:
+        !raw.productId || !raw.productDetailId
+          ? 'product not found'
+          : raw.releaseQty <= 0
+          ? 'invalid release qty'
+          : raw.assignedQty < raw.releaseQty
+          ? 'insufficient stock'
+          : raw.releaseDate == ''
+          ? 'release date is empty'
+          : releaseDate < _getStdDateStr(new Date())
+          ? 'backdate is not allowed'
+          : !raw.refNo
+          ? 'ref no is empty'
+          : ''
     }
   })
 }
@@ -772,3 +807,11 @@ function getConditionValues(
     return condition
   }, {})
 }
+
+function _getStdDateStr(date) {
+  if (isNaN(date.getFullYear())) return ''
+  else {
+    date.setHours(date.getHours() + 8)
+    return date.toISOString().split('T')[0]
+  }
+}

package/server/service/release-good/release-good-types.ts

@@ -158,6 +158,9 @@ export class NewReleaseGood {
   @Field({ nullable: true })
   name: string
 
+  @Field({ nullable: true })
+  bundleInfo: string
+
   @Field({ nullable: true })
   releaseDate: string
 
@@ -305,6 +308,13 @@ export class NewReleaseGood {
   @Field({ nullable: true })
   partnerBizplaceId: string
 
+  /* Mainly used for rawReleaseGood*/
+  @Field({ nullable: true })
+  productId: string
+
+  @Field({ nullable: true })
+  productDetailId: string
+
   @Field({ nullable: true })
   sku: string
 
@@ -312,17 +322,35 @@ export class NewReleaseGood {
   packingType: string
 
   @Field({ nullable: true })
-  packingSize: string
+  packingSize: number
 
   @Field({ nullable: true })
   uom: string
 
   @Field({ nullable: true })
-  releaseQty: string
+  releaseQty: number
+
+  @Field({ nullable: true })
+  assignedQty: number
+
+  @Field({ nullable: true })
+  assignedUomValue: number
+
+  @Field({ nullable: true })
+  remainQty: number
+
+  @Field({ nullable: true })
+  remainUomValue: number
+
+  @Field({ nullable: true })
+  errorMsg: string
 }
 
 @InputType()
 export class ReleaseGoodPatch {
+  @Field({ nullable: true })
+  id: string
+
   @Field({ nullable: true })
   name: string
 

package/server/service/release-good/release-good.ts

@@ -289,6 +289,9 @@ export class ReleaseGood {
   @Field({ nullable: true })
   invoice: string
 
+  @Column({ nullable: true })
+  bundleInfo: string
+
   @Column({ type: 'int', nullable: true })
   @Field({ nullable: true })
   noOfItems: number
@@ -341,4 +344,47 @@ export class ReleaseGood {
 
   @Field(type => ShippingOrderInfo, { nullable: true })
   shippingOrderInfo?: ShippingOrderInfo
+
+  /* Mainly used for rawReleaseGood*/
+  @Field({ nullable: true })
+  productId: string
+
+  @Field({ nullable: true })
+  productDetailId: string
+
+  @Field({ nullable: true })
+  productInfo: string
+
+  @Field({ nullable: true })
+  sku: string
+
+  @Field({ nullable: true })
+  batchId: string
+
+  @Field({ nullable: true })
+  packingType: string
+
+  @Field({ nullable: true })
+  packingSize: number
+
+  @Field({ nullable: true })
+  uom: string
+
+  @Field({ nullable: true })
+  releaseQty: number
+
+  @Field({ nullable: true })
+  assignedQty: number
+
+  @Field({ nullable: true })
+  assignedUomValue: number
+
+  @Field({ nullable: true })
+  remainQty: number
+
+  @Field({ nullable: true })
+  remainUomValue: number
+
+  @Field({ nullable: true })
+  errorMsg: string
 }

package/server/service/return-order/return-order-mutation.ts

@@ -42,7 +42,7 @@ export class ReturnOrderMutation {
   @Mutation(returns => ReturnOrder)
   async generateReturnOrder(
     @Ctx() context: any,
-    @Arg('file', type => [GraphQLUpload]) file: FileUpload[],
+    @Arg('file', type => [GraphQLUpload], { nullable: true }) file: FileUpload[],
     @Arg('returnOrder', type => NewReturnOrder, { nullable: true }) returnOrder: NewReturnOrder
   ): Promise<ReturnOrder> {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state

package/server/utils/index.ts

@@ -1,2 +1,2 @@
 export * from './order-no-generator'
-export * from './inventory-util'
+export * from './inventory-util'

package/server/utils/inventory-util.ts

@@ -1,4 +1,4 @@
-import { EntityManager, Equal, getRepository, In, Not, Raw, Repository } from 'typeorm'
+import { EntityManager, Equal, getRepository, In, Not, Raw, Repository, SelectQueryBuilder } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
@@ -16,6 +16,7 @@ import {
 } from '@things-factory/warehouse-base'
 
 import { ValidationError } from '../errors'
+import { ORDER_TYPES } from '../constants'
 import {
   ArrivalNotice,
   DeliveryOrder,
@@ -270,6 +271,68 @@ export const InventoryUtil = {
     if (duplicatedReusablePalletCnt) throw new Error(palletId + ` exists`)
   },
 
+  /**
+   * To pre-assign inventories automatically for orderInventories in Release Goods
+   * @param product
+   * @param orderInventory
+   * @param packingType
+   * @param locationSortingRules
+   * @param customerBizplace
+   * @param domain
+   * @param trxMgr
+   * @returns orderInventories
+   */
+  async autoAssignInventoryForRelease(
+    product: Product,
+    orderInventory: OrderInventory,
+    packingType: string,
+    locationSortingRules: any = [],
+    customerBizplace: Bizplace,
+    domain: Domain,
+    trxMgr: EntityManager
+  ): Promise<OrderInventory[]> {
+    let qb: SelectQueryBuilder<Inventory> = trxMgr.getRepository(Inventory).createQueryBuilder('iv')
+    qb.leftJoinAndSelect('iv.location', 'loc')
+      .andWhere('"iv"."domain_id" = :domainId')
+      .andWhere('"iv"."bizplace_id" = :bizplaceId')
+      .andWhere('"iv"."packing_type" = :packingType')
+      .andWhere('"iv"."product_id" = :productId')
+      .andWhere('"iv"."status" = :status')
+      .andWhere('"iv"."qty" - COALESCE("iv"."locked_qty", 0) > 0')
+      .andWhere('"loc"."type" NOT IN (:...locationTypes)')
+      .setParameters({
+        domainId: domain.id,
+        bizplaceId: customerBizplace.id,
+        packingType: packingType,
+        productId: product.id,
+        status: INVENTORY_STATUS.STORED,
+        locationTypes: [LOCATION_TYPE.QUARANTINE, LOCATION_TYPE.RESERVE]
+      })
+
+    if (locationSortingRules?.length) {
+      locationSortingRules.forEach((rule: { name: string; desc: boolean }, idx: number) => {
+        idx === 0
+          ? qb.addOrderBy(`loc.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+          : qb.addOrderBy(`loc.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+      })
+    } else {
+      qb.addOrderBy('"iv"."created_at"', 'ASC')
+    }
+
+    let inventories: Inventory[] = await qb.getMany()
+    if (!inventories?.length) throw new Error(`no inventories found for ${product.sku}`)
+
+    inventories = inventories.map(inventory => {
+      return {
+        ...inventory,
+        remainQty: inventory.qty - (inventory?.lockedQty || 0),
+        remainUomValue: inventory.uomValue - (inventory?.lockedUomValue || 0)
+      }
+    })
+
+    return _composeTargetInventories(product, orderInventory, inventories)
+  },
+
   /**
    * @summary Do transaction on inventory record
    * @description It will update inventory after set a temp (domain, updater)
@@ -617,3 +680,68 @@ export async function switchLocationStatus(
 
   return location
 }
+
+export function _composeTargetInventories(product: Product, record: any, inventories: Inventory[]): OrderInventory[] {
+  let leftReleaseQty: number = record.releaseQty
+  let leftReleaseUomValue: number = record.releaseUomValue
+  let compReleaseQty: number = 0
+  let compReleaseUomValue: number = 0
+  let totalInventoryQty: number = inventories.reduce((total, inventory) => total + inventory.remainQty, 0)
+
+  if (totalInventoryQty < record.releaseQty) {
+    throw new Error(`invalid release qty for ${product?.sku}`)
+  }
+
+  let orderInventories: Partial<OrderInventory[]> = []
+  let idx = 0
+  while (compReleaseQty < record.releaseQty) {
+    const inventory = inventories[idx]
+    const {
+      packingType,
+      packingSize,
+      batchId,
+      uom
+    }: { packingType: string; packingSize: number; batchId: string; uom: string } = inventory
+
+    let orderInventory: OrderInventory = new OrderInventory()
+
+    if (inventory.remainQty > leftReleaseQty) {
+      const uomValuePerQty: number = Math.round((inventory.remainUomValue / inventory.remainQty) * 100) / 100
+
+      compReleaseQty += leftReleaseQty
+      compReleaseUomValue += leftReleaseUomValue
+
+      orderInventory = {
+        ...orderInventory,
+        releaseQty: leftReleaseQty,
+        releaseUomValue: Math.round(leftReleaseQty * uomValuePerQty * 100) / 100
+      }
+    } else {
+      compReleaseQty += inventory.remainQty
+      compReleaseUomValue += inventory.remainUomValue
+      leftReleaseQty -= inventory.remainQty
+      leftReleaseUomValue -= inventory.remainUomValue
+
+      orderInventory = {
+        ...orderInventory,
+        releaseQty: inventory.remainQty,
+        releaseUomValue: inventory.remainUomValue
+      }
+    }
+
+    orderInventories.push({
+      ...orderInventory,
+      inventory,
+      packingType,
+      packingSize,
+      batchId,
+      uom,
+      product,
+      type: ORDER_TYPES.RELEASE_OF_GOODS
+    })
+
+    idx++
+  }
+
+  return orderInventories
+}