@things-factory/worksheet-base 5.0.0-alpha.5 → 5.0.0-alpha.52

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

@@ -1,7 +1,13 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
-import { OrderInventory, ORDER_INVENTORY_STATUS, ORDER_STATUS, ReleaseGood } from '@things-factory/sales-base'
+import { Bizplace, Company } from '@things-factory/biz-base'
+import { FulfillmentCenter } from '@things-factory/integration-fulfillment'
+import { Sftp, SftpAPI } from '@things-factory/integration-sftp'
+import { ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+import { InventoryItem } from '@things-factory/warehouse-base'
+
 import { WORKSHEET_TYPE } from '../../../../constants'
 import { LoadingWorksheetController, ReturningWorksheetController } from '../../../../controllers'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
@@ -20,14 +26,19 @@ export async function completeLoading(
   releaseGoodNo: string
 ): Promise<void> {
   const worksheetController: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
-  const releaseGood: ReleaseGood = await worksheetController.findRefOrder(ReleaseGood, {
-    domain,
-    name: releaseGoodNo,
-    status: ORDER_STATUS.LOADING
-  })
+  const releaseGood: ReleaseGood = await worksheetController.findRefOrder(
+    ReleaseGood,
+    {
+      domain,
+      name: releaseGoodNo,
+      status: ORDER_STATUS.LOADING
+    },
+    ['bizplace', 'bizplace.domain']
+  )
   const worksheet: Worksheet = await worksheetController.findWorksheetByRefOrder(releaseGood, WORKSHEET_TYPE.LOADING, [
     'worksheetDetails',
-    'worksheetDetails.targetInventory'
+    'worksheetDetails.targetInventory',
+    'worksheetDetails.targetInventory.product'
   ])
   const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
   const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => wsd.targetInventory)
@@ -35,6 +46,54 @@ export async function completeLoading(
     (targetInventory: OrderInventory) => targetInventory.status === ORDER_INVENTORY_STATUS.LOADING
   )
 
+  // Search Warehouse Company Domain
+  const warehouseCompanyBizplace: Bizplace = await tx
+    .getRepository(Bizplace)
+    .findOne({ where: { domain }, relations: ['company'] })
+
+  const warehouseCompany: Company = warehouseCompanyBizplace.company
+  const warehouseBizplaces: Bizplace[] = await tx
+    .getRepository(Bizplace)
+    .find({ where: { company: warehouseCompany }, relations: ['domain'] })
+  const warehouseCompanyBizplaces: Bizplace[] = warehouseBizplaces.filter(biz => biz.domain.extType == 'company')
+  const warehouseCompanyDomain: Domain = warehouseCompanyBizplaces[0].domain
+
+  const customerDomain: Domain = releaseGood.bizplace.domain
+  const fulfillmentCenter: FulfillmentCenter = await tx
+    .getRepository(FulfillmentCenter)
+    .findOne({ domain: warehouseCompanyDomain, centerId: domain.subdomain, status: 'active' })
+
+  if (fulfillmentCenter) {
+    let customerAvailableSftp: Sftp = await tx.getRepository(Sftp).findOne({
+      where: { domain: customerDomain, status: 'ACTIVE', fulfillmentCenter }
+    })
+    if (customerAvailableSftp) {
+      const responseFileTypes: any = JSON.parse(customerAvailableSftp.responseFileTypes)
+
+      let inventoryItems: InventoryItem[] = await tx.getRepository(InventoryItem).find({
+        where: { domain, outboundOrderId: releaseGood.id }
+      })
+
+      if (responseFileTypes.enableShipment) {
+        let shipmentResult: Sftp = await SftpAPI.createShipment(customerAvailableSftp, {
+          releaseGood,
+          orderInventories: targetInventories,
+          sftp: customerAvailableSftp
+        })
+        customerAvailableSftp = await tx.getRepository(Sftp).save(shipmentResult)
+      }
+
+      if (responseFileTypes.enableSerialNumber) {
+        let snResult: Sftp = await SftpAPI.createSerialNumber(customerAvailableSftp, {
+          releaseGood,
+          inventoryItems,
+          sftp: customerAvailableSftp
+        })
+        customerAvailableSftp = await tx.getRepository(Sftp).save(snResult)
+      }
+    }
+  }
+
   await worksheetController.completeLoading(releaseGoodNo)
 
   if (remainInventories.length) {

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

@@ -9,7 +9,7 @@ import { WorksheetDetail } from '../../../../entities'
 export const loadingResolver = {
   async loading(_: any, { loadedWorksheetDetails, releaseGoodNo, orderInfo }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await loading(tx, domain, user, loadedWorksheetDetails, releaseGoodNo)
+    const worksheetDetails = await loading(tx, domain, user, loadedWorksheetDetails, releaseGoodNo)
     const worksheetController: WorksheetController = new WorksheetController(tx, domain, user)
     const releaseGood: ReleaseGood = await worksheetController.findRefOrder(
       ReleaseGood,
@@ -18,14 +18,7 @@ export const loadingResolver = {
     )
 
     const loadingWorksheetController: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
-    let targetInventories: OrderInventory[] = []
-    for (let worksheetDetail of loadedWorksheetDetails) {
-      worksheetDetail = await loadingWorksheetController.findWorksheetDetailByName(worksheetDetail.name, [
-        'targetInventory'
-      ])
-      const targetInventory = worksheetDetail.targetInventory
-      targetInventories.push(targetInventory)
-    }
+    let targetInventories: OrderInventory[] = worksheetDetails.map(itm => itm.targetInventory)
 
     const bizplace: Bizplace = releaseGood.bizplace
     orderInfo = {
@@ -41,9 +34,9 @@ export async function loading(
   tx: EntityManager,
   domain: Domain,
   user: User,
-  worksheetDetails: Partial<WorksheetDetail & { loadedQty: number }>[],
+  worksheetDetails: Partial<WorksheetDetail & { loadedQty: number } & { toteName: string }>[],
   releaseGoodNo: string
-): Promise<void> {
+): Promise<any> {
   const worksheetController: LoadingWorksheetController = new LoadingWorksheetController(tx, domain, user)
-  await worksheetController.loading(releaseGoodNo, worksheetDetails)
+  return await worksheetController.loading(releaseGoodNo, worksheetDetails)
 }

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

@@ -1,6 +1,13 @@
 import { Equal, getRepository, In, Not, SelectQueryBuilder } from 'typeorm'
 
-import { ORDER_STATUS, ORDER_INVENTORY_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
+import {
+  ORDER_STATUS,
+  ORDER_INVENTORY_STATUS,
+  OrderInventory,
+  ReleaseGood,
+  OrderTote,
+  OrderToteItem
+} from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, Location } from '@things-factory/warehouse-base'
 
@@ -27,7 +34,9 @@ export const loadingWorksheetResolver = {
         .innerJoinAndSelect('releaseGood.bizplace', 'bizplace')
         .innerJoinAndSelect('bizplace.domain', 'domain')
         .where('orderInventory.domain_id = :domainId', { domainId: domain.id })
-        .andWhere('orderInventory.status IN (:...orderInventoryStatus)', { orderInventoryStatus: [ORDER_INVENTORY_STATUS.LOADING, ORDER_INVENTORY_STATUS.LOADED] })
+        .andWhere('orderInventory.status IN (:...orderInventoryStatus)', {
+          orderInventoryStatus: [ORDER_INVENTORY_STATUS.LOADING, ORDER_INVENTORY_STATUS.LOADED]
+        })
         .andWhere('orderInventory.bin_location_id = :locationId', { locationId: binLocation.id })
         .andWhere('releaseGood.status = :status', { status: ORDER_STATUS.LOADING })
 
@@ -41,6 +50,10 @@ export const loadingWorksheetResolver = {
 
     if (!releaseGood) throw new Error(`Release good doesn't exists.`)
 
+    let [orderTotes, orderTotesTotal]: OrderTote = await getRepository(OrderTote).findAndCount({
+      where: { releaseGood: releaseGood.id }
+    })
+
     const foundWorksheet: Worksheet = await fetchExecutingWorksheet(
       domain,
       releaseGood.bizplace,
@@ -48,7 +61,7 @@ export const loadingWorksheetResolver = {
       WORKSHEET_TYPE.LOADING,
       releaseGood
     )
-    const foundWSD: WorksheetDetail[] = await getRepository(WorksheetDetail).find({
+    let foundWSD: any[] = await getRepository(WorksheetDetail).find({
       where: {
         domain,
         worksheet: foundWorksheet,
@@ -57,21 +70,50 @@ export const loadingWorksheetResolver = {
       },
       relations: [
         'targetInventory',
+        'targetInventory.orderProduct',
         'targetInventory.inventory',
         'targetInventory.inventory.location',
         'targetInventory.inventory.product'
       ]
     })
 
-    return {
-      worksheetInfo: {
-        releaseGood,
-        bizplaceName: releaseGood.bizplace.name,
-        startedAt: foundWorksheet.startedAt,
-        refNo: releaseGood.refNo,
-        ownCollection: releaseGood.ownTransport
-      },
-      worksheetDetailInfos: foundWSD.map(async (loadingWSD: WorksheetDetail) => {
+    if (orderTotesTotal > 0) {
+      let [toteItems, toteItemsTotal]: OrderToteItem = await getRepository(OrderToteItem).findAndCount({
+        where: { orderTote: In(orderTotes.map(itm => itm.id)) },
+        relations: ['orderTote', 'orderInventory']
+      })
+
+      let toteWsd = []
+
+      for (let i = 0; i < toteItemsTotal; i++) {
+        let wsdIndex = foundWSD.findIndex(
+          itm => !itm?.toteName && itm.targetInventory.id == toteItems[i].orderInventory.id
+        )
+
+        if (wsdIndex >= 0) {
+          let filterWSD: any = JSON.parse(JSON.stringify(foundWSD[wsdIndex]))
+          let uomValue =
+            Math.round((filterWSD.targetInventory.releaseUomValue / filterWSD.targetInventory.releaseQty) * 100) / 100
+
+          foundWSD[wsdIndex].targetInventory.releaseQty -= toteItems[i].qty
+          foundWSD[wsdIndex].targetInventory.pickedQty -= toteItems[i].qty
+          foundWSD[wsdIndex].targetInventory.releaseUomValue = foundWSD[wsdIndex].targetInventory.releaseQty * uomValue
+
+          filterWSD.targetInventory.releaseQty = toteItems[i].qty
+          filterWSD.targetInventory.pickedQty = toteItems[i].qty
+          filterWSD.targetInventory.releaseUomValue = toteItems[i].qty * uomValue
+          filterWSD.toteName = toteItems[i].orderTote.name
+          toteWsd.push(filterWSD)
+        }
+      }
+
+      foundWSD = foundWSD.concat(toteWsd)
+      foundWSD.sort((a, b) => (a.toteName > b.toteName ? 1 : -1))
+    }
+
+    let worksheetDetailInfos = foundWSD
+      .filter(itm => itm.targetInventory.releaseQty > 0)
+      .map((loadingWSD: any) => {
         const targetInventory: OrderInventory = loadingWSD.targetInventory
         const inventory: Inventory = targetInventory.inventory
         return {
@@ -87,9 +129,20 @@ export const loadingWorksheetResolver = {
           targetName: targetInventory.name,
           packingType: inventory.packingType,
           packingSize: inventory.packingSize,
-          inventory: targetInventory.inventory
+          inventory: targetInventory.inventory,
+          toteName: loadingWSD.toteName
         }
       })
+
+    return {
+      worksheetInfo: {
+        releaseGood,
+        bizplaceName: releaseGood.bizplace.name,
+        startedAt: foundWorksheet.startedAt,
+        refNo: releaseGood.refNo,
+        ownCollection: releaseGood.ownTransport
+      },
+      worksheetDetailInfos
     }
   }
 }

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

@@ -2,10 +2,12 @@ import { activatePackingResolver } from './activate-packing'
 import { completePackingResolver } from './complete-packing'
 import { packingResolver } from './packing'
 import { scanProductPackingResolver } from './scan-product-packing'
+import { undoSerialNumberPackingResolver } from './undo-serial-number-packing'
 
 export const Mutations = {
   ...activatePackingResolver,
   ...completePackingResolver,
   ...packingResolver,
-  ...scanProductPackingResolver
+  ...scanProductPackingResolver,
+  ...undoSerialNumberPackingResolver
 }

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

@@ -9,9 +9,9 @@ import { PackingWorksheetController, SellercraftController } from '../../../../c
 import { Worksheet } from '../../../../entities'
 
 export const packingResolver = {
-  async packing(_: any, { worksheetDetailName, releaseQty }, context: any) {
+  async packing(_: any, { worksheetDetailName, releaseQty, serialNumber }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await packing(tx, domain, user, worksheetDetailName, releaseQty)
+    await packing(tx, domain, user, worksheetDetailName, releaseQty, serialNumber)
   }
 }
 
@@ -20,10 +20,11 @@ export async function packing(
   domain: Domain,
   user: User,
   worksheetDetailName: string,
-  releaseQty: number
+  releaseQty: number,
+  serialNumber: string
 ) {
   const worksheetController: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
-  const worksheetDetail = await worksheetController.packing(worksheetDetailName, releaseQty)
+  const worksheetDetail = await worksheetController.packing(worksheetDetailName, releaseQty, serialNumber)
 
   let releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
   const worksheet: Worksheet = worksheetDetail.worksheet

package/server/graphql/resolvers/worksheet/packing/scan-product-packing.ts

@@ -9,9 +9,9 @@ import { PackingWorksheetController, SellercraftController } from '../../../../c
 import { Worksheet } from '../../../../entities'
 
 export const scanProductPackingResolver = {
-  async scanProductPacking(_: any, { worksheetDetailName, productBarcode }, context: any) {
+  async scanProductPacking(_: any, { worksheetDetailName, productBarcode, serialNumber }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await scanProductPacking(tx, domain, user, worksheetDetailName, productBarcode)
+    await scanProductPacking(tx, domain, user, worksheetDetailName, productBarcode, serialNumber)
   }
 }
 
@@ -20,10 +20,15 @@ export async function scanProductPacking(
   domain: Domain,
   user: User,
   worksheetDetailName: string,
-  productBarcode: string
+  productBarcode: string,
+  serialNumber?: string
 ) {
   const worksheetController: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
-  const worksheetDetail = await worksheetController.scanProductPacking(worksheetDetailName, productBarcode)
+  const worksheetDetail = await worksheetController.scanProductPacking(
+    worksheetDetailName,
+    productBarcode,
+    serialNumber
+  )
 
   let releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
   const worksheet: Worksheet = worksheetDetail.worksheet

package/server/graphql/resolvers/worksheet/packing/undo-serial-number-packing.ts

@@ -0,0 +1,24 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { PackingWorksheetController } from '../../../../controllers'
+
+export const undoSerialNumberPackingResolver = {
+  async undoSerialNumberPacking(_: any, { worksheetDetailName, inventoryItemId }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    await undoSerialNumberPacking(tx, domain, user, worksheetDetailName, inventoryItemId)
+  }
+}
+
+async function undoSerialNumberPacking(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: string,
+  inventoryItemId: string
+): Promise<void> {
+  const worksheetController: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
+  await worksheetController.undoSerialNumberPacking(worksheetDetailName, inventoryItemId)
+}