@things-factory/worksheet-base 3.7.5 → 3.7.6

package/server/graphql/resolvers/worksheet/picking/complete-picking.ts

@@ -19,6 +19,7 @@ import {
 import { EcommerceController } from '../../../../controllers/ecommerce'
 import { WorksheetController } from '../../../../controllers/worksheet-controller'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
+import { Setting, PartnerSetting } from '@things-factory/setting-base'
 
 export const completePickingResolver = {
   async completePicking(_: any, { releaseGoodNo }, context: any) {
@@ -187,10 +188,30 @@ export async function completePicking(
 
   if (releaseGood.packingOption) {
     const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
-    await packingWSCtrl.generatePackingWorksheet(releaseGoodNo)
+
+    const directActivatePackingWorksheet: Setting = await tx.getRepository(Setting).findOne({
+      where: { domain: domain, category: 'id-rule', name: 'enable-direct-activate-packing-worksheet' }
+    })
+    const partnerDirectActivatePackingWorksheetSetting: PartnerSetting = await tx.getRepository(PartnerSetting).findOne({
+      where: { setting: directActivatePackingWorksheet, domain: domain, partnerDomain: releaseGood.bizplace?.domain }
+    })
+
+    let packingWorksheet: Worksheet = await packingWSCtrl.generatePackingWorksheet(releaseGoodNo)
+
+    if (
+      directActivatePackingWorksheet != undefined && (directActivatePackingWorksheet.value).toLowerCase() == 'true'
+    ) {
+      if (partnerDirectActivatePackingWorksheetSetting != undefined) {
+        if ((partnerDirectActivatePackingWorksheetSetting.value).toLowerCase() == 'true')
+          await packingWSCtrl.activatePacking(packingWorksheet.name)
+      } else {
+        await packingWSCtrl.activatePacking(packingWorksheet.name)
+      }
+    }
+
   } else {
     // Find Existing Loading Worksheet if any
-    const existLoadingWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+    let existLoadingWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
       where: {
         releaseGood,
         type: WORKSHEET_TYPE.LOADING,
@@ -211,10 +232,21 @@ export async function completePicking(
 
       const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
       await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
-    } else {
-      throw new Error(
-        'Picking completion has been triggered twice, loading worksheet has been generated. Kindly proceed to loading.'
+    }
+    else {
+      const loadingWSCtrl: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
+      let loadingWorksheet: Worksheet = await loadingWSCtrl.updateLoadingWorksheet(
+        releaseGoodNo,
+        pickedTargetInventories,
+        existLoadingWorksheet
       )
+
+      if (!loadingWorksheet.worksheetDetails?.length) {
+        loadingWorksheet = await pickingWSCtrl.findWorksheetById(loadingWorksheet.id)
+      }
+
+      const loadingWorksheetDetails: WorksheetDetail[] = loadingWorksheet.worksheetDetails
+      await loadingWSCtrl.activateLoading(loadingWorksheet.name, loadingWorksheetDetails)
     }
   }
 }

package/server/graphql/resolvers/worksheet/picking/fetch-and-assign-picking-task.ts

@@ -0,0 +1,78 @@
+import { EntityManager, getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Setting } from '@things-factory/setting-base'
+import { Domain } from '@things-factory/shell'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
+import { Worksheet } from '../../../../entities'
+import { pickingWorksheet } from '../picking-worksheet'
+import { activatePicking } from './activate-picking'
+
+export const fetchAndAssignPickingTaskResolver = {
+  async fetchAndAssignPickingTask(_: any, {}, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const assignee: User = await tx.getRepository(User).findOne(user.id, { relations: ['domains'] })
+    if ((assignee?.domains || []).every((userDomain: Domain) => userDomain.id !== domain.id))
+      throw new Error('Target user is not belong to current domain')
+
+    if (!assignee) throw new Error('failed to find target user')
+
+    let worksheet: Worksheet
+    worksheet = await tx.getRepository(Worksheet).findOne({
+      relations: ['releaseGood'],
+      where: [
+        {
+          domain,
+          type: WORKSHEET_TYPE.PICKING,
+          status: WORKSHEET_STATUS.EXECUTING,
+          assignee: assignee
+        },
+        {
+          domain,
+          type: WORKSHEET_TYPE.PICKING,
+          status: WORKSHEET_STATUS.DEACTIVATED,
+          assignee: assignee
+        }
+      ],
+      order: {
+        name: 'ASC'
+      }
+    })
+
+    if (!worksheet) {
+      worksheet = await tx.getRepository(Worksheet).findOne({
+        relations: ['releaseGood'],
+        where: [
+          {
+            domain,
+            type: WORKSHEET_TYPE.PICKING,
+            status: WORKSHEET_STATUS.EXECUTING,
+            assignee: null
+          },
+          {
+            domain,
+            type: WORKSHEET_TYPE.PICKING,
+            status: WORKSHEET_STATUS.DEACTIVATED,
+            assignee: null
+          }
+        ]
+      })
+
+      await getRepository(Worksheet).update({ id: worksheet.id }, { assignee: assignee })
+    }
+
+    if (worksheet.status == WORKSHEET_STATUS.DEACTIVATED) await activatePicking(tx, domain, user, worksheet.name)
+
+    const locationSortingRules: Setting = await tx.getRepository(Setting).findOne({
+      where: { domain, name: 'rule-for-picking-product' }
+    })
+
+    const sortingRule = JSON.parse(locationSortingRules.value)
+    const locationSortingRule = Object.keys(sortingRule).map(field => {
+      return { name: field, desc: sortingRule[field] === 'DESC' }
+    })
+
+    return await pickingWorksheet(domain, worksheet.releaseGood.name, locationSortingRule, tx)
+  }
+}

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

@@ -2,6 +2,7 @@ import { activateBatchPickingResolver } from './activate-batch-picking'
 import { activatePickingResolver } from './activate-picking'
 import { assignPickingInventoriesResolver } from './assign-picking-inventories'
 import { assignPickingWorkerResolver } from './assign-picking-worker'
+import { fetchAndAssignPickingTaskResolver } from './fetch-and-assign-picking-task'
 import { batchPickingResolver } from './batch-picking'
 import { completeBatchPickingResolver } from './complete-batch-picking'
 import { completePickingResolver } from './complete-picking'
@@ -21,5 +22,6 @@ export const Mutations = {
   ...batchPickingResolver,
   ...completePickingResolver,
   ...completeBatchPickingResolver,
-  ...assignPickingWorkerResolver
+  ...assignPickingWorkerResolver,
+  ...fetchAndAssignPickingTaskResolver
 }

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

@@ -4,9 +4,9 @@ import { EntityManager } from 'typeorm'
 import { PickingWorksheetController } from '../../../../controllers'
 
 export const pickingResolver = {
-  async picking(_: any, { worksheetDetailName, worksheetType, palletId, locationName, releaseQty }, context: any) {
+  async picking(_: any, { worksheetDetailName, worksheetType, palletId, locationName, releaseQty, binLocation }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await picking(tx, domain, user, worksheetDetailName, worksheetType, palletId, locationName, releaseQty)
+    await picking(tx, domain, user, worksheetDetailName, worksheetType, palletId, locationName, releaseQty, binLocation)
   }
 }
 
@@ -18,8 +18,9 @@ export async function picking(
   worksheetType: string,
   palletId: string,
   locationName: string,
-  releaseQty: number
+  releaseQty: number,
+  binLocation?: string
 ) {
   const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-  await worksheetController.picking(worksheetDetailName, worksheetType, palletId, locationName, releaseQty)
+  await worksheetController.picking(worksheetDetailName, worksheetType, palletId, locationName, releaseQty, binLocation)
 }

package/server/graphql/resolvers/worksheet/picking-worksheet.ts

@@ -1,8 +1,8 @@
-import { createQueryBuilder, getRepository, SelectQueryBuilder } from 'typeorm'
+import { EntityManager, In, SelectQueryBuilder } from 'typeorm'
 
 import { ORDER_INVENTORY_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
+import { Inventory, Location } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { WorksheetDetail } from '../../../entities'
@@ -10,71 +10,111 @@ import { fetchExecutingWorksheet } from '../../../utils'
 
 export const pickingWorksheetResolver = {
   async pickingWorksheet(_: any, { releaseGoodNo, locationSortingRules }, context: any) {
-    const { domain }: { domain: Domain } = context.state
-    const releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
-      where: { domain, name: releaseGoodNo /*status: ORDER_STATUS.PICKING*/ },
-      relations: ['bizplace', 'bizplace.domain']
-    })
-    if (!releaseGood) throw new Error(`Couldn't find picking worksheet by order no (${releaseGoodNo})`)
-
-    const worksheet = await fetchExecutingWorksheet(
-      domain,
-      releaseGood.bizplace,
-      ['bizplace'],
-      WORKSHEET_TYPE.PICKING,
-      releaseGood
-    )
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
 
-    const qb: SelectQueryBuilder<WorksheetDetail> = createQueryBuilder(WorksheetDetail, 'WSD')
-    qb.leftJoinAndSelect('WSD.targetInventory', 'T_INV')
-      .leftJoinAndSelect('T_INV.inventory', 'INV')
-      .leftJoinAndSelect('T_INV.product', 'PROD')
-      .leftJoinAndSelect('INV.location', 'LOC')
+    return await pickingWorksheet(domain, releaseGoodNo, locationSortingRules, tx)
+  }
+}
 
-    if (locationSortingRules?.length > 0) {
-      locationSortingRules.forEach((rule: { name: string; desc: boolean }) => {
-        qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
-      })
-    }
+export async function pickingWorksheet(
+  domain: Domain,
+  releaseGoodNo: String,
+  locationSortingRules: any,
+  tx: EntityManager
+) {
+  let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+    where: { domain, name: releaseGoodNo /*status: ORDER_STATUS.PICKING*/ },
+    relations: ['bizplace', 'bizplace.domain']
+  })
 
-    const worksheetDetails: WorksheetDetail[] = await qb
-      .where('"WSD"."worksheet_id" = :worksheetId', { worksheetId: worksheet.id })
-      .andWhere('"WSD"."status" != :status', { status: WORKSHEET_STATUS.REPLACED })
-      .andWhere('"T_INV"."status" != :t_invstatus', { t_invstatus: ORDER_INVENTORY_STATUS.CANCELLED })
-      .getMany()
+  // Find Release Order based on Bin
+  if (!releaseGood) {
+    const binLocation: Location = await tx.getRepository(Location).findOne({
+      where: { domain, name: releaseGoodNo }
+    })
 
-    return {
-      worksheetInfo: {
-        bizplaceName: releaseGood.bizplace.name,
-        partnerDomainId: releaseGood.bizplace?.domain.id,
-        startedAt: worksheet.startedAt,
-        refNo: releaseGood.refNo,
-        refNo2: releaseGood.refNo2,
-        releaseGood
+    const orderInventoryByBin: OrderInventory = await tx.getRepository(OrderInventory).findOne({
+      where: {
+        domain,
+        binLocation,
+        status: In([ORDER_INVENTORY_STATUS.PICKING, ORDER_INVENTORY_STATUS.PICKED])
+      },
+      order: {
+        createdAt: 'ASC'
       },
-      worksheetDetailInfos: worksheetDetails.map(async (pickingWSD: WorksheetDetail) => {
-        const targetInventory: OrderInventory = pickingWSD.targetInventory
-        const inventory: Inventory = targetInventory.inventory
-        return {
-          name: pickingWSD.name,
-          palletId: inventory?.palletId,
-          cartonId: inventory?.cartonId,
-          batchId: inventory?.batchId,
-          batchIdRef: inventory?.batchIdRef,
-          product: inventory?.product,
-          qty: inventory?.qty,
-          releaseQty: targetInventory.releaseQty,
-          pickedQty: targetInventory.pickedQty,
-          status: pickingWSD.status,
-          description: pickingWSD.description,
-          targetName: targetInventory.name,
-          packingType: inventory?.packingType,
-          packingSize: inventory?.packingSize,
-          expirationDate: inventory?.expirationDate,
-          location: inventory?.location,
-          relatedOrderInv: targetInventory
-        }
-      })
+      relations: ['releaseGood', 'releaseGood.bizplace', 'releaseGood.bizplace.domain']
+    })
+
+    if (orderInventoryByBin?.releaseGood) {
+      releaseGoodNo = orderInventoryByBin.releaseGood.name
+      releaseGood = orderInventoryByBin.releaseGood
     }
   }
+
+  if (!releaseGood) throw new Error(`Couldn't find picking worksheet by order no (${releaseGoodNo})`)
+
+  const worksheet = await fetchExecutingWorksheet(
+    domain,
+    releaseGood.bizplace,
+    ['bizplace'],
+    WORKSHEET_TYPE.PICKING,
+    releaseGood,
+    tx
+  )
+
+  const qb: SelectQueryBuilder<WorksheetDetail> = tx.createQueryBuilder(WorksheetDetail, 'WSD')
+  qb.leftJoinAndSelect('WSD.targetInventory', 'T_INV')
+    .leftJoinAndSelect('T_INV.binLocation', 'BIN_LOC')
+    .leftJoinAndSelect('T_INV.inventory', 'INV')
+    .leftJoinAndSelect('T_INV.product', 'PROD')
+    .leftJoinAndSelect('INV.location', 'LOC')
+
+  if (locationSortingRules?.length > 0) {
+    locationSortingRules.forEach((rule: { name: string; desc: boolean }) => {
+      qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+    })
+  }
+
+  qb.addOrderBy(`PROD.name`, 'ASC')
+
+  const worksheetDetails: WorksheetDetail[] = await qb
+    .where('"WSD"."worksheet_id" = :worksheetId', { worksheetId: worksheet.id })
+    .andWhere('"WSD"."status" != :status', { status: WORKSHEET_STATUS.REPLACED })
+    .andWhere('"T_INV"."status" != :t_invstatus', { t_invstatus: ORDER_INVENTORY_STATUS.CANCELLED })
+    .getMany()
+
+  return {
+    worksheetInfo: {
+      bizplaceName: releaseGood.bizplace.name,
+      partnerDomainId: releaseGood.bizplace?.domain.id,
+      startedAt: worksheet.startedAt,
+      refNo: releaseGood.refNo,
+      refNo2: releaseGood.refNo2,
+      releaseGood
+    },
+    worksheetDetailInfos: worksheetDetails.map(async (pickingWSD: WorksheetDetail) => {
+      const targetInventory: OrderInventory = pickingWSD.targetInventory
+      const inventory: Inventory = targetInventory.inventory
+      return {
+        name: pickingWSD.name,
+        palletId: inventory?.palletId,
+        cartonId: inventory?.cartonId,
+        batchId: inventory?.batchId,
+        batchIdRef: inventory?.batchIdRef,
+        product: inventory?.product,
+        qty: inventory?.qty,
+        binLocation: targetInventory?.binLocation || '',
+        releaseQty: targetInventory.releaseQty,
+        pickedQty: targetInventory.pickedQty,
+        status: pickingWSD.status,
+        description: pickingWSD.description,
+        targetName: targetInventory.name,
+        packingType: inventory?.packingType,
+        packingSize: inventory?.packingSize,
+        expirationDate: inventory?.expirationDate,
+        location: inventory?.location,
+        relatedOrderInv: targetInventory
+      }
+    })
+  }
 }

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

@@ -290,6 +290,7 @@ export const Mutation = /* GraphQL */ `
     cartonId: String
     locationName: String!
     releaseQty: Int!
+    binLocation: String
   ): Boolean @privilege(category: "worksheet_execute", privilege: "mutation") @transaction
 
   scanProductPicking (
@@ -515,6 +516,9 @@ export const Mutation = /* GraphQL */ `
     worksheetId: String!
     userId: String!
   ): Boolean @privilege(category: "worksheet_control", privilege: "mutation") @transaction
+
+  fetchAndAssignPickingTask     
+  : ExecutingWorksheet @privilege(category: "worksheet_control", privilege: "mutation") @transaction
   
   palletizingPallets (
     refOrderNo: String!
@@ -588,7 +592,7 @@ export const Query = /* GraphQL */ `
 
   pickingWorksheet (
     releaseGoodNo: String!, locationSortingRules: [Sorting]
-  ): ExecutingWorksheet @privilege(category: "worksheet", privilege: "query")
+  ): ExecutingWorksheet @privilege(category: "worksheet", privilege: "query") @transaction
 
   sortingWorksheet (
     releaseGoodNo: String!

package/server/utils/inventory-util.ts

@@ -59,10 +59,36 @@ export async function generateInventoryHistory(
       palletId: inventory.palletId,
       seq: seq - 1
     })
+
     openingQty = lastInvHistory.openingQty + lastInvHistory.qty
     openingUomValue = lastInvHistory.openingUomValue + lastInvHistory.uomValue
   }
 
+  if (transactionType == 'PICKING' || transactionType == 'UNLOADING') {
+    const [findSameOrderHistory, total]: InventoryHistory = await invHistoryRepo.findAndCount({
+      domain: inventory.domain,
+      palletId: inventory.palletId,
+      refOrderId: refOrder.id
+    })
+
+    if (findSameOrderHistory) {
+      let prevTotalQty = 0
+      let prevTotalUomValue = 0
+      for (let oh of findSameOrderHistory) {
+        prevTotalQty += oh.qty
+        prevTotalUomValue += oh.uomValue
+      }
+      qty -= prevTotalQty
+      uomValue -= prevTotalUomValue
+    }
+  } else if (transactionType == 'UNDO_UNLOADING' || transactionType == 'RETURN') {
+    qty = qty
+    uomValue = uomValue
+  } else {
+    qty = 0
+    uomValue = 0
+  }
+
   let inventoryHistory: InventoryHistory = new InventoryHistory()
   inventoryHistory.name = InventoryNoGenerator.inventoryHistoryName()
   inventoryHistory.description = inventory.description