@things-factory/worksheet-base 5.0.12 → 6.0.0-alpha.0

package/server/graphql/resolvers/worksheet/fetch-delivery-order-ro.ts

@@ -0,0 +1,190 @@
+import _ from 'lodash'
+import { Equal, In } from 'typeorm'
+
+import { Bizplace, ContactPoint } from '@things-factory/biz-base'
+import { DeliveryOrder, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
+import { Domain, getRepository } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
+import { WorksheetDetail } from '../../../entities'
+import { DateTimeConverter } from '../../../utils'
+
+export const fetchDeliveryOrderROResolver = {
+  async fetchDeliveryOrderRO(_: any, { name }, context: ResolverContext) {
+    const domain: Domain = await getRepository(Domain).findOne({
+      where: { id: context.state.domain.id }
+    })
+
+    const foundDO: DeliveryOrder = await getRepository(DeliveryOrder).findOne({
+      where: { domain: { id: domain.id }, name },
+      relations: [
+        'domain',
+        'bizplace',
+        'bizplace.company',
+        'bizplace.domain',
+        'transportDriver',
+        'transportVehicle',
+        'releaseGood',
+        'creator',
+        'updater'
+      ]
+    })
+
+    const ownTransportFlag: Boolean = foundDO.ownCollection
+
+    let foundCP: ContactPoint = null
+    if (foundDO?.contactPointRefId) {
+      foundCP = await getRepository(ContactPoint).findOne({
+        where: { domain: { id: domain.id }, id: foundDO.contactPointRefId }
+      })
+    }
+
+    const foundRO: ReleaseGood = foundDO.releaseGood
+    const partnerBiz: Bizplace = foundDO.bizplace //customer bizplace
+    const ownRefNo = foundRO.refNo
+
+    //find list of loaded inventory
+    const targetInventories: OrderInventory[] = await getRepository(OrderInventory).find({
+      where: { domain: { id: domain.id }, deliveryOrder: foundDO },
+      relations: ['inventory']
+    })
+    const orderInvIds: string[] = targetInventories.map((oi: any) => oi.id)
+
+    const foundWSD: WorksheetDetail[] = await getRepository(WorksheetDetail).find({
+      where: {
+        domain: { id: domain.id },
+        targetInventory: In(orderInvIds),
+        type: WORKSHEET_TYPE.LOADING,
+        status: Equal(WORKSHEET_STATUS.DONE)
+      },
+      relations: [
+        'targetInventory',
+        'targetInventory.inventory',
+        'targetInventory.inventory.location',
+        'targetInventory.inventory.product',
+        'targetInventory.inventory.product.productDetails',
+        'targetInventory.inventory.reusablePallet',
+        'updater'
+      ]
+    })
+
+    let foundDriver: any = null
+    if (foundDO.status !== ORDER_STATUS.READY_TO_DISPATCH) {
+      if (foundDO?.ownCollection && foundDO?.otherDriver) {
+        foundDriver = foundDO.otherDriver
+      } else {
+        foundDriver = foundDO.transportDriver.name
+      }
+    }
+
+    let productList: any[] = []
+    productList = foundWSD
+      .map((wsd: WorksheetDetail) => {
+        const targetInventory: OrderInventory = wsd.targetInventory
+        const inventory: Inventory = targetInventory.inventory
+        const productDetails: any[] = inventory.product.productDetails
+        const matchedProductDetail: any = productDetails.find(
+          productDetail => productDetail.packingType === inventory.packingType
+        )
+        return {
+          product_name: `${inventory.product.name} (${inventory.product.description})`,
+          product_desc: `${inventory.product?.description || ''}`,
+          product_nameOnly: `${inventory.product.name}`,
+          product_sku: `${inventory.product.sku}`,
+          product_type: inventory.packingType,
+          product_size: matchedProductDetail ? matchedProductDetail.packingSize : inventory.packingSize,
+          product_batch: inventory.batchId,
+          product_batch_ref: inventory.batchIdRef,
+          product_qty: targetInventory.releaseQty,
+          product_weight: targetInventory.releaseWeight,
+          product_gross_weight: inventory.product.grossWeight,
+          product_uom_value: targetInventory.releaseUomValue,
+          product_uom: inventory.uom,
+          remark: targetInventory.remark,
+          inventory_remark: inventory.remark,
+          cross_docking: targetInventory.crossDocking,
+          pallet: inventory?.reusablePallet && inventory?.reusablePallet?.name ? inventory.reusablePallet.name : ''
+        }
+      })
+      .reduce((newItem, item) => {
+        var foundItem = newItem.find(
+          newItem =>
+            newItem.product_name === item.product_name &&
+            newItem.product_batch === item.product_batch &&
+            newItem.product_batch_ref === item.product_batch_ref &&
+            newItem.cross_docking === item.cross_docking &&
+            newItem.pallet === item.pallet
+        )
+        if (!foundItem) {
+          foundItem = {
+            product_sku: item.product_sku,
+            product_name: item.product_name,
+            product_type: item.product_type,
+            product_size: item.product_size,
+            product_batch: item.product_batch,
+            product_batch_ref: item.product_batch_ref,
+            product_qty: item.product_qty,
+            product_weight: item.product_weight,
+            product_gross_weight: item.product_gross_weight,
+            product_uom_value: item.product_uom_value,
+            product_uom: item.product_uom,
+            product_desc: item.product_desc,
+            product_nameOnly: item.product_nameOnly,
+            remark: item.remark,
+            inventory_remark: item.inventory_remark,
+            palletQty: 1,
+            cross_docking: item.cross_docking,
+            pallet: item.pallet
+          }
+
+          newItem.push(foundItem)
+          return newItem
+        } else {
+          return newItem.map(ni => {
+            if (
+              ni.product_name === item.product_name &&
+              ni.product_batch === item.product_batch &&
+              ni.product_batch_ref === item.product_batch_ref &&
+              ni.cross_docking === item.cross_docking &&
+              ni.pallet === item.pallet
+            ) {
+              return {
+                ...ni,
+                palletQty: ni.palletQty + 1,
+                product_qty: ni.product_qty + item.product_qty,
+                product_weight: ni.product_weight + item.product_weight,
+                product_uom_value: ni.product_uom_value + item.product_uom_value
+              }
+            } else {
+              return ni
+            }
+          })
+        }
+      }, [])
+
+    const data = {
+      roNo: foundRO.name,
+      doNo: foundDO.name,
+      roRef: foundRO.refNo,
+      roRef2: foundRO.refNo2,
+      roRef3: foundRO.refNo3,
+      companyDomain: foundDO.bizplace.name,
+      recipientBiz: foundRO.attentionTo || '',
+      doDate: DateTimeConverter.date(foundDO.createdAt),
+      productList: productList.map((prod: any, idx) => {
+        return {
+          batchNo: prod.product_batch,
+          sku: prod.product_sku,
+          name: prod.product_name,
+          type: prod.product_type,
+          loadedQty: prod.product_qty,
+          uom: prod.product_uom,
+          uomValue: `${Math.round(prod.product_uom_value * 100) / 100}`
+        }
+      })
+    }
+
+    return data
+  }
+}

package/server/graphql/resolvers/worksheet/fetch-sellercraft-document.ts

@@ -0,0 +1,69 @@
+import { logger } from '@things-factory/env'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { ReleaseGood } from '@things-factory/sales-base'
+import { getRepository } from '@things-factory/shell'
+
+import { SellercraftController } from '../../../controllers'
+
+export const fetchSellercraftDocumentResolver = {
+  async fetchSellercraftDocument(_: any, { releaseGoodId }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+
+    //find release goods base on id
+    let releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
+      where: { domain: { id: domain.id }, id: releaseGoodId },
+      relations: ['bizplace', 'bizplace.domain']
+    })
+
+    //find user sellercraft data
+    const sellercraft: Sellercraft = await getRepository(Sellercraft).findOneBy({
+      domain: {
+        id: releaseGood.bizplace.domain.id
+      },
+      status: SellercraftStatus.ACTIVE
+    })
+
+    // instantiate sellercraft controller
+    const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+
+    try {
+      // fetch document if not found
+      if (sellercraft && !releaseGood?.airwayBill) {
+        try {
+          // try fetch order document / AWB
+          releaseGood = await sellercraftCtrl.fetchOrderDocument(sellercraft, releaseGood)
+        } catch (error) {
+          try {
+            // retry initiate order document
+            await sellercraftCtrl.initiateOrderDocument(sellercraft, releaseGood)
+          } catch (error) {
+            try {
+              // retry initiate order shipment / RTS
+              await sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
+            } catch (error) {
+              throw new Error(`initiateOrderShipment: ${error}`)
+            }
+            throw new Error(`initiateOrderDocument: ${error}`)
+          }
+          throw new Error(`fetchOrderDocument: ${error}`)
+        }
+      }
+
+      const airwayBill: string = releaseGood?.airwayBill
+      const invoice: string = releaseGood?.invoice
+      return { airwayBill, invoice }
+    } catch (error) {
+      // await sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
+      logger.error(
+        `packing-worksheet[getSellercraftDocument]:(data:${JSON.stringify({
+          sellercraft,
+          releaseGood,
+          domain,
+          user
+        })}) ${error} `
+      )
+
+      throw new Error('Waiting for AWB from marketplace. Please retry in awhile')
+    }
+  }
+}

package/server/graphql/resolvers/worksheet/find-release-orders-by-task-no.ts

@@ -1,54 +1,17 @@
-import { EntityManager, SelectQueryBuilder } from 'typeorm'
+import { SelectQueryBuilder } from 'typeorm'
 
-import {
-  ORDER_STATUS, ORDER_INVENTORY_STATUS,
-  OrderInventory as OrderInventoryEntity,
-  ReleaseGood as ReleaseGoodEntity
-} from '@things-factory/sales-base'
+import { OrderInventory as OrderInventoryEntity, ReleaseGood as ReleaseGoodEntity } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { Location } from '@things-factory/warehouse-base'
 
-import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet as WorksheetEntity, WorksheetDetail as WorksheetDetailEntity } from '../../../entities'
 
 export const findReleaseOrdersByTaskNoResolver = {
-  async findReleaseOrdersByTaskNo(_: any, { taskNo }, context: any) {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+  async findReleaseOrdersByTaskNo(_: any, { taskNo }, context: ResolverContext) {
+    const { domain, tx } = context.state
     let task = await tx.getRepository(WorksheetEntity).findOne({
-      where: { taskNo, status: WORKSHEET_STATUS.EXECUTING, type: WORKSHEET_TYPE.SORTING }
+      where: { taskNo }
     })
 
-    // Find Task based on Bin
-    if (!task) {
-      const binLocation: Location = await tx.getRepository(Location).findOne({
-        where: { domain, name: taskNo }
-      })
-
-      const qb: SelectQueryBuilder<OrderInventoryEntity> = tx.getRepository(OrderInventoryEntity).createQueryBuilder('orderInventory')
-
-      qb.innerJoinAndSelect('orderInventory.releaseGood', 'releaseGood')
-        .innerJoinAndSelect('worksheets', 'ws', `orderInventory.ref_worksheet_id = ws.id AND ws.type = 'BATCH_PICKING'`)
-        .innerJoinAndSelect('worksheets', 'ws2', `ws2.task_no = ws.task_no AND ws2.type = 'SORTING'`)
-        .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.SORTING]
-        })
-        .andWhere('orderInventory.bin_location_id = :locationId', { locationId: binLocation.id })
-        .andWhere('releaseGood.status = :status', { status: ORDER_STATUS.SORTING })
-
-      const orderInventoryByBin = await qb.getRawOne()
-      if (orderInventoryByBin?.releaseGood_id) {
-        taskNo = orderInventoryByBin.ws_task_no
-        task = await tx.getRepository(WorksheetEntity).findOne({
-          where: { taskNo, status: WORKSHEET_STATUS.EXECUTING, type: WORKSHEET_TYPE.SORTING }
-        })
-      } else {
-        throw new Error(`Bin do not have any batch picking order.`)
-      }
-    }
-
     if (!task) throw new Error('Unable to find task no.')
 
     const qb: SelectQueryBuilder<WorksheetEntity> = tx
@@ -63,9 +26,6 @@ export const findReleaseOrdersByTaskNoResolver = {
       .innerJoin(ReleaseGoodEntity, 'rg', 'rg.id = oi.release_good_id')
       .where('domain.id = :domainId', { domainId: domain.id })
       .andWhere('ws.taskNo = :taskNo', { taskNo: taskNo })
-      .andWhere('ws.type = :worksheetType', { worksheetType: WORKSHEET_TYPE.SORTING })
-      .andWhere('ws.status = :worksheetStatus', { worksheetStatus: WORKSHEET_STATUS.EXECUTING })
-      .andWhere('rg.status = :roStatus', { roStatus: ORDER_STATUS.SORTING })
       .groupBy('rg.id')
       .addGroupBy('rg.name')
       .addGroupBy('rg.status')

package/server/graphql/resolvers/worksheet/find-release-orders-by-worksheet-no.ts

@@ -1,10 +1,10 @@
-import { Domain } from '@things-factory/shell'
-import { EntityManager, SelectQueryBuilder } from 'typeorm'
-import { Worksheet as WorksheetEntity, ReleaseGood as ReleaseGoodEntity } from '@things-factory/sales-base'
+import { SelectQueryBuilder } from 'typeorm'
+
+import { ReleaseGood as ReleaseGoodEntity, Worksheet as WorksheetEntity } from '@things-factory/sales-base'
 
 export const findReleaseOrderByWorksheetNoResolver = {
-  async findReleaseOrderByWorksheetNo(_: any, { batchWorksheetNo }, context: any) {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+  async findReleaseOrderByWorksheetNo(_: any, { batchWorksheetNo }, context: ResolverContext) {
+    const { domain, tx } = context.state
     if (!batchWorksheetNo) throw new Error('Unable to find worksheet no.')
 
     const qb: SelectQueryBuilder<WorksheetEntity> = tx

package/server/graphql/resolvers/worksheet/find-sorting-release-orders-by-task-no.ts

@@ -0,0 +1,80 @@
+import { SelectQueryBuilder } from 'typeorm'
+
+import {
+  ORDER_INVENTORY_STATUS,
+  ORDER_STATUS,
+  OrderInventory as OrderInventoryEntity,
+  ReleaseGood as ReleaseGoodEntity
+} from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+import { Location } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet as WorksheetEntity, WorksheetDetail as WorksheetDetailEntity } from '../../../entities'
+
+export const findSortingReleaseOrdersByTaskNoResolver = {
+  async findSortingReleaseOrdersByTaskNo(_: any, { taskNo }, context: ResolverContext) {
+    const { domain, tx } = context.state
+    let task = await tx.getRepository(WorksheetEntity).findOne({
+      where: { taskNo, status: WORKSHEET_STATUS.EXECUTING, type: WORKSHEET_TYPE.SORTING }
+    })
+
+    // Find Task based on Bin
+    if (!task) {
+      const binLocation: Location = await tx.getRepository(Location).findOne({
+        where: { domain: { id: domain.id }, name: taskNo }
+      })
+
+      const qb: SelectQueryBuilder<OrderInventoryEntity> = tx
+        .getRepository(OrderInventoryEntity)
+        .createQueryBuilder('orderInventory')
+
+      qb.innerJoinAndSelect('orderInventory.releaseGood', 'releaseGood')
+        .innerJoinAndSelect('worksheets', 'ws', `orderInventory.ref_worksheet_id = ws.id AND ws.type = 'BATCH_PICKING'`)
+        .innerJoinAndSelect('worksheets', 'ws2', `ws2.task_no = ws.task_no AND ws2.type = 'SORTING'`)
+        .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.SORTING]
+        })
+        .andWhere('orderInventory.bin_location_id = :locationId', { locationId: binLocation.id })
+        .andWhere('releaseGood.status = :status', { status: ORDER_STATUS.SORTING })
+
+      const orderInventoryByBin = await qb.getRawOne()
+      if (orderInventoryByBin?.releaseGood_id) {
+        taskNo = orderInventoryByBin.ws_task_no
+        task = await tx.getRepository(WorksheetEntity).findOne({
+          where: { taskNo, status: WORKSHEET_STATUS.EXECUTING, type: WORKSHEET_TYPE.SORTING }
+        })
+      } else {
+        throw new Error(`Bin do not have any batch picking order.`)
+      }
+    }
+
+    if (!task) throw new Error('Unable to find task no.')
+
+    const qb: SelectQueryBuilder<WorksheetEntity> = tx
+      .getRepository(WorksheetEntity)
+      .createQueryBuilder('ws')
+      .select('rg.id as id')
+      .addSelect('rg.name as name')
+      .addSelect('rg.status as status')
+      .innerJoin(Domain, 'domain', 'ws.domain_id = domain.id')
+      .innerJoin(WorksheetDetailEntity, 'wsd', 'ws.id = wsd.worksheet_id')
+      .innerJoin(OrderInventoryEntity, 'oi', 'oi.id = wsd.target_inventory_id')
+      .innerJoin(ReleaseGoodEntity, 'rg', 'rg.id = oi.release_good_id')
+      .where('domain.id = :domainId', { domainId: domain.id })
+      .andWhere('ws.taskNo = :taskNo', { taskNo: taskNo })
+      .andWhere('ws.type = :worksheetType', { worksheetType: WORKSHEET_TYPE.SORTING })
+      .andWhere('ws.status = :worksheetStatus', { worksheetStatus: WORKSHEET_STATUS.EXECUTING })
+      .andWhere('rg.status = :roStatus', { roStatus: ORDER_STATUS.SORTING })
+      .groupBy('rg.id')
+      .addGroupBy('rg.name')
+      .addGroupBy('rg.status')
+      .orderBy('rg.createdAt', 'ASC')
+
+    const releaseGoods: ReleaseGoodEntity[] = await qb.getRawMany()
+    return { releaseGoods, taskNo }
+  }
+}

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-arrival-notice-worksheet.ts

@@ -1,14 +1,54 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { ArrivalNotice } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { PickingWorksheetController, UnloadingWorksheetController } from '../../../../controllers'
 import { Worksheet } from '../../../../entities'
 
 export const generateArrivalNoticeWorksheetResolver = {
-  async generateArrivalNoticeWorksheet(_: any, { arrivalNoticeNo, bufferLocation }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    return await generateArrivalNoticeWorksheet(tx, domain, user, arrivalNoticeNo, bufferLocation)
+  async generateArrivalNoticeWorksheet(_: any, { arrivalNoticeNos, bufferLocation }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    /* REVIEW ME --
+      return await generateArrivalNoticeWorksheet(tx, domain, user, arrivalNoticeNo, bufferLocation)
+    */
+
+    await Promise.all(
+      arrivalNoticeNos.map(async arrivalNoticeNo => {
+        try {
+          let unloadingWorksheet = await generateUnloadingWorksheet(tx, domain, user, arrivalNoticeNo, bufferLocation)
+
+          if (!unloadingWorksheet.arrivalNotice?.id) {
+            unloadingWorksheet = await tx.getRepository(Worksheet).findOne({
+              where: { id: unloadingWorksheet.id },
+              relations: ['arrivalNotice']
+            })
+          }
+
+          let arrivalNotice: ArrivalNotice = unloadingWorksheet.arrivalNotice
+          const crossDocking: boolean = unloadingWorksheet.arrivalNotice.crossDocking
+
+          if (crossDocking) {
+            arrivalNotice = await tx
+              .getRepository(ArrivalNotice)
+              .findOne({ where: { domain: domain, name: arrivalNoticeNo }, relations: ['releaseGood'] })
+
+            const releaseGoodNo: string = arrivalNotice.releaseGood.name
+            const pickingWSCtrl: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+            await pickingWSCtrl.generatePickingWorksheet(releaseGoodNo)
+          }
+
+          const vasWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+            where: { domain: domain, arrivalNotice }
+          })
+
+          return { unloadingWorksheet, vasWorksheet }
+        } catch (e) {
+          throw new Error(e)
+        }
+      })
+    )
   }
 }
 
@@ -23,7 +63,7 @@ export async function generateArrivalNoticeWorksheet(
 
   if (!unloadingWorksheet.arrivalNotice?.id) {
     unloadingWorksheet = await tx.getRepository(Worksheet).findOne({
-      where: unloadingWorksheet,
+      where: { id: unloadingWorksheet.id },
       relations: ['arrivalNotice']
     })
   }

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

@@ -1,14 +1,16 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
-import { OrderInventory } from '@things-factory/sales-base'
+import { GenerateBatchPickInfo } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { PickingWorksheetController } from '../../../../controllers/'
-import { Worksheet, WorksheetDetail } from '../../../../entities'
+import { Worksheet } from '../../../../entities'
 
 export const generateBatchPickingWorksheetResolver = {
-  async generateBatchPickingWorksheet(_: any, { releaseGoodNos, partnerBizplaceId }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    return await generateBatchPickingWorksheet(tx, domain, user, releaseGoodNos, partnerBizplaceId)
+  async generateBatchPickingWorksheet(_: any, { releaseGoodWithBiz }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    return await generateBatchPickingWorksheet(tx, domain, user, releaseGoodWithBiz)
   }
 }
 
@@ -16,9 +18,8 @@ export async function generateBatchPickingWorksheet(
   tx: EntityManager,
   domain: Domain,
   user: User,
-  releaseGoodNos: [string],
-  partnerBizplaceId: string
-): Promise<Worksheet> {
+  releaseGoodWithBiz: [[GenerateBatchPickInfo]]
+): Promise<Worksheet[]> {
   const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-  return await worksheetController.generateBatchPickingWorksheet(releaseGoodNos, partnerBizplaceId)
+  return await worksheetController.generateBatchPickingWorksheet(releaseGoodWithBiz)
 }

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-cycle-count-worksheet.ts

@@ -13,7 +13,7 @@ export const generateCycleCountWorksheetResolver = {
     { executionDate, customerId, orderInventoryIds, orderInventories, limit },
     context: any
   ) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
     const cycleCountWorksheet: Worksheet = await generateCycleCountWorksheet(
       tx,

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

@@ -1,24 +1,17 @@
-import { EntityManager, getManager } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { OrderInventory } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-
-import { PickingWorksheetController } from '../../../../controllers/'
-import { Worksheet, WorksheetDetail } from '../../../../entities'
+import { getManager } from 'typeorm'
 
 import { generatePickingWorksheet } from './generate-release-good-worksheet'
 
 export const generateMultipleReleaseGoodWorksheetResolver = {
-  async generateMultipleReleaseGoodWorksheet(_: any, { releaseGoodNos }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async generateMultipleReleaseGoodWorksheet(_: any, { releaseGoods }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
 
-    for (let idx = 0; idx < releaseGoodNos.length; idx++) {
+    for (let idx = 0; idx < releaseGoods.length; idx++) {
       await getManager().transaction(async txMgr => {
-        await generatePickingWorksheet(txMgr, domain, user, releaseGoodNos[idx])
-      });
+        await generatePickingWorksheet(txMgr, domain, user, releaseGoods[idx].name, releaseGoods[idx].status)
+      })
     }
 
     return true
   }
-}
+}

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-partial-putaway-return-worksheet.ts

@@ -1,15 +1,21 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { ReturnOrder } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
-import { EntityManager } from 'typeorm'
+import { Inventory } from '@things-factory/warehouse-base'
+
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
 import { PutawayReturningWorksheetController } from '../../../../controllers'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
 
 export const generatePartialPutawayReturnWorksheetResolver = {
-  async generatePartialPutawayReturnWorksheet(_: any, { returnOrderNo, inventories }, context: any): Promise<void> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async generatePartialPutawayReturnWorksheet(
+    _: any,
+    { returnOrderNo, inventories },
+    context: ResolverContext
+  ): Promise<void> {
+    const { tx, domain, user } = context.state
     let worksheet: Worksheet = await generatePartialPutawayReturnWorksheet(tx, domain, user, returnOrderNo, inventories)
 
     if (!worksheet?.returnOrder?.id) {

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-partial-putaway-worksheet.ts

@@ -1,15 +1,21 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { ArrivalNotice } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
-import { EntityManager } from 'typeorm'
+import { Inventory } from '@things-factory/warehouse-base'
+
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
 import { PutawayWorksheetController } from '../../../../controllers'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
 
 export const generatePartialPutawayWorksheetResolver = {
-  async generatePartialPutawayWorksheet(_: any, { arrivalNoticeNo, inventories }, context: any): Promise<void> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async generatePartialPutawayWorksheet(
+    _: any,
+    { arrivalNoticeNo, inventories },
+    context: ResolverContext
+  ): Promise<void> {
+    const { tx, domain, user } = context.state
     let worksheet: Worksheet = await generatePartialPutawayWorksheet(tx, domain, user, arrivalNoticeNo, inventories)
 
     if (!worksheet?.arrivalNotice?.id) {

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

@@ -1,15 +1,17 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { ArrivalNotice } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
-import { EntityManager } from 'typeorm'
+
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
 import { PutawayWorksheetController } from '../../../../controllers'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
 
 export const generatePutawayWorksheetResolver = {
-  async generatePutawayWorksheet(_: any, { arrivalNoticeNo, inventories }, context: any): Promise<void> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async generatePutawayWorksheet(_: any, { arrivalNoticeNo, inventories }, context: ResolverContext): Promise<void> {
+    const { tx, domain, user } = context.state
     let worksheet: Worksheet = await generatePutawayWorksheet(tx, domain, user, arrivalNoticeNo, inventories)
 
     if (!worksheet.arrivalNotice?.id) {