@things-factory/worksheet-base 8.0.0-beta.0 → 8.0.0-beta.2

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

@@ -1,25 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,147 +0,0 @@
-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

@@ -1,242 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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
-}