@things-factory/sales-base 4.0.24 → 4.0.25

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

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
+}