@things-factory/worksheet-base 8.0.0-beta.8 → 8.0.0

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

@@ -0,0 +1,211 @@
+import { EntityManager, In } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { InventoryCheck, ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory, INVENTORY_STATUS, INVENTORY_TRANSACTION_TYPE, Location } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
+import { SellercraftController } from '../../../controllers'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+import { generateInventoryHistory, switchLocationStatus } from '../../../utils'
+
+export const cycleCountAdjustmentResolver = {
+  async cycleCountAdjustment(_: any, { cycleCountNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    await cycleCountAdjustment(tx, domain, user, cycleCountNo)
+  }
+}
+
+export async function cycleCountAdjustment(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  cycleCountNo: string
+): Promise<void> {
+  // get cycle count no
+  const cycleCount: InventoryCheck = await tx.getRepository(InventoryCheck).findOne({
+    where: {
+      domain: { id: domain.id },
+      name: cycleCountNo,
+      status: ORDER_STATUS.PENDING_REVIEW
+    }
+  })
+
+  let worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+    where: {
+      domain: { id: domain.id },
+      type: In([WORKSHEET_TYPE.CYCLE_COUNT, WORKSHEET_TYPE.CYCLE_COUNT_RECHECK]),
+      inventoryCheck: { id: cycleCount.id }
+    }
+  })
+
+  // get cycle count wsd that is not tally
+  const worksheetDetails: WorksheetDetail[] = await tx.getRepository(WorksheetDetail).find({
+    where: {
+      domain: { id: domain.id },
+      worksheet: { id: worksheet.id },
+      type: In([WORKSHEET_TYPE.CYCLE_COUNT, WORKSHEET_TYPE.CYCLE_COUNT_RECHECK]),
+      status: WORKSHEET_STATUS.NOT_TALLY
+    },
+    relations: [
+      'targetInventory',
+      'targetInventory.inventory',
+      'targetInventory.inventory.product',
+      'targetInventory.inventory.product.productDetails',
+      'targetInventory.inventory.product.productDetails.childProductDetail',
+      'targetInventory.inventory.bizplace',
+      'targetInventory.inventory.domain',
+      'targetInventory.inventory.bizplace.domain',
+      'targetInventory.inventory.warehouse',
+      'targetInventory.inventory.location',
+      'targetInventory.inspectedLocation',
+      'targetInventory.inspectedLocation.warehouse'
+    ]
+  })
+
+  for (let worksheetDetail of worksheetDetails) {
+    const targetInventory: OrderInventory = worksheetDetail.targetInventory
+    let inventory: Inventory = targetInventory.inventory
+
+    let transactQty: number = targetInventory.inspectedQty - inventory.qty
+    let transactUomValue: number = targetInventory.inspectedUomValue - inventory.uomValue
+
+    const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({
+      where: { domain: { id: inventory.bizplace.domain.id }, status: SellercraftStatus.ACTIVE },
+      relations: ['domain']
+    })
+
+    if (targetInventory.status === ORDER_INVENTORY_STATUS.MISSING) {
+      // create STORED, CC_ADJUSTMENT history
+      await generateInventoryHistory(
+        inventory,
+        cycleCount,
+        INVENTORY_TRANSACTION_TYPE.CC_ADJUSTMENT,
+        -inventory.qty,
+        -inventory.uomValue,
+        user,
+        tx
+      )
+
+      inventory.qty = 0
+      inventory.uomValue = 0
+      inventory.lockedQty = 0
+      //@ts-ignore
+      inventory.lockeduomValue = 0
+      inventory.updater = user
+      inventory.status = INVENTORY_STATUS.TERMINATED
+      inventory = await tx.getRepository(Inventory).save(inventory)
+
+      // create TERMINATED, TERMINATED history
+      await generateInventoryHistory(inventory, cycleCount, INVENTORY_TRANSACTION_TYPE.TERMINATED, 0, 0, user, tx)
+
+      if (sellercraft) {
+        const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+        await sellercraftCtrl.updateSellercraftStock(sellercraft, inventory)
+      }
+    } else if (targetInventory.inspectedQty == 0) {
+      // create STORED, CC_ADJUSTMENT history
+      await generateInventoryHistory(
+        inventory,
+        cycleCount,
+        INVENTORY_TRANSACTION_TYPE.CC_ADJUSTMENT,
+        transactQty,
+        transactUomValue,
+        user,
+        tx
+      )
+
+      // change inventory qty to 0 and terminate it
+      inventory.batchId = targetInventory.inspectedBatchNo
+      inventory.qty = targetInventory.inspectedQty
+      inventory.lockedQty = 0
+      inventory.uomValue = targetInventory.inspectedUomValue
+      inventory.lockedUomValue = 0
+      inventory.location = targetInventory.inspectedLocation
+      inventory.warehouse = targetInventory.inspectedLocation.warehouse
+      inventory.status = INVENTORY_STATUS.TERMINATED
+      inventory.updater = user
+      inventory = await tx.getRepository(Inventory).save(inventory)
+
+      // create TERMINATED, TERMINATED history
+      await generateInventoryHistory(inventory, cycleCount, INVENTORY_TRANSACTION_TYPE.TERMINATED, 0, 0, user, tx)
+
+      if (sellercraft) {
+        const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+        await sellercraftCtrl.updateSellercraftStock(sellercraft, inventory)
+      }
+    } else {
+      const prevLocationId: string = inventory.location.id
+
+      if (targetInventory.inspectedBatchNo !== inventory.batchId) {
+        // generate TERMINATED, ADJUSTMENT history
+        const { qty, uomValue }: { qty: number; uomValue: number } = inventory
+        inventory.status = INVENTORY_STATUS.TERMINATED
+        inventory.qty = 0
+        inventory.uomValue = 0
+
+        await generateInventoryHistory(
+          inventory,
+          cycleCount,
+          INVENTORY_TRANSACTION_TYPE.CC_ADJUSTMENT,
+          -qty,
+          -uomValue,
+          user,
+          tx
+        )
+
+        transactQty = targetInventory.inspectedQty
+        transactUomValue = targetInventory.inspectedUomValue
+      }
+
+      inventory.batchId = targetInventory.inspectedBatchNo
+      inventory.qty = targetInventory.inspectedQty
+      inventory.lockedQty = 0
+      inventory.uomValue = targetInventory.inspectedUomValue
+      inventory.lockedUomValue = 0
+      inventory.location = targetInventory.inspectedLocation
+      inventory.warehouse = targetInventory.inspectedLocation.warehouse
+      inventory.status = INVENTORY_STATUS.STORED
+      inventory.updater = user
+      inventory = await tx.getRepository(Inventory).save(inventory)
+
+      if (prevLocationId !== targetInventory.inspectedLocation.id) {
+        const prevLocation: Location = await tx.getRepository(Location).findOneBy({ id: prevLocationId })
+        await switchLocationStatus(domain, prevLocation, user, tx)
+      }
+
+      await generateInventoryHistory(
+        inventory,
+        cycleCount,
+        INVENTORY_TRANSACTION_TYPE.CC_ADJUSTMENT,
+        transactQty,
+        transactUomValue,
+        user,
+        tx
+      )
+    }
+
+    if (sellercraft) {
+      const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+      await sellercraftCtrl.updateSellercraftStock(sellercraft, inventory)
+    }
+
+    targetInventory.status = ORDER_INVENTORY_STATUS.TERMINATED
+    targetInventory.updater = user
+    await tx.getRepository(OrderInventory).save(targetInventory)
+
+    worksheetDetail.status = WORKSHEET_STATUS.ADJUSTED
+    worksheetDetail.updater = user
+    await tx.getRepository(WorksheetDetail).save(worksheetDetail)
+  }
+
+  worksheet.status = WORKSHEET_STATUS.DONE
+  await tx.getRepository(Worksheet).save(worksheet)
+
+  // change cycle count status to DONE
+  cycleCount.status = ORDER_STATUS.DONE
+  cycleCount.updater = user
+  await tx.getRepository(InventoryCheck).save(cycleCount)
+}

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

@@ -0,0 +1,79 @@
+import { createQueryBuilder, In, SelectQueryBuilder } from 'typeorm'
+
+import { InventoryCheck, ORDER_STATUS, OrderInventory } from '@things-factory/sales-base'
+import { getRepository } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+
+export const cycleCountWorksheetResolver = {
+  async cycleCountWorksheet(_: any, { inventoryCheckNo, locationSortingRules }, context: ResolverContext) {
+    const { domain } = context.state
+    const cycleCount: InventoryCheck = await getRepository(InventoryCheck).findOne({
+      where: { domain: { id: domain.id }, name: inventoryCheckNo, status: ORDER_STATUS.INSPECTING }
+    })
+
+    if (!cycleCount) throw new Error('Failed to find cycle count worksheet')
+
+    const worksheet: Worksheet = await getRepository(Worksheet).findOne({
+      where: {
+        domain: { id: domain.id },
+        inventoryCheck: { id: cycleCount.id },
+        type: In([WORKSHEET_TYPE.CYCLE_COUNT, WORKSHEET_TYPE.CYCLE_COUNT_RECHECK]),
+        status: WORKSHEET_STATUS.EXECUTING
+      },
+      relations: ['bizplace', 'bizplace.domain']
+    })
+
+    const qb: SelectQueryBuilder<WorksheetDetail> = createQueryBuilder(WorksheetDetail, 'WSD')
+    qb.leftJoinAndSelect('WSD.targetInventory', 'T_INV')
+      .leftJoinAndSelect('T_INV.inventory', 'INV')
+      .leftJoinAndSelect('T_INV.inspectedLocation', 'INS_LOC')
+      .leftJoinAndSelect('INV.location', 'LOC')
+      .leftJoinAndSelect('INV.product', 'PROD')
+      .leftJoinAndSelect('LOC.warehouse', 'WH')
+
+    if (locationSortingRules?.length > 0) {
+      locationSortingRules.forEach((rule: { name: string; desc: boolean }) => {
+        qb.addOrderBy(`LOC.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
+      })
+    }
+
+    const worksheetDetails: WorksheetDetail[] = await qb
+      .where('"WSD"."worksheet_id" = :worksheetId', { worksheetId: worksheet.id })
+      .andWhere('"WSD"."status" != :status', { status: WORKSHEET_STATUS.REPLACED })
+      .getMany()
+
+    return {
+      worksheetInfo: {
+        startedAt: worksheet.startedAt,
+        bizplace: worksheet.bizplace,
+        partnerDomainId: worksheet.bizplace?.domain.id
+      },
+      worksheetDetailInfos: worksheetDetails.map(async (cycleCountWSD: WorksheetDetail) => {
+        const targetInventory: OrderInventory = cycleCountWSD.targetInventory
+        const inventory: Inventory = targetInventory.inventory
+
+        return {
+          name: cycleCountWSD.name,
+          palletId: inventory?.palletId,
+          batchId: inventory?.batchId,
+          product: inventory?.product,
+          qty: inventory?.qty,
+          uomValue: inventory?.uomValue,
+          uom: inventory?.uom,
+          inspectedQty: targetInventory.inspectedQty,
+          inspectedUomValue: targetInventory.inspectedUomValue,
+          inspectedLocation: targetInventory.inspectedLocation,
+          inspectedBatchNo: targetInventory.inspectedBatchNo,
+          status: cycleCountWSD.status,
+          targetName: targetInventory.name,
+          packingType: inventory?.packingType,
+          location: inventory?.location,
+          relatedOrderInv: targetInventory
+        }
+      })
+    }
+  }
+}

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

@@ -0,0 +1,21 @@
+import { EntityManager, In } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+
+import { Worksheet } from '../../../entities'
+
+export const deleteWorksheet = {
+  async deleteWorksheet(_: any, { id }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+
+    await tx.getRepository(Worksheet).delete({
+      domain: { id: domain.id },
+      bizplace: In(await getPermittedBizplaceIds(domain, user)),
+      id
+    })
+
+    return true
+  }
+}

package/server/graphql/resolvers/worksheet/delivery-order-by-worksheet.ts

@@ -0,0 +1,104 @@
+import { Bizplace, ContactPoint } from '@things-factory/biz-base'
+import { logger } from '@things-factory/env'
+import { DeliveryOrder, OrderInventory } from '@things-factory/sales-base'
+import { TransportDriver } from '@things-factory/transport-base'
+
+export const deliveryOrderByWorksheetResolver = {
+  async deliveryOrderByWorksheet(_: any, { name }, context: ResolverContext) {
+    const { domain, tx } = context.state
+    try {
+      const foundDO: DeliveryOrder = await tx.getRepository(DeliveryOrder).findOne({
+        where: {
+          domain: { id: domain.id },
+          name
+        },
+        relations: ['domain', 'bizplace', 'transportDriver', 'transportVehicle', 'releaseGood', 'creator', 'updater']
+      })
+
+      if (!foundDO) throw new Error('Delivery order not found!')
+
+      const foundOI: any = await tx
+        .getRepository(OrderInventory)
+        .createQueryBuilder('oi')
+        .select('p.name', 'name')
+        .addSelect('p.sku', 'sku')
+        .addSelect('p.type', 'type')
+        .addSelect('oi.batch_id', 'batchNo')
+        .addSelect('oi.uom', 'uom')
+        .addSelect('sum(oi.release_qty)', 'loadedQty')
+        .addSelect('sum(oi.release_uom_value)', 'uomValue')
+        .innerJoin('products', 'p', 'p.id = oi.product_id')
+        .groupBy('p.name')
+        .addGroupBy('p.sku')
+        .addGroupBy('p.type')
+        .addGroupBy('oi.batch_id')
+        .addGroupBy('oi.uom')
+        .where('oi.domain_id = :domainId', { domainId: domain.id })
+        .andWhere('oi.delivery_order_id = :deliveryOrderId', { deliveryOrderId: foundDO.id })
+        .orderBy('p.sku')
+        .addOrderBy('oi.batch_id')
+        .getRawMany()
+
+      const partnerBiz: Bizplace = await tx.getRepository(Bizplace).findOne({
+        where: { id: foundDO.bizplace.id }
+      })
+
+      const partnerContactPoint: ContactPoint[] = await tx.getRepository(ContactPoint).find({
+        where: { domain: { id: domain.id }, bizplace: { id: partnerBiz.id } }
+      })
+
+      //@ts-ignore
+      let foundTransportDriver: TransportDriver = { name: '' }
+      if (foundDO.transportDriver) {
+        foundTransportDriver = await tx.getRepository(TransportDriver).findOne({
+          where: { domain: { id: domain.id }, id: foundDO.transportDriver.id }
+        })
+
+        if (!foundTransportDriver) throw new Error('transport driver is not found')
+      }
+
+      return {
+        deliveryOrderInfo: {
+          name: foundDO.name,
+          ownCollection: foundDO.ownCollection,
+          doStatus: foundDO.status,
+          truckNo: foundDO.truckNo,
+          bizplace: foundDO.bizplace,
+          deliverTo: foundDO.contactPointRefId || '',
+          deliveryDate: foundDO.deliveryDate || '',
+          driverName: foundTransportDriver.name,
+          //@ts-ignore
+          otherDestination: foundDO.otherDestination || false,
+          //@ts-ignore
+          contactName: foundDO.contactName || '',
+          otherDriver: foundDO.otherDriver || '',
+          looseItem: foundDO.looseItem || false,
+          remark: foundDO.remark || '',
+          reusablePallet: foundDO.reusablePallet || '',
+          createdDate: foundDO.createdAt.toISOString().split('T')[0],
+          isManualDo: foundDO.releaseGood ? false : true,
+          attentionTo: foundDO.attentionTo || '',
+          releaseGood: {
+            ...foundDO.releaseGood,
+            attentionTo: foundDO.attentionTo || foundDO.releaseGood?.attentionTo,
+            bizplace: partnerBiz
+          },
+          productList: foundOI
+        },
+        contactPointInfo: partnerContactPoint.map(async (cp: ContactPoint) => {
+          return {
+            id: cp.id,
+            address: cp.address || '',
+            email: cp.email || '',
+            fax: cp.fax || '',
+            phone: cp.phone || '',
+            contactName: cp.name || ''
+          }
+        })
+      }
+    } catch (error) {
+      logger.error(`delivery-order-by-worksheet:(data:${JSON.stringify({ name, domain })}) ${error} `)
+      throw new Error('Something went wrong. Please contact support.')
+    }
+  }
+}

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

@@ -0,0 +1,191 @@
+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: { id: foundDO.id } },
+      relations: ['inventory']
+    })
+    const orderInvIds: string[] = targetInventories.map((oi: any) => oi.id)
+
+    const foundWSD: WorksheetDetail[] = await getRepository(WorksheetDetail).find({
+      where: {
+        domain: { id: domain.id },
+        targetInventory: { id: 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,
+          //@ts-ignore
+          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')
+    }
+  }
+}