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

package/server/graphql/resolvers/worksheet/not-tally-target-inventories.ts

@@ -0,0 +1,34 @@
+import { createQueryBuilder, SelectQueryBuilder } from 'typeorm'
+
+import { InventoryCheck, ORDER_INVENTORY_STATUS } from '@things-factory/sales-base'
+import { getRepository } from '@things-factory/shell'
+
+import { Worksheet, WorksheetDetail } from '../../../entities'
+
+export const notTallyTargetInventoriesResolver = {
+  async notTallyTargetInventories(_: any, { cycleCountNo }, context: ResolverContext) {
+    const { domain } = context.state
+
+    const cycleCount: InventoryCheck = await getRepository(InventoryCheck).findOne({
+      where: { domain: { id: domain.id }, name: cycleCountNo }
+    })
+
+    const worksheet: Worksheet = await getRepository(Worksheet).findOne({
+      where: { domain: { id: domain.id }, inventoryCheck: { id: cycleCount.id } }
+    })
+
+    const qb: SelectQueryBuilder<WorksheetDetail> = createQueryBuilder(WorksheetDetail, 'WSD')
+    const worksheetDetails: WorksheetDetail[] = await qb
+      .leftJoinAndSelect('WSD.targetInventory', 'T_INV')
+      .leftJoinAndSelect('T_INV.inventory', 'INV')
+      .leftJoinAndSelect('T_INV.originLocation', 'ORG_LOC')
+      .leftJoinAndSelect('T_INV.inspectedLocation', 'ISP_LOC')
+      .leftJoinAndSelect('INV.product', 'PROD')
+      .where('WSD.domain = :domainId', { domainId: domain.id })
+      .andWhere('WSD.worksheet = :worksheetId', { worksheetId: worksheet.id })
+      .andWhere('WSD.status = :status', { status: ORDER_INVENTORY_STATUS.NOT_TALLY })
+      .getMany()
+
+    return worksheetDetails.map((wsd: WorksheetDetail) => wsd.targetInventory)
+  }
+}

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

@@ -0,0 +1,69 @@
+import { EntityManager, getManager } from 'typeorm'
+
+import { ApplicationType, User } from '@things-factory/auth-base'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { ReleaseGood } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import { PackingWorksheetController, SellercraftController } from '../../../../controllers'
+import { Worksheet } from '../../../../entities'
+
+export const activatePackingResolver = {
+  async activatePacking(_: any, { worksheetNo }, context: ResolverContext) {
+    const { domain, user } = context.state
+
+    let activatedPackingWs = []
+
+    await Promise.all(
+      worksheetNo.map(async item => {
+        try {
+          await getManager().transaction(async txMgr => {
+            let result = await activatePacking(txMgr, domain, user, item)
+            activatedPackingWs.push(result)
+          })
+        } catch (error) {}
+      })
+    )
+    return activatedPackingWs
+  }
+}
+
+export async function activatePacking(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetNo: string
+): Promise<Worksheet> {
+  const worksheetController: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
+  const worksheet = await worksheetController.activatePacking(worksheetNo)
+  let releaseGood: ReleaseGood = worksheet.releaseGood
+
+  const orderSource: string = releaseGood.source
+  switch (orderSource) {
+    case ApplicationType.SELLERCRAFT:
+      const sellercraft: Sellercraft = await tx
+        .getRepository(Sellercraft)
+        .findOneBy({ domain: {id: releaseGood.bizplace.domain.id }, status: SellercraftStatus.ACTIVE })
+
+      if (sellercraft) {
+        const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+        sellercraftCtrl.initiateOrderDocument(sellercraft, releaseGood)
+      }
+      break
+
+    default:
+      break
+  }
+
+  // if (releaseGood.type == 'b2c') {
+  //   const sellercraft: Sellercraft = await tx
+  //     .getRepository(Sellercraft)
+  //     .findOne({ domain: releaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
+
+  //   if (sellercraft) {
+  //     const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+  //     sellercraftCtrl.initiateOrderDocument(sellercraft, releaseGood)
+  //   }
+  // }
+  return worksheet
+}

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

@@ -0,0 +1,102 @@
+import { EntityManager } from 'typeorm'
+
+import { ApplicationType, User } from '@things-factory/auth-base'
+import { Bizplace, getMyBizplace } from '@things-factory/biz-base'
+import { MarketplaceStore } from '@things-factory/integration-marketplace'
+import { MarketplaceOrder } from '@things-factory/marketplace-base'
+import { ReleaseGood } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import { PackingWorksheetController } from '../../../../controllers/'
+import { EcommerceController } from '../../../../controllers/ecommerce'
+import { WorksheetController } from '../../../../controllers/worksheet-controller'
+
+export const completePackingResolver = {
+  async completePacking(_: any, { releaseGoodNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    await completePacking(tx, domain, user, releaseGoodNo)
+
+    const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+      where: { domain: { id: domain.id }, name: releaseGoodNo },
+      relations: [
+        'bizplace',
+        'bizplace.domain',
+        'bizplace.company',
+        'bizplace.company.domain',
+        'orderInventories',
+        'orderInventories.product'
+      ]
+    })
+
+    const orderSource: string = releaseGood.source
+    switch (orderSource) {
+      case ApplicationType.MMS:
+        const companyDomain: Domain = releaseGood.bizplace.company.domain
+        const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+          where: { orderNo: releaseGood.refNo, domain: { id: companyDomain.id } },
+          relations: [
+            'marketplaceOrderItems',
+            'marketplaceOrderItems.marketplaceOrderShippingItems',
+            'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
+            'marketplaceStore',
+            'marketplaceStore.marketplaceDistributors'
+          ]
+        })
+        const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
+
+        if (marketplaceStore.isAutoUpdateShipment) {
+          const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+          await ecommerceCtrl.createOrderShip(releaseGood, marketplaceStore, marketplaceOrder, companyDomain)
+        }
+        break
+
+      default:
+        break
+    }
+
+    // if (releaseGood.type === 'b2c') {
+    //   const sellercraft: Sellercraft = await tx
+    //     .getRepository(Sellercraft)
+    //     .findOne({ domain: releaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
+
+    //   if (!sellercraft) {
+    //     const companyDomain: Domain = releaseGood.bizplace.company.domain
+    //     const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+    //       where: { orderNo: releaseGood.refNo, domain: companyDomain },
+    //       relations: [
+    //         'marketplaceOrderItems',
+    //         'marketplaceOrderItems.marketplaceOrderShippingItems',
+    //         'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
+    //         'marketplaceStore',
+    //         'marketplaceStore.marketplaceDistributors'
+    //       ]
+    //     })
+    //     const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
+
+    //     if (marketplaceStore.isAutoUpdateShipment) {
+    //       const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+    //       await ecommerceCtrl.createOrderShip(releaseGood, marketplaceStore, marketplaceOrder, companyDomain)
+    //     }
+    //   }
+    // }
+
+    const bizplace: Bizplace = await getMyBizplace(domain, user)
+    const worksheetController: WorksheetController = new WorksheetController(tx, domain, user)
+    await worksheetController.notifyToCustomer(bizplace, {
+      title: `Packing has been completed (${bizplace.name}, ${releaseGoodNo})`,
+      body: `Items now are ready to be shipped/delivery`,
+      url: context.header.referer,
+      data: { url: context.header.referer }
+    })
+  }
+}
+
+export async function completePacking(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  releaseGoodNo: string
+): Promise<void> {
+  const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
+  await packingWSCtrl.completePacking(releaseGoodNo)
+}

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

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

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

@@ -0,0 +1,59 @@
+import { EntityManager } from 'typeorm'
+
+import { ApplicationType, User } from '@things-factory/auth-base'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { ReleaseGood } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import { PackingWorksheetController, SellercraftController } from '../../../../controllers'
+import { Worksheet } from '../../../../entities'
+
+export const packingResolver = {
+  async packing(_: any, { worksheetDetailName, releaseQty, serialNumber }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    await packing(tx, domain, user, worksheetDetailName, releaseQty, serialNumber)
+  }
+}
+
+export async function packing(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: string,
+  releaseQty: number,
+  serialNumber?: string
+) {
+  const worksheetController: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
+  const worksheetDetail = await worksheetController.packing(worksheetDetailName, releaseQty, serialNumber)
+
+  let releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
+  const worksheet: Worksheet = worksheetDetail.worksheet
+
+  const orderSource: string = releaseGood.source
+  switch (orderSource) {
+    case ApplicationType.SELLERCRAFT:
+      const sellercraft: Sellercraft = await tx
+        .getRepository(Sellercraft)
+        .findOneBy({ domain: { id: worksheet.bizplace.domain.id }, status: SellercraftStatus.ACTIVE })
+
+      if (sellercraft) {
+        const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+        await sellercraftCtrl.fetchOrderDocument(sellercraft, releaseGood)
+      }
+      break
+
+    default:
+      break
+  }
+
+  // if (releaseGood.type === 'b2c' && !releaseGood?.airwayBill) {
+  //   const sellercraft: Sellercraft = await tx
+  //     .getRepository(Sellercraft)
+  //     .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
+
+  //   if (sellercraft) {
+  //     const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+  //     await sellercraftCtrl.fetchOrderDocument(sellercraft, releaseGood)
+  //   }
+  // }
+}

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

@@ -0,0 +1,70 @@
+import { EntityManager } from 'typeorm'
+
+import { ApplicationType, User } from '@things-factory/auth-base'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { ReleaseGood } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+import { PackingWorksheetController, SellercraftController } from '../../../../controllers'
+import { Worksheet } from '../../../../entities'
+
+export const scanProductPackingResolver = {
+  async scanProductPacking(_: any, { worksheetDetailName, productBarcode, serialNumber }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    await scanProductPacking(tx, domain, user, worksheetDetailName, productBarcode, serialNumber)
+  }
+}
+
+export async function scanProductPacking(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetDetailName: string,
+  productBarcode: string,
+  serialNumber?: string
+) {
+  try {
+    const worksheetController: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
+    const worksheetDetail = await worksheetController.scanProductPacking(
+      worksheetDetailName,
+      productBarcode,
+      serialNumber
+    )
+
+    let releaseGood: ReleaseGood = worksheetDetail.targetInventory.releaseGood
+    const worksheet: Worksheet = worksheetDetail.worksheet
+
+    const orderSource: string = releaseGood.source
+    switch (orderSource) {
+      case ApplicationType.SELLERCRAFT:
+        if (!releaseGood?.airwayBill) {
+          const sellercraft: Sellercraft = await tx
+            .getRepository(Sellercraft)
+            .findOneBy({ domain: { id: worksheet.bizplace.domain.id }, status: SellercraftStatus.ACTIVE })
+
+          if (sellercraft) {
+            const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+            sellercraftCtrl.fetchOrderDocument(sellercraft, releaseGood)
+          }
+        }
+
+        break
+
+      default:
+        break
+    }
+
+    // if (releaseGood.type === 'b2c' && !releaseGood?.airwayBill) {
+    //   const sellercraft: Sellercraft = await tx
+    //     .getRepository(Sellercraft)
+    //     .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
+
+    //   if (sellercraft) {
+    //     const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+    //     sellercraftCtrl.fetchOrderDocument(sellercraft, releaseGood)
+    //   }
+    // }
+  } catch (error) {
+    throw error
+  }
+}

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

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