@things-factory/worksheet-base 4.0.11 → 4.0.16

package/server/graphql/resolvers/worksheet/recommend-putway-location.ts

@@ -1,10 +1,13 @@
+import { getRepository, In } from 'typeorm'
+
 import { ArrivalNotice, ReturnOrder } from '@things-factory/sales-base'
 import { Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
-import { Location, LOCATION_STATUS, LOCATION_TYPE, Warehouse } from '@things-factory/warehouse-base'
-import { In, getRepository, Not } from 'typeorm'
+import { Inventory, Location, LOCATION_STATUS, LOCATION_TYPE, Warehouse } from '@things-factory/warehouse-base'
+
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../entities'
+import { isInventoryExpiring } from '../../../utils/inventory-util'
 
 export const recommendPutawayLocationResolver = {
   async recommendPutawayLocation(
@@ -17,14 +20,22 @@ export const recommendPutawayLocationResolver = {
     const worksheetDetail: WorksheetDetail = await getRepository(WorksheetDetail).findOne(
       { domain, name: worksheetDetailName },
       {
-        relations: ['worksheet', 'worksheet.arrivalNotice', 'worksheet.returnOrder']
+        relations: [
+          'worksheet',
+          'worksheet.arrivalNotice',
+          'worksheet.returnOrder',
+          'targetInventory',
+          'targetInventory.inventory'
+        ]
       }
     )
 
+    const inventory: Inventory = worksheetDetail.targetInventory.inventory
     if (worksheetDetail.status !== WORKSHEET_STATUS.EXECUTING) throw new Error('Current target is not processing')
 
     const arrivalNotice: ArrivalNotice = worksheetDetail.worksheet.arrivalNotice
     const returnOrder: ReturnOrder = worksheetDetail.worksheet.returnOrder
+
     let unloadingWS: Worksheet
     if (arrivalNotice) {
       unloadingWS = await getRepository(Worksheet).findOne({
@@ -37,19 +48,41 @@ export const recommendPutawayLocationResolver = {
         relations: ['bufferLocation', 'bufferLocation.warehouse']
       })
     }
+
     const targetWarehouse: Warehouse = unloadingWS.bufferLocation.warehouse
     const sortingLevelSetting: Setting = await getRepository(Setting).findOne({
       where: { domain, name: 'location-recommendation-level' }
     })
     const sortingLevel = sortingLevelSetting?.value
 
+    const isExpiring: boolean = await isInventoryExpiring(inventory)
+
+    let recommendedLocations: Location[] = []
+    if (isExpiring) {
+      switch (sortingLevel) {
+        case 'level 1':
+          recommendedLocations = await recommendQuarantineLocationLevel1(domain, targetWarehouse, optCnt)
+          break
+
+        default:
+          recommendedLocations = await recommendQuarantineLocationLevel1(domain, targetWarehouse, optCnt)
+          break
+      }
+    }
+
+    if (recommendedLocations.length > 0) return recommendedLocations
+
     switch (sortingLevel) {
       case 'level 1':
-        return recommendLocationLevel1(domain, targetWarehouse, optCnt)
+        recommendedLocations = await recommendLocationLevel1(domain, targetWarehouse, optCnt)
+        break
 
       default:
-        return recommendLocationLevel1(domain, targetWarehouse, optCnt)
+        recommendedLocations = await recommendLocationLevel1(domain, targetWarehouse, optCnt)
+        break
     }
+
+    return recommendedLocations
   }
 }
 
@@ -57,6 +90,23 @@ export async function recommendLocationLevel1(
   domain: Domain,
   warehouse: Warehouse,
   optCnt: number
+): Promise<Location[]> {
+  return await getEmptyLocations(domain, warehouse, optCnt, [LOCATION_TYPE.SHELF, LOCATION_TYPE.FLOOR])
+}
+
+export async function recommendQuarantineLocationLevel1(
+  domain: Domain,
+  warehouse: Warehouse,
+  optCnt: number
+): Promise<Location[]> {
+  return await getEmptyLocations(domain, warehouse, optCnt, [LOCATION_TYPE.QUARANTINE])
+}
+
+export async function getEmptyLocations(
+  domain: Domain,
+  warehouse: Warehouse,
+  optCnt: number,
+  allowedTypes: LOCATION_TYPE[]
 ): Promise<Location[]> {
   const orderSetting: Setting = await getRepository(Setting).findOne({
     where: { domain, name: 'rule-for-storing-product' }
@@ -69,7 +119,7 @@ export async function recommendLocationLevel1(
       domain,
       warehouse,
       status: LOCATION_STATUS.EMPTY,
-      type: Not(In([LOCATION_TYPE.BUFFER, LOCATION_TYPE.BIN]))
+      type: In(allowedTypes)
     },
     order,
     take: optCnt

package/server/graphql/resolvers/worksheet/unloaded-inventories.ts

@@ -32,7 +32,7 @@ export const unloadedInventories = {
     const returnOrder: ReturnOrder = foundWorksheetDetails[0].worksheet.returnOrder
     const customerBizplace: Bizplace = foundWorksheetDetails[0].bizplace
     if (arrivalNotice) {
-      return await getRepository(Inventory).find({
+      let foundInv = await getRepository(Inventory).find({
         where: {
           domain,
           bizplace: customerBizplace,
@@ -44,6 +44,15 @@ export const unloadedInventories = {
         },
         relations: ['reusablePallet', 'product', 'bizplace']
       })
+      const items = foundInv.map((inv: Inventory) => {
+        const expirationDate: Date = inv.expirationDate ? new Date(inv.expirationDate) : null
+        return {
+          ...inv,
+          expirationDate: expirationDate
+        }
+      })
+
+      return items
     }
 
     if (returnOrder) {

package/server/graphql/resolvers/worksheet/unloading-return-worksheet.ts

@@ -1,10 +1,12 @@
+import { getRepository } from 'typeorm'
+
 import { Bizplace } from '@things-factory/biz-base'
+import { OrderInventory, ReturnOrder } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import { fetchExecutingWorksheet } from '../../../utils'
-import { ReturnOrder, OrderInventory } from '@things-factory/sales-base'
+
 import { WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../entities'
+import { fetchExecutingWorksheet } from '../../../utils'
 
 export const unloadingReturnWorksheetResolver = {
   async unloadingReturnWorksheet(_: any, { returnOrderNo }, context: any) {
@@ -59,7 +61,7 @@ export const unloadingReturnWorksheetResolver = {
           description: productWSD.description,
           targetName: targetInventory.name,
           packingType: targetInventory.packingType,
-          packingSize: targetInventory.packingSize,
+          packingSize: targetInventory.inventory.packingSize,
           palletQty: targetInventory.palletQty,
           actualPalletQty: targetInventory.actualPalletQty,
           packQty: targetInventory.returnQty,

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

@@ -1,9 +1,11 @@
-import { Domain } from '@things-factory/shell'
 import { EntityManager } from 'typeorm'
-import { Inventory } from '@things-factory/warehouse-base'
-import { OrderInventory, OrderNoGenerator, ORDER_INVENTORY_STATUS } from '@things-factory/sales-base'
-import { Product } from '@things-factory/product-base'
+
 import { User } from '@things-factory/auth-base'
+import { Product } from '@things-factory/product-base'
+import { ORDER_INVENTORY_STATUS, OrderInventory, OrderNoGenerator } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../entities'
 import { WorksheetNoGenerator } from '../../../utils'
@@ -14,84 +16,108 @@ export const generateReleaseGoodWorksheetDetailsResolver = {
     { worksheetNo, batchId, productId, packingType, packingSize, worksheetDetails },
     context: any
   ): Promise<void> {
-    const { tx, user, domain }: { tx: EntityManager; user: User; domain: Domain } = context.state
-    // 1. Remove prev worksheet details if it's exists
-    const worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
-      where: { name: worksheetNo, domain },
-      relations: [
-        'bizplace',
-        'releaseGood',
-        'worksheetDetails',
-        'worksheetDetails.targetInventory',
-        'worksheetDetails.targetInventory.product'
-      ]
-    })
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    return await generateReleaseGoodWorksheetDetails(
+      tx,
+      domain,
+      user,
+      worksheetNo,
+      batchId,
+      productId,
+      packingType,
+      packingSize,
+      worksheetDetails
+    )
+  }
+}
 
-    const prevWSDs: WorksheetDetail[] = worksheet.worksheetDetails.filter((wsd: WorksheetDetail) => {
-      const targetInv: OrderInventory = wsd.targetInventory
-      if (targetInv.batchId === batchId && targetInv.product.id === productId && targetInv.packingType === packingType)
-        return wsd.id
-    })
+export async function generateReleaseGoodWorksheetDetails(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetNo: string,
+  batchId: string,
+  productId: string,
+  packingType: string,
+  packingSize: number,
+  worksheetDetails: Partial<WorksheetDetail>[]
+): Promise<void> {
+  // 1. Remove prev worksheet details if it's exists
+  const worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+    where: { name: worksheetNo, domain },
+    relations: [
+      'bizplace',
+      'releaseGood',
+      'worksheetDetails',
+      'worksheetDetails.targetInventory',
+      'worksheetDetails.targetInventory.product'
+    ]
+  })
 
-    // TODO: Delete order inventories
-    if (prevWSDs?.length) {
-      const wsdIds: string[] = prevWSDs.map((wsd: WorksheetDetail) => wsd.id)
-      const prevOrderInvIds: string[] = prevWSDs.map((wsd: WorksheetDetail) => wsd.targetInventory.id)
-      await tx.getRepository(WorksheetDetail).delete(wsdIds)
-      await tx.getRepository(OrderInventory).delete(prevOrderInvIds)
-    }
+  const prevWSDs: WorksheetDetail[] = worksheet.worksheetDetails.filter((wsd: WorksheetDetail) => {
+    const targetInv: OrderInventory = wsd.targetInventory
+    if (targetInv.batchId === batchId && targetInv.product.id === productId && targetInv.packingType === packingType)
+      return wsd.id
+  })
+
+  // TODO: Delete order inventories
+  if (prevWSDs?.length) {
+    const wsdIds: string[] = prevWSDs.map((wsd: WorksheetDetail) => wsd.id)
+    const prevOrderInvIds: string[] = prevWSDs.map((wsd: WorksheetDetail) => wsd.targetInventory.id)
+    await tx.getRepository(WorksheetDetail).delete(wsdIds)
+    await tx.getRepository(OrderInventory).delete(prevOrderInvIds)
+  }
 
-    await Promise.all(
-      worksheetDetails.map(async (wsd: WorksheetDetail) => {
-        // 2. Create order inventory
-        let targetInventory: OrderInventory = wsd.targetInventory
-        const inventory: Inventory = await tx.getRepository(Inventory).findOne(targetInventory.inventory.id)
+  await Promise.all(
+    worksheetDetails.map(async (wsd: WorksheetDetail) => {
+      // 2. Create order inventory
+      let targetInventory: OrderInventory = wsd.targetInventory
+      const inventory: Inventory = await tx.getRepository(Inventory).findOne(targetInventory.inventory.id)
 
-        targetInventory = await tx.getRepository(OrderInventory).save({
-          ...targetInventory,
-          domain,
-          bizplace: worksheet.bizplace,
-          name: OrderNoGenerator.orderInventory(),
-          releaseGood: worksheet.releaseGood,
-          inventory,
-          batchId,
-          batchIdRef: inventory.batchIdRef,
-          status: ORDER_INVENTORY_STATUS.READY_TO_PICK,
-          product: await tx.getRepository(Product).findOne(productId),
-          packingType,
-          packingSize,
-          creator: user,
-          updater: user
-        })
+      targetInventory = await tx.getRepository(OrderInventory).save({
+        ...targetInventory,
+        domain,
+        bizplace: worksheet.bizplace,
+        name: OrderNoGenerator.orderInventory(),
+        releaseGood: worksheet.releaseGood,
+        inventory,
+        batchId,
+        batchIdRef: inventory.batchIdRef,
+        status: ORDER_INVENTORY_STATUS.READY_TO_PICK,
+        product: await tx.getRepository(Product).findOne(productId),
+        packingType,
+        packingSize,
+        creator: user,
+        updater: user
+      })
 
-        const currentLockedQty: any = inventory.lockedQty
-        const currentLockedUomValue: any = inventory.lockedUomValue
+      const currentLockedQty: any = inventory.lockedQty
+      const currentLockedUomValue: any = inventory.lockedUomValue
 
-        await tx.getRepository(Inventory).save({
-          ...targetInventory.inventory,
-          lockedQty: Boolean(currentLockedQty)
-            ? targetInventory.releaseQty + currentLockedQty
-            : targetInventory.releaseQty,
-          lockedUomValue: Boolean(currentLockedUomValue)
-            ? targetInventory.releaseUomValue + currentLockedUomValue
-            : targetInventory.releaseUomValue,
-          updater: user
-        })
+      await tx.getRepository(Inventory).save({
+        ...targetInventory.inventory,
+        lockedQty: Boolean(currentLockedQty)
+          ? targetInventory.releaseQty + currentLockedQty
+          : targetInventory.releaseQty,
+        lockedUomValue: Boolean(currentLockedUomValue)
+          ? targetInventory.releaseUomValue + currentLockedUomValue
+          : targetInventory.releaseUomValue,
+        updater: user
+      })
 
-        // 3. Create worksheet details
-        await tx.getRepository(WorksheetDetail).save({
-          ...wsd,
-          domain,
-          bizplace: worksheet.bizplace,
-          worksheet,
-          name: WorksheetNoGenerator.pickingDetail(),
-          targetInventory,
-          type: WORKSHEET_TYPE.PICKING,
-          status: WORKSHEET_STATUS.DEACTIVATED,
-          creator: user,
-          updater: user
-        })
+      // 3. Create worksheet details
+      await tx.getRepository(WorksheetDetail).save({
+        ...wsd,
+        domain,
+        bizplace: worksheet.bizplace,
+        worksheet,
+        name: WorksheetNoGenerator.pickingDetail(),
+        targetInventory,
+        type: WORKSHEET_TYPE.PICKING,
+        status: WORKSHEET_STATUS.DEACTIVATED,
+        creator: user,
+        updater: user
       })
-    )
-  }
+    })
+  )
 }

package/server/graphql/types/index.ts

@@ -1,10 +1,15 @@
-import * as Pallet from './pallet'
 import * as Worksheet from './worksheet'
 import * as WorksheetDetail from './worksheet-detail'
 import * as WorksheetMovement from './worksheet-movement'
+import * as PalletOutbound from './pallet'
 
-export const queries = [Worksheet.Query, WorksheetDetail.Query, WorksheetMovement.Query]
+export const queries = [Worksheet.Query, WorksheetDetail.Query, WorksheetMovement.Query, PalletOutbound.Query]
 
-export const mutations = [Worksheet.Mutation, WorksheetDetail.Mutation, WorksheetMovement.Mutation, Pallet.Mutation]
+export const mutations = [
+  Worksheet.Mutation,
+  WorksheetDetail.Mutation,
+  WorksheetMovement.Mutation,
+  PalletOutbound.Mutation
+]
 
-export const types = [...Worksheet.Types, ...WorksheetDetail.Types, ...WorksheetMovement.Types]
+export const types = [...Worksheet.Types, ...WorksheetDetail.Types, ...WorksheetMovement.Types, ...PalletOutbound.Types]

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

@@ -1,6 +1,12 @@
+import { PalletPatch } from './pallet'
+
 export const Mutation = /* GraphQL */ `
-  palletOutbound(
+  palletOutbound (
     refOrderNo: String!
-    patches: [PalletPatch]!
+    patches: [PalletPatch]
   ): Boolean @transaction
 `
+
+export const Types = /* GraphQL */ [PalletPatch]
+
+export const Query = /* GraphQL */ ``

package/server/graphql/types/pallet/pallet.ts

@@ -0,0 +1,7 @@
+import { gql } from 'apollo-server-koa'
+
+export const PalletPatch = gql`
+  input PalletPatch {
+    name: String
+  }
+`

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

@@ -290,6 +290,8 @@ export const Mutation = /* GraphQL */ `
     cartonId: String
     locationName: String!
     releaseQty: Int!
+    binLocation: String
+    serialNumber: String
   ): Boolean @privilege(category: "worksheet_execute", privilege: "mutation") @transaction
 
   scanProductPicking (
@@ -298,6 +300,7 @@ export const Mutation = /* GraphQL */ `
     productBarcode: String!
     cartonId: String!
     binLocation: String
+    serialNumber: String
   ): Boolean @privilege(category: "worksheet_execute", privilege: "mutation") @transaction
 
   sortingProduct (
@@ -515,6 +518,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 +594,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!
@@ -662,7 +668,7 @@ export const Query = /* GraphQL */ `
   findReleaseOrdersByTaskNo(taskNo: String!): [ReleaseGood] @privilege(category: "worksheet", privilege: "query") @transaction
 `
 
-export const Types = /* GraphQL */ [
+export const Types = /* GraphQL */[
   Worksheet,
   AirwayBill,
   NewWorksheet,

package/server/index.ts

@@ -4,4 +4,5 @@ export * from './constants'
 export * from './entities'
 export * from './graphql'
 export * from './graphql/resolvers/worksheet/generate-worksheet/generate-release-good-worksheet'
+export * from './graphql/resolvers/worksheet-detail/generate-release-good-worksheet-details'
 export * from './migrations'

package/server/routes.ts

@@ -2,6 +2,7 @@ import { renderElcclGRN } from './controllers/render-elccl-grn'
 import { renderGRN } from './controllers/render-grn'
 import { renderJobSheet } from './controllers/render-job-sheet'
 import { renderKimedaGRN } from './controllers/render-kimeda-grn'
+import { renderManifest } from './controllers/render-manifest'
 import { renderManualDO } from './controllers/render-manual-do'
 import { renderOrientageDO } from './controllers/render-orientage-do'
 import { renderOrientageGRN } from './controllers/render-orientage-grn'
@@ -44,4 +45,8 @@ process.on('bootstrap-module-domain-private-route' as any, (app, routes) => {
   routes.get('/view_job_sheet/:ganNo/:timezoneOffSet', async (context, next) => {
     context.body = await renderJobSheet(context.params, context)
   })
+
+  routes.get('/view_manifest/:manifestNo', async (context, next) => {
+    context.body = await renderManifest(context.params, context)
+  })
 })

package/server/utils/inventory-util.ts

@@ -1,8 +1,4 @@
-import {
-  EntityManager,
-  getRepository,
-  Repository
-} from 'typeorm'
+import { EntityManager, getRepository, Repository } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
@@ -63,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
@@ -93,8 +115,6 @@ export async function generateInventoryHistory(
   inventoryHistory.uom = inventory.uom
   inventoryHistory.qty = qty
   inventoryHistory.openingQty = openingQty
-  inventoryHistory.weight = 0
-  inventoryHistory.openingWeight = 0
   inventoryHistory.uomValue = uomValue
   inventoryHistory.openingUomValue = openingUomValue
   inventoryHistory.unitCost = inventory.unitCost
@@ -221,7 +241,7 @@ export async function checkPalletIdenticallity(
  * @param trxMgr
  */
 export async function inventoriesByStrategy(
-  { worksheetId, batchId, bizplaceId, productId, packingType, packingSize, pickingStrategy, locationSortingRules },
+  { worksheetId, batchId, bizplaceId, productId, packingType, packingSize, uom, pickingStrategy, locationSortingRules },
   domain: Domain,
   trxMgr: EntityManager
 ) {
@@ -248,12 +268,14 @@ export async function inventoriesByStrategy(
     .andWhere('"PROD"."id" = :productId')
     .andWhere('"INV"."packing_type" = :packingType')
     .andWhere('"INV"."packing_size" = :packingSize')
+    .andWhere('"INV"."uom" = :uom')
     .andWhere('"INV"."status" = :status', { status: 'STORED' })
     .setParameters({
       domainId: domain.id,
       productId,
       packingType,
-      packingSize
+      packingSize,
+      uom
     })
 
   if (batchId !== '') {
@@ -348,3 +370,25 @@ export async function inventoriesByStrategy(
   const total: number = await qb.getCount()
   return { items, total }
 }
+
+export async function isInventoryExpiring(inventory: Inventory): Promise<boolean> {
+  if (!inventory.id) throw new Error('No inventory id provided')
+  let product: Product | undefined = inventory.product
+  if (!product) {
+    inventory = await getRepository(Inventory).findOne(inventory.id, {
+      relations: ['product']
+    })
+    product = inventory.product
+  }
+
+  const { expirationDate } = inventory
+  const { isRequiredCheckExpiry, expirationPeriod } = product
+
+  if (!isRequiredCheckExpiry || !expirationPeriod || expirationDate <= 0) return false
+
+  let date: Date = new Date()
+  const acceptBefore: Date = new Date(date.setDate(date.getDate() + expirationPeriod))
+  const expiryDate: Date = new Date(expirationDate)
+
+  return expiryDate < acceptBefore
+}