@things-factory/worksheet-base 4.3.186 → 4.3.187

package/server/controllers/worksheet-controller.ts

@@ -16,7 +16,8 @@ import {
   OrderVas,
   ReleaseGood,
   ReturnOrder,
-  VasOrder
+  VasOrder,
+  Replenishment
 } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import {
@@ -31,7 +32,14 @@ import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../constants'
 import { Worksheet, WorksheetDetail } from '../entities'
 import { WorksheetNoGenerator } from '../utils'
 
-export type ReferenceOrderType = ArrivalNotice | ReleaseGood | VasOrder | InventoryCheck | DeliveryOrder | ReturnOrder
+export type ReferenceOrderType =
+  | ArrivalNotice
+  | ReleaseGood
+  | VasOrder
+  | InventoryCheck
+  | DeliveryOrder
+  | ReturnOrder
+  | Replenishment
 export type OrderTargetTypes = OrderProduct | OrderInventory | OrderVas
 
 export enum ReferenceOrderFields {
@@ -39,7 +47,8 @@ export enum ReferenceOrderFields {
   ReleaseGood = 'releaseGood',
   VasOrder = 'vasOrder',
   InventoryCheck = 'inventoryCheck',
-  ReturnOrder = 'returnOrder'
+  ReturnOrder = 'returnOrder',
+  Replenishment = 'replenishment'
 }
 
 export enum OrderTargetFields {
@@ -121,6 +130,8 @@ export class WorksheetController {
       return ReferenceOrderFields.InventoryCheck
     } else if (refOrder instanceof ReturnOrder) {
       return ReferenceOrderFields.ReturnOrder
+    } else if (refOrder instanceof Replenishment) {
+      return ReferenceOrderFields.Replenishment
     } else {
       throw new Error(
         this.ERROR_MSG.VALIDITY.UNEXPECTED_FIELD_VALUE('refOrder', 'One of reference order type', refOrder)
@@ -247,13 +258,17 @@ export class WorksheetController {
         case ReferenceOrderFields.ReturnOrder:
           refOrder = await this.findRefOrder(ReturnOrder, refOrder, ['bizplace'])
           break
+
+        case ReferenceOrderFields.Replenishment:
+          refOrder = await this.findRefOrder(Replenishment, refOrder)
+          break
       }
     }
 
-    const bizplace: Bizplace = refOrder.bizplace
+    const bizplace: Bizplace = refOrder?.bizplace
     const condition: FindOneOptions = {
       where: {
-        bizplace,
+        bizplace: bizplace ? bizplace : null,
         domain: this.domain,
         type,
         [refOrderField]: refOrder
@@ -394,7 +409,10 @@ export class WorksheetController {
     additionalProps: Partial<Worksheet> = {}
   ): Promise<Worksheet> {
     let refOrderType: string = await this.getRefOrderField(refOrder)
-    const bizplace: Bizplace = await this.extractBizplaceFromRefOrder(refOrder)
+    let bizplace: Bizplace
+    if (refOrderType !== 'replenishment') {
+      bizplace = await this.extractBizplaceFromRefOrder(refOrder)
+    }
 
     let existingWorksheet: Worksheet
     try {
@@ -411,10 +429,13 @@ export class WorksheetController {
 
     const worksheet: Partial<Worksheet> = {
       domain: this.domain,
-      bizplace,
+      bizplace: bizplace ? bizplace : null,
       name: WorksheetNoGenerator.generate(type),
       type,
-      status: WORKSHEET_STATUS.DEACTIVATED,
+      status:
+        refOrderType == 'replenishment' && type == WORKSHEET_TYPE.PUTAWAY_REPLENISHMENT
+          ? WORKSHEET_STATUS.EXECUTING
+          : WORKSHEET_STATUS.DEACTIVATED,
       creator: this.user,
       updater: this.user,
       [refOrderType]: refOrder,
@@ -463,7 +484,11 @@ export class WorksheetController {
     orderTargets: OrderTargetTypes[],
     additionalProps: Partial<WorksheetDetail> = {}
   ): Promise<WorksheetDetail[]> {
-    if (!worksheet.bizplace?.id) {
+    if (
+      !worksheet.bizplace?.id &&
+      type !== WORKSHEET_TYPE.PICKING_REPLENISHMENT &&
+      type !== WORKSHEET_TYPE.PUTAWAY_REPLENISHMENT
+    ) {
       worksheet = await this.findWorksheetById(worksheet.id, ['bizplace'])
     }
     const bizplace: Bizplace = worksheet.bizplace
@@ -472,11 +497,12 @@ export class WorksheetController {
       const orderTargetField: string = this.getOrderTargetField(orderTarget)
       return {
         domain: this.domain,
-        bizplace,
+        bizplace: bizplace ? bizplace : orderTarget.bizplace,
         worksheet,
         name: WorksheetNoGenerator.generate(type, true),
         type,
-        status: WORKSHEET_STATUS.DEACTIVATED,
+        status:
+          type == WORKSHEET_TYPE.PUTAWAY_REPLENISHMENT ? WORKSHEET_STATUS.EXECUTING : WORKSHEET_STATUS.DEACTIVATED,
         [orderTargetField]: orderTarget,
         creator: this.user,
         updater: this.user,
@@ -511,6 +537,8 @@ export class WorksheetController {
         entitySchema = InventoryCheck
       } else if (refOrder instanceof ReturnOrder) {
         entitySchema = ReturnOrder
+      } else if (refOrder instanceof Replenishment) {
+        entitySchema = Replenishment
       }
     }
 
@@ -746,7 +774,9 @@ export class WorksheetController {
       worksheetType === WORKSHEET_TYPE.PACKING ||
       worksheetType === WORKSHEET_TYPE.LOADING ||
       worksheetType === WORKSHEET_TYPE.WAREHOUSE_RETURN ||
-      worksheetType === WORKSHEET_TYPE.UNLOADING_RETURN
+      worksheetType === WORKSHEET_TYPE.UNLOADING_RETURN ||
+      worksheetType === WORKSHEET_TYPE.PICKING_REPLENISHMENT ||
+      worksheetType === WORKSHEET_TYPE.PUTAWAY_REPLENISHMENT
     ) {
       let targetInventories: OrderInventory[] = worksheet.worksheetDetails
         .filter((wsd: WorksheetDetail) => wsd.status !== ORDER_INVENTORY_STATUS.REPLACED)
@@ -904,10 +934,11 @@ export class WorksheetController {
       worksheet.vasOrder ||
       worksheet.inventoryCheck ||
       worksheet.returnOrder ||
+      worksheet.replenishment ||
       null
     if (!refOrder) {
       const wsWithRefOrd: Worksheet = await this.trxMgr.getRepository(Worksheet).findOne(worksheet.id, {
-        relations: ['arrivalNotice', 'releaseGood', 'vasOrder', 'inventoryCheck', 'returnOrder']
+        relations: ['arrivalNotice', 'releaseGood', 'vasOrder', 'inventoryCheck', 'returnOrder', 'replenishment']
       })
 
       refOrder =
@@ -916,6 +947,7 @@ export class WorksheetController {
         wsWithRefOrd.vasOrder ||
         wsWithRefOrd.inventoryCheck ||
         wsWithRefOrd.returnOrder ||
+        wsWithRefOrd.replenishment ||
         null
       if (!refOrder) throw new Error(this.ERROR_MSG.FIND.NO_RESULT(worksheet.id))
     }
@@ -1221,6 +1253,8 @@ export class WorksheetController {
         entitySchema = InventoryCheck
       } else if (refOrder instanceof ReturnOrder) {
         entitySchema = ReturnOrder
+      } else if (refOrder instanceof Replenishment) {
+        entitySchema = Replenishment
       }
     }
 

package/server/entities/index.ts

@@ -1,8 +1,21 @@
 import { WarehouseBizplaceOnhandInventory } from './warehouse-bizplace-onhand-inventory'
+import { WarehouseInventoryAssignmentRanking } from './warehouse-inventory-assignment-ranking'
 import { Worksheet } from './worksheet'
 import { WorksheetDetail } from './worksheet-detail'
 import { WorksheetMovement } from './worksheet-movement'
 
-export const entities = [Worksheet, WorksheetDetail, WorksheetMovement, WarehouseBizplaceOnhandInventory]
+export const entities = [
+  Worksheet,
+  WorksheetDetail,
+  WorksheetMovement,
+  WarehouseBizplaceOnhandInventory,
+  WarehouseInventoryAssignmentRanking
+]
 
-export { WarehouseBizplaceOnhandInventory, Worksheet, WorksheetDetail, WorksheetMovement }
+export {
+  WarehouseBizplaceOnhandInventory,
+  WarehouseInventoryAssignmentRanking,
+  Worksheet,
+  WorksheetDetail,
+  WorksheetMovement
+}

package/server/entities/warehouse-bizplace-onhand-inventory.ts

@@ -16,6 +16,8 @@ import { ViewColumn, ViewEntity } from 'typeorm'
     COALESCE(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0))) AS "remain_uom_value",
     COALESCE(sum(COALESCE(i.qty, 0::double precision))) AS "qty",
     COALESCE(sum(COALESCE(i.uom_value, 0::double precision))) AS "uom_value",
+    COALESCE(sum(COALESCE(i.transfer_qty, 0::double precision))) AS "transfer_qty",
+    COALESCE(sum(COALESCE(i.transfer_uom_value, 0::double precision))) AS "transfer_uom_value",
     'SINGLE' AS "group_type"
     FROM inventories i
     INNER JOIN locations l2 ON i.location_id = l2.id AND i.domain_id = l2.domain_id AND l2.type NOT IN ('QUARANTINE', 'RESERVE')
@@ -43,6 +45,8 @@ import { ViewColumn, ViewEntity } from 'typeorm'
     COALESCE(MIN(FLOOR(pbs."available_uom_value")),0) AS "remain_uom_value",
     COALESCE(MIN(FLOOR(pbs."qty")), 0::double precision) AS "qty",
     COALESCE(MIN(FLOOR(pbs."uom_value")), 0::double precision) AS "uom_value",
+    COALESCE(MIN(FLOOR(pbs."transfer_qty")), 0::double precision) AS "transfer_qty",
+    COALESCE(MIN(FLOOR(pbs."transfer_uom_value")), 0::double precision) AS "transfer_uom_value",
     'BUNDLE' AS "group_type"
     FROM product_bundles pb
     INNER JOIN (
@@ -50,7 +54,9 @@ import { ViewColumn, ViewEntity } from 'typeorm'
       (SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0))) / min(pbs.bundle_qty) AS "available_qty",
       (SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0))) / min(pbs.bundle_qty)  AS "available_uom_value",
       (sum(COALESCE(i.qty, 0::double precision))) / min(pbs.bundle_qty)::double precision AS "qty",
-      (sum(COALESCE(i.uom_value, 0::double precision))) / min(pbs.bundle_qty)::double precision AS "uom_value"
+      (sum(COALESCE(i.uom_value, 0::double precision))) / min(pbs.bundle_qty)::double precision AS "uom_value",
+      (sum(COALESCE(i.transfer_qty, 0::double precision))) / min(pbs.bundle_qty)::double precision AS "transfer_qty",
+      (sum(COALESCE(i.transfer_uom_value, 0::double precision))) / min(pbs.bundle_qty)::double precision AS "transfer_uom_value"
       FROM product_bundle_settings pbs 
       LEFT JOIN inventories i ON i.product_id = pbs.product_id AND i.status = 'STORED' AND i.obsolete = false
       INNER JOIN products p ON p.id = pbs.product_id AND CASE WHEN i.expiration_date is not null and p.shelf_life is not null then CURRENT_DATE < i.expiration_date - p.shelf_life else true end
@@ -112,6 +118,12 @@ export class WarehouseBizplaceOnhandInventory {
   @ViewColumn()
   remainUomValue: number
 
+  @ViewColumn()
+  transferQty: number
+
+  @ViewColumn()
+  transferUomValue: number
+
   @ViewColumn()
   groupType: string
 }

package/server/entities/warehouse-inventory-assignment-ranking.ts

@@ -0,0 +1,19 @@
+import { ViewColumn, ViewEntity } from 'typeorm'
+
+@ViewEntity({
+  expression: `
+    select src.* from (select 0 as "rank", 'SHELF' as location_type
+    union all
+    select 1 as "rank", 'FLOOR' as location_type
+    union all
+    select 2 as "rank", 'STORAGE' as location_type
+    ) src
+  `
+})
+export class WarehouseInventoryAssignmentRanking {
+  @ViewColumn()
+  locationType: string
+
+  @ViewColumn()
+  rank: number
+}

package/server/entities/worksheet.ts

@@ -6,7 +6,8 @@ import {
   ReleaseGood,
   ShippingOrder,
   VasOrder,
-  ReturnOrder
+  ReturnOrder,
+  Replenishment
 } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Location } from '@things-factory/warehouse-base'
@@ -44,6 +45,9 @@ export class Worksheet {
   @ManyToOne(type => ReleaseGood)
   releaseGood: ReleaseGood
 
+  @ManyToOne(type => Replenishment)
+  replenishment: Replenishment
+
   @ManyToOne(type => ReturnOrder)
   returnOrder: ReturnOrder
 

package/server/graphql/resolvers/worksheet/cancel-replenishment.ts

@@ -0,0 +1,69 @@
+import { In, Not, EntityManager } from 'typeorm'
+import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+import { ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory, Replenishment } from '@things-factory/sales-base'
+import { User } from '@things-factory/auth-base'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+
+export const cancelReplenishment = {
+  async cancelReplenishment(_: any, { name }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    let replenishment: Replenishment = await tx.getRepository(Replenishment).findOne({
+      where: { domain, name, status: Not(In([ORDER_STATUS.PICKING, ORDER_STATUS.PUTTING_AWAY])) },
+      relations: ['orderInventories', 'orderInventories.inventory', 'orderInventories.inventory.location']
+    })
+
+    if (!replenishment) throw new Error(`Replenishment doesn't exists.`)
+    let targetOIs: OrderInventory[] = replenishment.orderInventories
+
+    // change status to cancelled for order inventory that has not executed yet and remove locked qty
+
+    await Promise.all(
+      targetOIs.map(async (orderInventory: OrderInventory) => {
+        let inventory: Inventory = orderInventory.inventory
+
+        if (inventory && inventory.id) {
+          await tx
+            .createQueryBuilder()
+            .update(Inventory)
+            .set({
+              transferQty: () => `COALESCE("transfer_qty", 0) - ${orderInventory.releaseQty}`,
+              transferUomValue: () => `COALESCE("transfer_uom_value", 0) - ${orderInventory.releaseUomValue}`,
+              updater: user
+            })
+            .where('id = :id', { id: inventory.id })
+            .execute()
+        }
+
+        return orderInventory
+      })
+    )
+
+    await tx
+      .getRepository(OrderInventory)
+      .update(targetOIs, { status: ORDER_INVENTORY_STATUS.CANCELLED, updater: user })
+
+    let worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+      where: { replenishment },
+      relations: ['worksheetDetails']
+    })
+
+    if (worksheet) {
+      let worksheetDetailIds = worksheet.worksheetDetails.map(wsd => wsd.id)
+
+      await tx
+        .getRepository(Worksheet)
+        .update({ id: worksheet.id }, { status: ORDER_INVENTORY_STATUS.CANCELLED, updater: this.user })
+
+      await tx
+        .getRepository(WorksheetDetail)
+        .update({ id: In(worksheetDetailIds) }, { status: ORDER_INVENTORY_STATUS.CANCELLED, updater: this.user })
+    }
+
+    await tx
+      .getRepository(Replenishment)
+      .update({ id: replenishment.id }, { status: ORDER_STATUS.CANCELLED, updater: this.user })
+
+    return worksheet
+  }
+}

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-release-good-worksheet.ts

@@ -13,7 +13,12 @@ import { Inventory, InventoryUtil, INVENTORY_TRANSACTION_TYPE } from '@things-fa
 export const generateReleaseGoodWorksheetResolver = {
   async generateReleaseGoodWorksheet(_: any, { releaseGoodNo, currentStatus = null }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    return await generatePickingWorksheet(tx, domain, user, releaseGoodNo, currentStatus)
+    let worksheet = await generatePickingWorksheet(tx, domain, user, releaseGoodNo, currentStatus)
+    if (worksheet) {
+      return true
+    } else {
+      return false
+    }
   }
 }
 

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-replenishement-worksheet.ts

@@ -0,0 +1,30 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { OrderInventory } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import { ReplenishmentWorksheetController } from '../../../../controllers'
+import { Worksheet } from '../../../../entities'
+
+export const generateReplenishmentWorksheetResolver = {
+  async generateReplenishmentWorksheets(_: any, { replenishmentNos }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    for (let i = 0; i < replenishmentNos.length; i++) {
+      await generateReplenishmentWorksheet(tx, domain, user, replenishmentNos[i])
+    }
+
+    return true
+  }
+}
+
+export async function generateReplenishmentWorksheet(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  replenishmentNo: string
+): Promise<Worksheet> {
+  const worksheetController: ReplenishmentWorksheetController = new ReplenishmentWorksheetController(tx, domain, user)
+  return await worksheetController.generateReplenishmentWorksheet(replenishmentNo)
+}

package/server/graphql/resolvers/worksheet/generate-worksheet/index.ts

@@ -8,6 +8,7 @@ import { generateMultipleReleaseGoodWorksheetResolver } from './generate-multipl
 import { generateVasOrderWorksheetResolver } from './generate-vas-order-worksheet'
 import { generateReturnOrderWorksheetResolver } from './generate-return-order-worksheet'
 import { generatePartialPutawayReturnWorksheetResolver } from './generate-partial-putaway-return-worksheet'
+import { generateReplenishmentWorksheetResolver } from './generate-replenishement-worksheet'
 
 export const Mutations = {
   ...generateArrivalNoticeWorksheetResolver,
@@ -19,5 +20,6 @@ export const Mutations = {
   ...generateMultipleReleaseGoodWorksheetResolver,
   ...generateVasOrderWorksheetResolver,
   ...generateReturnOrderWorksheetResolver,
-  ...generatePartialPutawayReturnWorksheetResolver
+  ...generatePartialPutawayReturnWorksheetResolver,
+  ...generateReplenishmentWorksheetResolver
 }

package/server/graphql/resolvers/worksheet/index.ts

@@ -67,6 +67,9 @@ import { worksheetResolver } from './worksheet'
 import { worksheetByOrderNoResolver } from './worksheet-by-order-no'
 import { worksheetWithPaginationResolver } from './worksheet-with-pagination'
 import { worksheetsResolver } from './worksheets'
+import { cancelReplenishment } from './cancel-replenishment'
+import { Mutations as ReplenishmentMutations } from './replenishment'
+import { putawayReplenishmentWorksheetResolver } from './putaway-replenishment-worksheet'
 
 export const Query = {
   ...worksheetsResolver,
@@ -102,7 +105,8 @@ export const Query = {
   ...sortingWorksheetResolver,
   ...findSortingReleaseOrdersByTaskNoResolver,
   ...findReleaseOrdersByTaskNoResolver,
-  ...fetchDeliveryOrderROResolver
+  ...fetchDeliveryOrderROResolver,
+  ...putawayReplenishmentWorksheetResolver
 }
 
 export const Mutation = {
@@ -138,5 +142,7 @@ export const Mutation = {
   ...unpackingResolver,
   ...palletizingPallets,
   ...fetchSellercraftDocumentResolver,
-  ...cancelDraftReleaseOrder
+  ...cancelDraftReleaseOrder,
+  ...cancelReplenishment,
+  ...ReplenishmentMutations
 }

package/server/graphql/resolvers/worksheet/inventories-by-pallet.ts

@@ -51,6 +51,8 @@ export const inventoriesByPalletResolver = {
       .leftJoinAndSelect('iv.creator', 'creator')
       .leftJoinAndSelect('iv.updater', 'updater')
       .andWhere('iv.qty > 0')
+      .andWhere('iv.transfer_qty <= 0')
+      .andWhere('iv.transfer_uom_value <= 0')
       .andWhere(
         `location.type ${recallFilters?.value === true ? '' : 'NOT'} IN ('${LOCATION_TYPE.QUARANTINE}', '${
           LOCATION_TYPE.RESERVE
@@ -146,8 +148,6 @@ export const inventoriesByPalletResolver = {
       )
     }
 
-    let [items, total] = await qb.getManyAndCount()
-
     if (sortings?.length !== 0) {
       const arrChildSortData = ['productName', 'productSKU']
 
@@ -171,6 +171,8 @@ export const inventoriesByPalletResolver = {
       qb.addOrderBy('location.name', 'DESC')
     }
 
+    let [items, total] = await qb.getManyAndCount()
+
     items = await Promise.all(
       items.map(async (item: Inventory) => {
         const { remainQty, remainUomValue } = await getRemainAmount(item)