@things-factory/worksheet-base 8.0.0-beta.9 → 8.0.1

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

@@ -0,0 +1,25 @@
+import { PickingWorksheetController } from '../../../../controllers'
+
+export const scanProductPickingResolver = {
+  async scanProductPicking(
+    _: any,
+    { worksheetDetailName, worksheetType, productBarcode, cartonId, binLocation, serialNumber, toteNo, pickingQty },
+    context: ResolverContext
+  ) {
+    const { tx, domain, user } = context.state
+
+    const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+    let ws = await worksheetController.scanProductPicking(
+      worksheetDetailName,
+      worksheetType,
+      productBarcode,
+      cartonId,
+      binLocation,
+      serialNumber,
+      toteNo,
+      pickingQty
+    )
+
+    // return await pickingWorksheet(domain, releaseGoodNo, locationSortingRule, tx)
+  }
+}

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

@@ -0,0 +1,25 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { PickingWorksheetController } from '../../../../controllers'
+
+export const sealToteResolver = {
+  async sealTote(_: any, { sealNo, toteNo, orderNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    await sealTote(tx, domain, user, sealNo, toteNo, orderNo)
+  }
+}
+
+async function sealTote(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  sealNo: string,
+  toteNo: string,
+  orderNo: string
+): Promise<void> {
+  const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+  await worksheetController.sealTote(sealNo, toteNo, orderNo)
+}

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

@@ -0,0 +1,31 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { PickingWorksheetController } from '../../../../controllers'
+
+export const undoPickingAssigmentResolver = {
+  async undoPickingAssigment(
+    _: any,
+    { worksheetNo, batchId, productId, packingType, packingSize },
+    context: ResolverContext
+  ): Promise<void> {
+    const { tx, domain, user } = context.state
+    await undoPickingAssigment(tx, domain, user, worksheetNo, batchId, productId, packingType, packingSize)
+  }
+}
+
+export async function undoPickingAssigment(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetNo: string,
+  batchId: string,
+  productId: string,
+  packingType: string,
+  packingSize: number
+): Promise<void> {
+  const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+  await worksheetController.undoPickingAssigment(worksheetNo, batchId, productId, packingType, packingSize)
+}

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

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

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

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

package/server/graphql/resolvers/worksheet/proceed-extra-products.ts

@@ -0,0 +1,242 @@
+import { Role } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { ArrivalNotice, ORDER_PRODUCT_STATUS, ORDER_STATUS, OrderProduct } from '@things-factory/sales-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+import { WorksheetNoGenerator } from '../../../utils'
+
+const debug = require('debug')('things-factory:operato-wms:proceedExtraProducts')
+
+export const proceedExtraProductsResolver = {
+  async proceedExtraProducts(
+    _: any,
+    { ganNo, bizplaceId, approvedProducts, rejectedProducts },
+    context: any
+  ): Promise<void> {
+    const { tx, domain, user } = context.state
+
+    const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
+      where: {
+        id: bizplaceId
+      }
+    })
+
+    let arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
+      where: {
+        domain: { id: domain.id },
+        bizplace: { id: customerBizplace.id },
+        name: ganNo,
+        status: ORDER_STATUS.PENDING_APPROVAL
+      },
+      relations: ['orderProducts']
+    })
+
+    if (!arrivalNotice) throw new Error(`Unable to find ${arrivalNotice.name} under PENDING APPROVAL status`)
+
+    // Create worksheet details with approved order products
+    const worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+      where: {
+        domain: { id: domain.id },
+        arrivalNotice: { id: arrivalNotice.id },
+        type: WORKSHEET_TYPE.UNLOADING
+      }
+    })
+
+    arrivalNotice.status =
+      worksheet.status === WORKSHEET_STATUS.DEACTIVATED ? ORDER_STATUS.READY_TO_UNLOAD : ORDER_STATUS.PROCESSING
+    arrivalNotice.updater = user
+    await tx.getRepository(ArrivalNotice).save(arrivalNotice)
+
+    const targetProdCnt: number = arrivalNotice.orderProducts.filter(
+      (op: OrderProduct) => op.status === ORDER_PRODUCT_STATUS.ADDED || op.status === ORDER_PRODUCT_STATUS.EDITED
+    ).length
+
+    const storedOrderProducts: OrderProduct[] = arrivalNotice.orderProducts
+
+    if (approvedProducts.length + rejectedProducts.length != targetProdCnt)
+      throw new Error(`Invalid numbers of extra products`)
+
+    if (approvedProducts?.length) {
+      let updatedOrderProducts: OrderProduct[] = []
+      const editedApprovedProducts = approvedProducts.filter(
+        (approvedProd: OrderProduct) => approvedProd.status === ORDER_PRODUCT_STATUS.EDITED
+      )
+      const addedApprovedProducts = approvedProducts.filter(
+        (approvedProd: OrderProduct) => approvedProd.status === ORDER_PRODUCT_STATUS.ADDED
+      )
+
+      if (editedApprovedProducts?.length > 0) {
+        editedApprovedProducts.map((editedApprovedProd: OrderProduct) => {
+          const selectedOrderProduct: OrderProduct = storedOrderProducts.find(
+            (op: OrderProduct) => op.id === editedApprovedProd.id
+          )
+
+          updatedOrderProducts.push({
+            ...selectedOrderProduct,
+            batchId: selectedOrderProduct?.adjustedBatchId
+              ? selectedOrderProduct.adjustedBatchId
+              : selectedOrderProduct.batchId,
+            batchIdRef: selectedOrderProduct?.adjustedBatchIdRef
+              ? selectedOrderProduct.adjustedBatchIdRef
+              : selectedOrderProduct.batchIdRef,
+            packingType: selectedOrderProduct?.adjustedPackingType
+              ? selectedOrderProduct.adjustedPackingType
+              : selectedOrderProduct.packingType,
+            packQty: selectedOrderProduct?.adjustedPackQty
+              ? selectedOrderProduct.adjustedPackQty
+              : selectedOrderProduct.packQty,
+            uom: selectedOrderProduct?.adjustedUom ? selectedOrderProduct.adjustedUom : selectedOrderProduct.uom,
+            uomValue: selectedOrderProduct?.adjustedUomValue
+              ? selectedOrderProduct.adjustedUomValue
+              : selectedOrderProduct.uomValue,
+            totalUomValue: selectedOrderProduct?.adjustedTotalUomValue
+              ? selectedOrderProduct.adjustedTotalUomValue
+              : selectedOrderProduct.totalUomValue,
+            palletQty: selectedOrderProduct?.adjustedPalletQty
+              ? selectedOrderProduct.adjustedPalletQty
+              : selectedOrderProduct.palletQty,
+            unitPrice: selectedOrderProduct?.adjustedUnitPrice
+              ? selectedOrderProduct.adjustedUnitPrice
+              : selectedOrderProduct.unitPrice,
+            status:
+              worksheet.status === WORKSHEET_STATUS.DEACTIVATED
+                ? ORDER_PRODUCT_STATUS.READY_TO_UNLOAD
+                : ORDER_PRODUCT_STATUS.UNLOADING,
+            updater: user
+          })
+        })
+      }
+
+      if (addedApprovedProducts?.length > 0) {
+        addedApprovedProducts.map((addedApprovedProd: OrderProduct) => {
+          const selectedOrderProduct: OrderProduct = storedOrderProducts.find(
+            (op: OrderProduct) => op.id === addedApprovedProd.id
+          )
+          updatedOrderProducts.push({
+            ...selectedOrderProduct,
+            batchId: selectedOrderProduct.adjustedBatchId,
+            batchIdRef: selectedOrderProduct.adjustedBatchIdRef,
+            packingType: selectedOrderProduct.adjustedPackingType,
+            packQty: selectedOrderProduct.adjustedPackQty,
+            uom: selectedOrderProduct.adjustedUom,
+            uomValue: selectedOrderProduct.adjustedUomValue,
+            totalUomValue: selectedOrderProduct.adjustedTotalUomValue,
+            palletQty: selectedOrderProduct.adjustedPalletQty,
+            unitPrice: selectedOrderProduct.adjustedUnitPrice,
+            status:
+              worksheet.status === WORKSHEET_STATUS.DEACTIVATED
+                ? ORDER_PRODUCT_STATUS.READY_TO_UNLOAD
+                : ORDER_PRODUCT_STATUS.UNLOADING,
+            updater: user
+          })
+        })
+      }
+
+      debug('approved and updated order product', updatedOrderProducts)
+      await tx.getRepository(OrderProduct).save(updatedOrderProducts)
+
+      const unloadingWSDs: any[] = await Promise.all(
+        addedApprovedProducts.map(async (targetProduct: OrderProduct) => {
+          return {
+            domain,
+            bizplace: customerBizplace,
+            worksheet,
+            name: WorksheetNoGenerator.unloadingDetail(),
+            targetProduct: await tx.getRepository(OrderProduct).findOneBy({ id: targetProduct.id }),
+            type: WORKSHEET_TYPE.UNLOADING,
+            status:
+              worksheet.status === WORKSHEET_STATUS.EXECUTING
+                ? WORKSHEET_STATUS.EXECUTING
+                : WORKSHEET_STATUS.DEACTIVATED,
+            creator: user,
+            updater: user
+          }
+        })
+      )
+      debug('new unloading worksheet details', unloadingWSDs)
+      await tx.getRepository(WorksheetDetail).save(unloadingWSDs)
+    }
+
+    if (rejectedProducts?.length) {
+      const addedRejectedProducts: OrderProduct[] = rejectedProducts.filter(
+        (addedRejectedProduct: OrderProduct) => addedRejectedProduct.status === ORDER_PRODUCT_STATUS.ADDED
+      )
+      let editedRejectedProducts: OrderProduct[] = rejectedProducts.filter(
+        (editedRejectedProduct: OrderProduct) => editedRejectedProduct.status === ORDER_PRODUCT_STATUS.EDITED
+      )
+
+      if (editedRejectedProducts?.length > 0) {
+        editedRejectedProducts = editedRejectedProducts.map((editedRejectProduct: OrderProduct) => {
+          const selectedOrderProduct: OrderProduct = storedOrderProducts.find(
+            (op: OrderProduct) => op.id === editedRejectProduct.id
+          )
+
+          return {
+            ...selectedOrderProduct,
+            status:
+              worksheet.status === WORKSHEET_STATUS.DEACTIVATED
+                ? ORDER_PRODUCT_STATUS.READY_TO_UNLOAD
+                : ORDER_PRODUCT_STATUS.UNLOADING,
+            updater: user
+          }
+        })
+        debug('rejected existing order product changes', editedRejectedProducts)
+        await tx.getRepository(OrderProduct).save(editedRejectedProducts)
+      }
+
+      debug('rejected added order product', addedRejectedProducts)
+      if (addedRejectedProducts?.length > 0) {
+        let deleteOrderProducts: OrderProduct[] = []
+        addedRejectedProducts.map(rejectedOp => {
+          //@ts-ignore
+          const selectedOrderProduct: OrderProduct[] = storedOrderProducts.find(
+            (op: OrderProduct) => op.id === rejectedOp.id
+          )
+          //@ts-ignore
+          deleteOrderProducts.push(selectedOrderProduct)
+        })
+
+        await tx.getRepository(OrderProduct).delete(deleteOrderProducts)
+      }
+    }
+
+    // notification logics
+    // get Office Admin Users
+    const users: any[] = await tx
+      .getRepository('users_roles')
+      .createQueryBuilder('ur')
+      .select('ur.users_id', 'id')
+      .where(qb => {
+        const subQuery = qb
+          .subQuery()
+          .select('role.id')
+          .from(Role, 'role')
+          .where("role.name = 'Office Admin'")
+          .andWhere('role.domain_id = :domain', { domain: domain.id })
+          .getQuery()
+        return 'ur.roles_id IN ' + subQuery
+      })
+      .getRawMany()
+
+    // send notification to Office Admin Users
+    if (users?.length && context.header?.referer) {
+      const receivers: any[] = users.map(user => user.id)
+      const msg = {
+        title: `Product changes has been approved/rejected - (${arrivalNotice.name}, ${customerBizplace.name}) `,
+        body: `Approved products are ready for unloading`,
+        url: context.header.referer,
+        data: { url: context.header.referer }
+      }
+
+      /**
+       * @notes Temporary off sendNotification due to suspect of causing wms down
+       */
+
+      // await sendNotification({
+      //   receivers,
+      //   message: { ...msg }
+      // })
+    }
+  }
+}

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

@@ -0,0 +1,51 @@
+import { EntityManager, Equal, Not } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
+import { PutawayWorksheetController } from '../../../../controllers'
+import { Worksheet, WorksheetDetail } from '../../../../entities'
+
+export const activatePutawayResolver = {
+  async activatePutaway(_: any, { worksheetNo, putawayWorksheetDetails }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    const foundWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+      where: {
+        domain: { id: domain.id },
+        name: worksheetNo,
+        status: WORKSHEET_STATUS.DEACTIVATED,
+        type: WORKSHEET_TYPE.PUTAWAY
+      },
+      relations: ['bizplace', 'arrivalNotice', 'worksheetDetails', 'worksheetDetails.targetInventory']
+    })
+
+    if (!foundWorksheet) throw new Error(`Worksheet doesn't exists`)
+
+    const relatedWorksheetCnt: number = await tx.getRepository(Worksheet).count({
+      where: {
+        domain: { id: domain.id },
+        arrivalNotice: { id: foundWorksheet.arrivalNotice.id },
+        type: WORKSHEET_TYPE.VAS,
+        status: Not(Equal(WORKSHEET_STATUS.DONE))
+      }
+    })
+
+    if (relatedWorksheetCnt) {
+      throw new Error(`Related VAS order with GAN: ${foundWorksheet.arrivalNotice.name} is still under processing.`)
+    }
+
+    return await activatePutaway(tx, domain, user, worksheetNo, putawayWorksheetDetails)
+  }
+}
+
+export async function activatePutaway(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetNo: string,
+  putawayWorksheetDetails: Partial<WorksheetDetail>[]
+) {
+  const worksheetController: PutawayWorksheetController = new PutawayWorksheetController(tx, domain, user)
+  await worksheetController.activatePutaway(worksheetNo, putawayWorksheetDetails)
+}

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

@@ -0,0 +1,105 @@
+import { EntityManager } from 'typeorm'
+
+import { ApplicationType, User } from '@things-factory/auth-base'
+import { MarketplaceStore } from '@things-factory/integration-marketplace'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { ArrivalNotice } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import { PutawayWorksheetController } from '../../../../controllers'
+import { EcommerceController, SellercraftController } from '../../../../controllers/ecommerce'
+import { Worksheet } from '../../../../entities'
+
+export const completePutawayResolver = {
+  async completePutaway(_: any, { arrivalNoticeNo }, context: ResolverContext) {
+    const { tx, user, domain } = context.state
+    await completePutaway(tx, domain, user, arrivalNoticeNo)
+
+    const arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
+      where: { domain: { id: domain.id }, name: arrivalNoticeNo },
+      relations: [
+        'purchaseOrder',
+        'bizplace',
+        'bizplace.domain',
+        'bizplace.company',
+        'bizplace.company.domain',
+        'orderProducts',
+        'orderProducts.product',
+        'orderProducts.product.productDetails',
+        'orderProducts.product.productDetails.childProductDetail'
+      ]
+    })
+
+    // search for any active marketplace connection
+    const companyDomain: Domain = arrivalNotice.bizplace.company.domain
+    const customerDomain: Domain = arrivalNotice.bizplace.domain
+
+    const orderSource: string = arrivalNotice.source
+    switch (orderSource) {
+      case ApplicationType.SELLERCRAFT:
+        const sellercraft: Sellercraft = await tx
+          .getRepository(Sellercraft)
+          .findOneBy({ domain: { id: customerDomain.id }, status: SellercraftStatus.ACTIVE })
+
+        if (sellercraft) {
+          const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+          await sellercraftCtrl.registerProductInbound(sellercraft, arrivalNotice)
+        }
+        break
+
+      case ApplicationType.MMS:
+        const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
+          where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true },
+          relations: ['marketplaceDistributors']
+        })
+
+        if (marketplaceStores?.length && marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
+          const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+          await ecommerceCtrl.updateProductVariationStock(marketplaceStores, arrivalNotice.orderProducts, companyDomain)
+        }
+        break
+
+      default:
+        break
+    }
+
+    // const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
+    //   where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true },
+    //   relations: ['marketplaceDistributors']
+    // })
+
+    // const sellercraft: Sellercraft = await tx
+    //   .getRepository(Sellercraft)
+    //   .findOne({ domain: customerDomain, status: SellercraftStatus.ACTIVE })
+
+    // if (sellercraft) {
+    //   const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+    //   await sellercraftCtrl.registerProductInbound(sellercraft, arrivalNotice)
+    // }
+
+    // if (marketplaceStores?.length && marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
+    //   const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+    //   await ecommerceCtrl.updateProductVariationStock(marketplaceStores, arrivalNotice.orderProducts, companyDomain)
+    // }
+  }
+}
+
+export async function completePutaway(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  arrivalNoticeNo: string
+): Promise<void> {
+  const worksheetController: PutawayWorksheetController = new PutawayWorksheetController(tx, domain, user)
+  let worksheet: Worksheet = await worksheetController.completePutaway(arrivalNoticeNo)
+
+  /**
+   * 4. Generate the Goods Received Note straight away
+   */
+  if (!worksheet.arrivalNotice?.name || !worksheet.bizplace?.id) {
+    worksheet = await tx.getRepository(Worksheet).findOne({
+      where: { id: worksheet.id },
+      relations: ['bizplace', 'arrivalNotice']
+    })
+  }
+}

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

@@ -0,0 +1,11 @@
+import { activatePutawayResolver } from './activate-putaway'
+import { completePutawayResolver } from './complete-putaway'
+import { putawayResolver } from './putaway'
+import { undoPutawayResolver } from './undo-putaway'
+
+export const Mutations = {
+  ...activatePutawayResolver,
+  ...putawayResolver,
+  ...undoPutawayResolver,
+  ...completePutawayResolver
+}