@things-factory/worksheet-base 4.0.0-alpha.9 → 4.0.0-beta.0

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

@@ -1,16 +1,21 @@
-import { MarketplaceOrder, MarketplaceOrderItem } from '@things-factory/marketplace-base'
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { MarketplaceOrder, MarketplaceOrderItem, MarketplaceOrderShipping } from '@things-factory/marketplace-base'
 import { OrderInventory, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
-import { getRepository } from 'typeorm'
+
 import { WORKSHEET_TYPE } from '../../../constants'
+import { SellercraftController } from '../../../controllers'
 import { Worksheet, WorksheetDetail } from '../../../entities'
 import { fetchExecutingWorksheet } from '../../../utils'
 
 export const packingWorksheetResolver = {
   async packingWorksheet(_: any, { releaseGoodNo }, context: any) {
-    const { domain }: { domain: Domain } = context.state
-    const releaseGood: ReleaseGood = await getRepository(ReleaseGood).findOne({
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
       where: {
         domain,
         name: releaseGoodNo
@@ -24,7 +29,9 @@ export const packingWorksheetResolver = {
       releaseGood.bizplace,
       [
         'bizplace',
+        'bizplace.domain',
         'releaseGood',
+        'releaseGood.domain',
         'worksheetDetails',
         'worksheetDetails.targetInventory',
         'worksheetDetails.targetInventory.binLocation',
@@ -37,31 +44,84 @@ export const packingWorksheetResolver = {
       releaseGood
     )
 
-    const marketplaceOrder: MarketplaceOrder = await getRepository(MarketplaceOrder).findOne({
-      where: { releaseOrderId: releaseGood.id },
-      relations: [
-        'domain',
-        'marketplaceStore',
-        'marketplaceOrderItems',
-        'marketplaceOrderItems.marketplaceOrderShipping'
-      ]
-    })
+    let marketplaceOrder: MarketplaceOrder
+    let marketplaceOrderItems: MarketplaceOrderItem[] = []
+    let marketplaceStore
+    let trackingNo: string
+    let shippingProvider: string
+    let marketplaceStatus: string
+
+    if (releaseGood.type === 'b2c') {
+      const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({
+        domain: worksheet.bizplace.domain,
+        status: SellercraftStatus.ACTIVE
+      })
+
+      if (sellercraft) {
+        if (!releaseGood?.airwayBill) {
+          const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+          releaseGood = await sellercraftCtrl.fetchOrderDocument(sellercraft, releaseGood)
+        }
+        trackingNo = releaseGood?.trackingNo
+        shippingProvider = releaseGood?.transporter
+        marketplaceStatus = releaseGood?.marketplaceOrderStatus
+      }
 
-    const marketplaceOrderItems: MarketplaceOrderItem[] = marketplaceOrder.marketplaceOrderItems
-    const marketplaceStore = marketplaceOrder.marketplaceStore
-    const trackingNo: string = await getTrackingNo(marketplaceStore, marketplaceOrderItems)
+      if (!sellercraft) {
+        marketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+          where: { orderNo: releaseGood.refNo },
+          relations: [
+            'domain',
+            'marketplaceStore',
+            'marketplaceOrderItems',
+            'marketplaceOrderItems.marketplaceOrderShipping'
+          ]
+        })
+
+        if (!marketplaceOrder) {
+          throw new Error('Failed to retrieve ecommerce information, kindly contact our support team for this issue.')
+        }
+
+        let marketplaceOrderShipping: MarketplaceOrderShipping
+        if (marketplaceOrder.isSplitted) {
+          marketplaceOrderShipping = await tx.getRepository(MarketplaceOrderShipping).findOne({
+            where: { subOrderNoRef: worksheet.releaseGood.refNo2 }
+          })
+        } else {
+          marketplaceOrderShipping = await tx.getRepository(MarketplaceOrderShipping).findOne({
+            where: { orderNoRef: worksheet.releaseGood.refNo }
+          })
+        }
+
+        trackingNo = marketplaceOrderShipping.ownTrackingNo
+          ? marketplaceOrderShipping.ownTrackingNo
+          : marketplaceOrderShipping.trackingNo
+        shippingProvider = marketplaceOrderShipping.ownTransporter
+          ? marketplaceOrderShipping.ownTransporter
+          : marketplaceOrderShipping.transporter
+
+        marketplaceOrderItems = marketplaceOrder.marketplaceOrderItems.filter(
+          item => item.marketplaceOrderShipping.id === marketplaceOrderShipping.id
+        )
+        marketplaceStore = marketplaceOrder?.marketplaceStore
+        marketplaceStatus = marketplaceOrder?.status
+      }
+    }
 
     return {
       worksheetInfo: {
         bizplaceName: releaseGood.bizplace.name,
         refNo: releaseGood.refNo,
+        refNo2: releaseGood.refNo2,
         partnerDomainId: releaseGood.bizplace?.domain.id,
         startedAt: worksheet.startedAt,
-        shippingProvider: marketplaceOrder ? marketplaceOrder.shippingProvider : '',
+        shippingProvider: shippingProvider ? shippingProvider : '',
         trackingNo: trackingNo ? trackingNo : '',
-        platform: marketplaceOrder ? marketplaceOrder.marketplaceStore.platform : '',
+        airwayBill: releaseGood?.airwayBill,
+        invoice: releaseGood?.invoice,
+        platform: marketplaceOrder ? marketplaceOrder.marketplaceStore.platform : 'operato',
         marketplaceStoreId: marketplaceOrder ? marketplaceOrder.marketplaceStore.id : '',
-        marketplaceStatus: marketplaceOrder ? marketplaceOrder.status : '',
+        marketplaceStatus: marketplaceStatus ? marketplaceStatus : '',
         marketplaceOrder: marketplaceOrder ? marketplaceOrder : ''
       },
       worksheetDetailInfos: worksheet.worksheetDetails.map(async (packingWSD: WorksheetDetail) => {

package/server/graphql/resolvers/worksheet/pending-cancellation-release-order.ts

@@ -31,7 +31,11 @@ export const pendingCancellationReleaseOrder = {
     let pickingOIs: OrderInventory[]
 
     // 1. Check RO status
-    if (foundRO.status === ORDER_STATUS.LOADING) {
+    if (
+      foundRO.status === ORDER_STATUS.LOADING ||
+      foundRO.status === ORDER_STATUS.PACKING ||
+      foundRO.status === ORDER_STATUS.SORTING
+    ) {
       // 1a. Case 1: RO is done or loading, pending cancel order, worksheet, worksheet detail, order inventory
       // update status of order inventory to PENDING_CANCEL
       pickedOIs = targetOIs.map((orderInv: OrderInventory) => {

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

@@ -1,8 +1,12 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { MarketplaceStore } from '@things-factory/integration-marketplace'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { EcommerceController, PickingWorksheetController } from '../../../../controllers'
+
+import { EcommerceController, PickingWorksheetController, SellercraftController } from '../../../../controllers'
 import { Worksheet } from '../../../../entities'
 
 export const activateBatchPickingResolver = {
@@ -20,15 +24,41 @@ export async function activateBatchPicking(
 ): Promise<Worksheet> {
   const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
   const worksheet = await worksheetController.activateBatchPicking(worksheetNo)
+  const worksheetDetails = worksheet.worksheetDetails
   const companyDomain: Domain = worksheet?.bizplace.company.domain
 
+  const sellercraft: Sellercraft = await tx
+    .getRepository(Sellercraft)
+    .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
+
+  if (sellercraft) {
+    const releaseGoods: ReleaseGood[] = worksheetDetails.map(
+      worksheetDetail => worksheetDetail.targetInventory && worksheetDetail.targetInventory.releaseGood
+    )
+    const uniqueReleaseGoods: ReleaseGood[] = []
+    const map = new Map()
+    for (const releaseGood of releaseGoods) {
+      if (!map.has(releaseGood.id)) {
+        map.set(releaseGood.id, true)
+        uniqueReleaseGoods.push({ ...releaseGood })
+      }
+    }
+
+    await Promise.all(
+      uniqueReleaseGoods.map(async releaseGood => {
+        const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+        await sellercraftCtrl.initiateOrderShipment(sellercraft, releaseGood)
+      })
+    )
+  }
+
   // find for any existing marketplace store connections
   const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
-    where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true }
+    where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true },
+    relations: ['marketplaceDistributors']
   })
 
   if (marketplaceStores?.length && marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
-    const worksheetDetails = worksheet.worksheetDetails
     let orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
     const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
     await ecommerceCtrl.updateProductVariationStock(marketplaceStores, orderInventories, companyDomain)

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

@@ -1,8 +1,13 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { MarketplaceStore } from '@things-factory/integration-marketplace'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { MarketplaceOrder } from '@things-factory/marketplace-base'
+import { ORDER_STATUS, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { EcommerceController, PickingWorksheetController } from '../../../../controllers'
+
+import { EcommerceController, PickingWorksheetController, SellercraftController } from '../../../../controllers'
 import { Worksheet } from '../../../../entities'
 
 export const activatePickingResolver = {
@@ -24,14 +29,42 @@ export async function activatePicking(
 
   // find for any existing marketplace store connections
   const marketplaceStores: MarketplaceStore[] = await tx.getRepository(MarketplaceStore).find({
-    where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true }
+    where: { domain: companyDomain, status: 'ACTIVE', isAutoUpdateStockQty: true },
+    relations: ['marketplaceDistributors']
   })
 
-  if (marketplaceStores?.length && marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
-    const worksheetDetails = worksheet.worksheetDetails
-    let orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
-    const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
-    await ecommerceCtrl.updateProductVariationStock(marketplaceStores, orderInventories, companyDomain)
+  let releaseGood: ReleaseGood = worksheet.releaseGood
+
+  if (releaseGood.type === 'b2c') {
+    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.initiateOrderShipment(sellercraft, releaseGood)
+    }
+
+    if (marketplaceStores?.length && !sellercraft) {
+      if (marketplaceStores.some(store => store.isAutoUpdateStockQty)) {
+        const worksheetDetails = worksheet.worksheetDetails
+        let orderInventories: any[] = worksheetDetails.map(wsd => wsd.targetInventory)
+        const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+        await ecommerceCtrl.updateProductVariationStock(marketplaceStores, orderInventories, companyDomain)
+      }
+
+      const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+        where: { orderNo: releaseGood.refNo, domain: companyDomain },
+        relations: ['marketplaceStore']
+      })
+      const marketplaceStore: MarketplaceStore = marketplaceOrder.marketplaceStore
+
+      if (marketplaceStore.isAutoUpdateShipment) {
+        const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
+        await ecommerceCtrl.createOrderComment(marketplaceStore, marketplaceOrder, ORDER_STATUS.PICKING)
+      }
+    }
   }
+
   return worksheet
 }

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

@@ -7,11 +7,11 @@ import { WorksheetDetail } from '../../../../entities'
 export const assignPickingInventoriesResolver = {
   async assignPickingInventories(
     _: any,
-    { worksheetNo, batchId, productId, packingType, worksheetDetails },
+    { worksheetNo, batchId, productId, packingType, packingSize, worksheetDetails },
     context: any
   ): Promise<void> {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await assignPickingInventories(tx, domain, user, worksheetNo, batchId, productId, packingType, worksheetDetails)
+    await assignPickingInventories(tx, domain, user, worksheetNo, batchId, productId, packingType, packingSize, worksheetDetails)
   }
 }
 
@@ -23,8 +23,9 @@ export async function assignPickingInventories(
   batchId: string,
   productId: string,
   packingType: string,
+  packingSize: number,
   worksheetDetails: Partial<WorksheetDetail>[]
 ): Promise<void> {
   const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-  await worksheetController.assignPickingInventories(worksheetNo, batchId, productId, packingType, worksheetDetails)
+  await worksheetController.assignPickingInventories(worksheetNo, batchId, productId, packingType, packingSize, worksheetDetails)
 }

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

@@ -1,12 +1,15 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Bizplace, getMyBizplace } from '@things-factory/biz-base'
-import { ReleaseGood, OrderInventory } from '@things-factory/sales-base'
+import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { OrderInventory, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
-import { WORKSHEET_TYPE } from '../../../../constants'
+
 import {
   PackingWorksheetController,
   PickingWorksheetController,
+  SellercraftController,
   SortingWorksheetController
 } from '../../../../controllers/'
 import { WorksheetController } from '../../../../controllers/worksheet-controller'
@@ -41,6 +44,31 @@ export async function completeBatchPicking(
   const worksheetDetails: WorksheetDetail[] = worksheet.worksheetDetails
   const targetInventories: OrderInventory[] = worksheetDetails.map((wsd: WorksheetDetail) => wsd.targetInventory)
 
+  const sellercraft: Sellercraft = await tx
+    .getRepository(Sellercraft)
+    .findOne({ domain: worksheet.bizplace.domain, status: SellercraftStatus.ACTIVE })
+
+  if (sellercraft) {
+    const releaseGoods: ReleaseGood[] = worksheetDetails.map(
+      worksheetDetail => worksheetDetail.targetInventory && worksheetDetail.targetInventory.releaseGood
+    )
+    const uniqueReleaseGoods: ReleaseGood[] = []
+    const map = new Map()
+    for (const releaseGood of releaseGoods) {
+      if (!map.has(releaseGood.id)) {
+        map.set(releaseGood.id, true)
+        uniqueReleaseGoods.push({ ...releaseGood })
+      }
+    }
+
+    await Promise.all(
+      uniqueReleaseGoods.map(async releaseGood => {
+        const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
+        await sellercraftCtrl.initiateOrderDocument(sellercraft, releaseGood)
+      })
+    )
+  }
+
   const pickPackTargetInventories: OrderInventory[] = targetInventories
     .filter(targetInventory => targetInventory.releaseGood.packingOption)
     .map((pickPackTargetInventory: OrderInventory) => {