@things-factory/worksheet-base 5.0.13 → 6.0.0-alpha.1

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-release-good-worksheet.ts

@@ -2,22 +2,17 @@ import { EntityManager } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
+import { Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
-import { PartnerSetting, Setting } from '@things-factory/setting-base'
+import { Inventory, INVENTORY_TRANSACTION_TYPE, InventoryUtil } from '@things-factory/warehouse-base'
 
 import { PickingWorksheetController } from '../../../../controllers/'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
 
-import {
-  Inventory,
-  InventoryUtil,
-  INVENTORY_TRANSACTION_TYPE
-} from '@things-factory/warehouse-base'
-
 export const generateReleaseGoodWorksheetResolver = {
-  async generateReleaseGoodWorksheet(_: any, { releaseGoodNo }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    return await generatePickingWorksheet(tx, domain, user, releaseGoodNo)
+  async generateReleaseGoodWorksheet(_: any, { releaseGoodNo, currentStatus = null }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
+    return await generatePickingWorksheet(tx, domain, user, releaseGoodNo, currentStatus)
   }
 }
 
@@ -25,42 +20,42 @@ export async function generatePickingWorksheet(
   tx: EntityManager,
   domain: Domain,
   user: User,
-  releaseGoodNo: string
+  releaseGoodNo: string,
+  currentStatus: string = null
 ): Promise<Worksheet> {
   try {
     const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
 
-    let releaseGood: ReleaseGood = await worksheetController.findRefOrder(
-      ReleaseGood,
-      {
-        domain: domain,
-        name: releaseGoodNo,
-        status: ORDER_STATUS.PENDING_WORKSHEET
-      }
-    )
+    let releaseGood: ReleaseGood = await worksheetController.findRefOrder(ReleaseGood, {
+      domain: domain,
+      name: releaseGoodNo,
+      status: ORDER_STATUS.PENDING_WORKSHEET
+    })
 
     let worksheet: Worksheet = new Worksheet()
 
     const directReleaseOrder: Setting = await tx.getRepository(Setting).findOne({
-      where: { domain, category: 'id-rule', name: 'enable-direct-b2c-release-order' }
+      where: { domain: { id: domain.id }, category: 'id-rule', name: 'enable-direct-b2c-release-order' }
     })
 
     if (releaseGood.type == 'b2c' && directReleaseOrder && directReleaseOrder.value.toLowerCase() == 'true') {
       const inventoryUtil = new InventoryUtil(tx, domain, user)
 
       let orderInventories: OrderInventory[] = await tx.getRepository(OrderInventory).find({
-        where: { domain, releaseGood },
+        where: { domain: { id: domain.id }, releaseGood },
         relations: ['inventory']
       })
 
       for (let idx = 0; idx < orderInventories.length; idx++) {
         let orderInventory = orderInventories[idx]
         if (orderInventory.releaseQty <= 0 || (orderInventory.uomValue != null && orderInventory.uomValue <= 0)) {
-          throw new Error(`Invalid data for ${releaseGoodNo}. Please contact support.`);
+          throw new Error(`Invalid data for ${releaseGoodNo}. Please contact support.`)
         }
         orderInventory.uomValue = orderInventory.uomValue > 0 ? orderInventory.uomValue : 0
 
-        let inventory: Inventory = await tx.getRepository(Inventory).findOne({ where: { id: orderInventory.inventory.id } })
+        let inventory: Inventory = await tx
+          .getRepository(Inventory)
+          .findOne({ where: { id: orderInventory.inventory.id } })
 
         await inventoryUtil.transactionInventory(
           {
@@ -71,18 +66,19 @@ export async function generatePickingWorksheet(
             lockedUomValue: Math.round((inventory.lockedUomValue - orderInventory.releaseUomValue) * 100) / 100
           },
           releaseGood,
-          - orderInventory.releaseQty,
-          - orderInventory.releaseUomValue,
+          -orderInventory.releaseQty,
+          -orderInventory.releaseUomValue,
           INVENTORY_TRANSACTION_TYPE.DIRECT_DEDUCTION
         )
 
-        await tx.getRepository(OrderInventory).save({ id: orderInventory.id, status: ORDER_INVENTORY_STATUS.TERMINATED })
+        await tx
+          .getRepository(OrderInventory)
+          .update({ id: orderInventory.id }, { status: ORDER_INVENTORY_STATUS.TERMINATED })
       }
 
-      await tx.getRepository(ReleaseGood).save({ id: releaseGood.id, status: ORDER_STATUS.DONE })
-
+      await tx.getRepository(ReleaseGood).update({ id: releaseGood.id }, { status: ORDER_STATUS.DONE })
     } else {
-      worksheet = await worksheetController.generatePickingWorksheet(releaseGoodNo)
+      worksheet = await worksheetController.generatePickingWorksheet(releaseGoodNo, currentStatus)
     }
 
     return worksheet

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-return-order-worksheet.ts

@@ -1,18 +1,20 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { ReturnOrder } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { UnloadingReturningWorksheetController } from '../../../../controllers'
 import { Worksheet } from '../../../../entities'
 
 export const generateReturnOrderWorksheetResolver = {
-  async generateReturnOrderWorksheet(_: any, { returnOrderNo, bufferLocation }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async generateReturnOrderWorksheet(_: any, { returnOrderNo, bufferLocation }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     let outboundReturningWorksheet = await generateReturnOrderWorksheet(tx, domain, user, returnOrderNo, bufferLocation)
 
     if (!outboundReturningWorksheet.returnOrder?.id) {
       outboundReturningWorksheet = await tx.getRepository(Worksheet).findOne({
-        where: outboundReturningWorksheet,
+        where: { id: outboundReturningWorksheet.id },
         relations: ['returnOrder']
       })
     }

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-vas-order-worksheet.ts

@@ -1,15 +1,17 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { ORDER_STATUS, VasOrder } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { VasWorksheetController } from '../../../../controllers/'
 import { Worksheet } from '../../../../entities'
 
 export const generateVasOrderWorksheetResolver = {
-  async generateVasOrderWorksheet(_: any, { vasNo }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async generateVasOrderWorksheet(_: any, { vasNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     const foundVasOrder: VasOrder = await tx.getRepository(VasOrder).findOne({
-      where: { domain, name: vasNo, status: ORDER_STATUS.PENDING_RECEIVE }
+      where: { domain: { id: domain.id }, name: vasNo, status: ORDER_STATUS.PENDING_RECEIVE }
     })
 
     const vasOrderWorksheet: Worksheet = await generateVasOrderWorksheet(tx, domain, user, foundVasOrder)

package/server/graphql/resolvers/worksheet/having-vas.ts

@@ -1,27 +1,29 @@
+import { FindOneOptions, Repository } from 'typeorm'
+
 import { ArrivalNotice, ORDER_TYPES, ReleaseGood } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-import { getRepository, FindOneOptions, Repository } from 'typeorm'
-import { Worksheet } from '../../../entities'
+import { getRepository } from '@things-factory/shell'
+
 import { WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet } from '../../../entities'
 
 export const havingVasResolver = {
-  async havingVas(_: any, { orderType, orderNo }, context: any): Promise<Worksheet> {
+  async havingVas(_: any, { orderType, orderNo }, context: ResolverContext): Promise<Worksheet> {
     return await havingVas(orderType, orderNo, context)
   }
 }
 
-export async function havingVas(orderType: string, orderNo: string, context: any) {
+export async function havingVas(orderType: string, orderNo: string, context: ResolverContext) {
   const ganRepo: Repository<ArrivalNotice> = getRepository(ArrivalNotice)
   const roRepo: Repository<ReleaseGood> = getRepository(ReleaseGood)
   const wsRepo: Repository<Worksheet> = getRepository(Worksheet)
 
-  const { domain }: { domain: Domain } = context.state
+  const { domain } = context.state
 
   const orderFindOptions: FindOneOptions<ArrivalNotice | ReleaseGood> = {
-    where: { domain, name: orderNo }
+    where: { domain: { id: domain.id }, name: orderNo }
   }
   let wsFindOptions: FindOneOptions<Worksheet> = {
-    where: { domain, type: WORKSHEET_TYPE.VAS },
+    where: { domain: { id: domain.id }, type: WORKSHEET_TYPE.VAS },
     relations: ['worksheetDetails', 'worksheetDetails.targetVas', 'worksheetDetails.targetVas.vas']
   }
 

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

@@ -8,8 +8,10 @@ import { cycleCountAdjustmentResolver } from './cycle-count-adjustment'
 import { cycleCountWorksheetResolver } from './cycle-count-worksheet'
 import { deleteWorksheet } from './delete-worksheet'
 import { deliveryOrderByWorksheetResolver } from './delivery-order-by-worksheet'
-import { fetchSellercraftAirwayBillResolver } from './fetch-sellercraft-airway-bill'
+import { fetchDeliveryOrderROResolver } from './fetch-delivery-order-ro'
+import { fetchSellercraftDocumentResolver } from './fetch-sellercraft-document'
 import { findReleaseOrdersByTaskNoResolver } from './find-release-orders-by-task-no'
+import { findSortingReleaseOrdersByTaskNoResolver } from './find-sorting-release-orders-by-task-no'
 import { Mutations as GenerateWorksheetMutations } from './generate-worksheet'
 import { havingVasResolver } from './having-vas'
 import { Mutations as InspectMutations } from './inspecting'
@@ -98,7 +100,9 @@ export const Query = {
   ...myPickingAssignmentStatusResolver,
   ...recommendPutawayLocationResolver,
   ...sortingWorksheetResolver,
-  ...findReleaseOrdersByTaskNoResolver
+  ...findSortingReleaseOrdersByTaskNoResolver,
+  ...findReleaseOrdersByTaskNoResolver,
+  ...fetchDeliveryOrderROResolver
 }
 
 export const Mutation = {
@@ -133,6 +137,6 @@ export const Mutation = {
   ...crossDockPickingResolver,
   ...unpackingResolver,
   ...palletizingPallets,
-  ...fetchSellercraftAirwayBillResolver,
+  ...fetchSellercraftDocumentResolver,
   ...cancelDraftReleaseOrder
 }

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

@@ -1,12 +1,14 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { CycleCountWorksheetController } from '../../../../controllers'
 import { Worksheet } from '../../../../entities'
 
 export const activateCycleCountResolver = {
-  async activateCycleCount(_: any, { worksheetNo }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async activateCycleCount(_: any, { worksheetNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     return await activateCycleCount(tx, domain, user, worksheetNo)
   }
 }

package/server/graphql/resolvers/worksheet/inspecting/add-extra-pallet.ts

@@ -1,6 +1,8 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { CycleCountWorksheetController } from '../../../../controllers'
 
 export const addExtraPalletResolver = {
@@ -9,7 +11,7 @@ export const addExtraPalletResolver = {
     { cycleCountNo, palletId, inspectedBatchNo, inspectedQty, inspectedUomValue, locationName },
     context: any
   ) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
     await addExtraPallet(
       tx,
       domain,

package/server/graphql/resolvers/worksheet/inspecting/check-missing-pallet.ts

@@ -1,11 +1,13 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { CycleCountWorksheetController } from '../../../../controllers'
 
 export const checkMissingPalletResolver = {
-  async checkMissingPallet(_: any, { worksheetDetailName }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async checkMissingPallet(_: any, { worksheetDetailName }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     await checkMissingPallet(tx, domain, user, worksheetDetailName)
   }
 }

package/server/graphql/resolvers/worksheet/inspecting/complete-inspection.ts

@@ -1,14 +1,16 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { WORKSHEET_STATUS } from '../../../../constants'
 import { CycleCountWorksheetController } from '../../../../controllers'
 import { WorksheetController } from '../../../../controllers/worksheet-controller'
 import { Worksheet } from '../../../../entities'
 
 export const completeInspectionResolver = {
-  async completeInspection(_: any, { inventoryCheckNo }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async completeInspection(_: any, { inventoryCheckNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     const worksheet: Worksheet = await completeCycleCount(tx, domain, user, inventoryCheckNo)
 
     const body: string =

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

@@ -1,11 +1,17 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { CycleCountWorksheetController } from '../../../../controllers'
 
 export const inspectingResolver = {
-  async inspecting(_: any, { worksheetDetailName, inspectedBatchNo, inspectedQty, inspectedUomValue }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async inspecting(
+    _: any,
+    { worksheetDetailName, inspectedBatchNo, inspectedQty, inspectedUomValue },
+    context: ResolverContext
+  ) {
+    const { tx, domain, user } = context.state
     await executeInspection(tx, domain, user, worksheetDetailName, inspectedBatchNo, inspectedQty, inspectedUomValue)
   }
 }

package/server/graphql/resolvers/worksheet/inspecting/relocate-pallet.ts

@@ -1,11 +1,17 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { CycleCountWorksheetController } from '../../../../controllers'
 
 export const relocatePalletResolver = {
-  async relocatePallet(_: any, { worksheetDetailName, inspectedBatchNo, inspectedQty, inspectedUomValue, inspectedLocationName }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async relocatePallet(
+    _: any,
+    { worksheetDetailName, inspectedBatchNo, inspectedQty, inspectedUomValue, inspectedLocationName },
+    context: ResolverContext
+  ) {
+    const { tx, domain, user } = context.state
     await relocatePallet(
       tx,
       domain,
@@ -30,5 +36,11 @@ export async function relocatePallet(
   inspectedLocationName: string
 ) {
   const worksheetController: CycleCountWorksheetController = new CycleCountWorksheetController(tx, domain, user)
-  await worksheetController.relocatePallet(worksheetDetailName, inspectedBatchNo, inspectedQty, inspectedUomValue, inspectedLocationName)
+  await worksheetController.relocatePallet(
+    worksheetDetailName,
+    inspectedBatchNo,
+    inspectedQty,
+    inspectedUomValue,
+    inspectedLocationName
+  )
 }

package/server/graphql/resolvers/worksheet/inspecting/undo-inspection.ts

@@ -1,11 +1,13 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { CycleCountWorksheetController } from '../../../../controllers'
 
 export const undoInspectionResolver = {
-  async undoInspection(_: any, { worksheetDetailName }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async undoInspection(_: any, { worksheetDetailName }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     await undoInspection(tx, domain, user, worksheetDetailName)
   }
 }

package/server/graphql/resolvers/worksheet/inventories-by-pallet.ts

@@ -1,18 +1,20 @@
-import { Brackets, getRepository, SelectQueryBuilder } from 'typeorm'
+import { Brackets, OrderByCondition, SelectQueryBuilder } from 'typeorm'
 
-import { User } from '@things-factory/auth-base'
 import { getPermittedBizplaceIds } from '@things-factory/biz-base'
 import { ORDER_INVENTORY_STATUS } from '@things-factory/sales-base'
-import { buildCondition, buildQuery, Domain } from '@things-factory/shell'
+import { buildCondition, buildQuery, getRepository } from '@things-factory/shell'
 import { Inventory, LOCATION_TYPE } from '@things-factory/warehouse-base'
 
 export const inventoriesByPalletResolver = {
-  async inventoriesByPallet(_: any, { filters, pagination, sortings, locationSortingRules }, context: any) {
-    const { domain, user }: { domain: Domain; user: User } = context.state
+  async inventoriesByPallet(_: any, { filters, pagination, sortings, locationSortingRules }, context: ResolverContext) {
+    const { domain, user } = context.state
     const params = { filters, pagination }
     let permittedBizplaceIds: string[] = await getPermittedBizplaceIds(domain, user)
-
     const productFilters = params.filters.filter(x => x.name == 'productName')
+    const recallFilters = params.filters.find(x => x.name === 'recall')
+    const skipLockCheckFilters = params.filters.find(x => x.name === 'skipLockCheck')
+    let skipLockCheck: Boolean =
+      skipLockCheckFilters && skipLockCheckFilters?.value ? skipLockCheckFilters?.value : false
     const productFilterColumns = ['sku', 'brandSku', 'name', 'description', 'brand', 'subBrand']
     params.filters = params.filters.filter(x => x.name != 'productName')
 
@@ -28,6 +30,9 @@ export const inventoriesByPalletResolver = {
       params.filters.find(filter => filter.name === 'bizplace').relation = true
     }
 
+    const locationFilters = params.filters.find(x => x.name == 'locationName')
+    params.filters = params.filters.filter(x => x.name != 'locationName')
+
     const qb: SelectQueryBuilder<Inventory> = getRepository(Inventory).createQueryBuilder('iv')
     buildQuery(qb, params, context)
 
@@ -39,9 +44,11 @@ export const inventoriesByPalletResolver = {
       .leftJoinAndSelect('iv.creator', 'creator')
       .leftJoinAndSelect('iv.updater', 'updater')
       .andWhere('iv.qty > 0')
-      .andWhere('CASE WHEN iv.lockedQty IS NULL THEN 0 ELSE iv.lockedQty END >= 0')
-      .andWhere('iv.qty - CASE WHEN iv.lockedQty IS NULL THEN 0 ELSE iv.lockedQty END > 0')
-      .andWhere(`location.type NOT IN ('${LOCATION_TYPE.QUARANTINE}', '${LOCATION_TYPE.RESERVE}')`)
+      .andWhere(
+        `location.type ${recallFilters?.value === true ? '' : 'NOT'} IN ('${LOCATION_TYPE.QUARANTINE}', '${
+          LOCATION_TYPE.RESERVE
+        }')`
+      )
       .andWhere(
         `(iv.batch_id, product.name, iv.packing_type, product.brand) NOT IN (
         SELECT 
@@ -60,14 +67,24 @@ export const inventoriesByPalletResolver = {
         { permittedBizplaceIds, domainId: domain.id }
       )
 
+    if (!skipLockCheck) {
+      qb.andWhere('CASE WHEN iv.lockedQty IS NULL THEN 0 ELSE iv.lockedQty END >= 0')
+      qb.andWhere('iv.qty - CASE WHEN iv.lockedQty IS NULL THEN 0 ELSE iv.lockedQty END > 0')
+    }
+
+    if (locationFilters) {
+      qb.andWhere(`location.name ilike '${locationFilters.value}'`)
+    }
+
     if (sortings?.length !== 0) {
-      const arrChildSortData = ['bizplace', 'product', 'location', 'warehouse', 'zone']
-      const sort = (sortings || []).reduce(
-        (acc, sort) => ({
+      const arrChildSortData = ['productName', 'productSKU']
+
+      const remapChildSortData = ['name', 'sku']
+      const sort: OrderByCondition = (sortings || []).reduce(
+        (acc, sort, idx) => ({
           ...acc,
-          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'iv.' + sort.name]: sort.desc
-            ? 'DESC'
-            : 'ASC'
+          [arrChildSortData.indexOf(sort.name) >= 0 ? 'product' + '.' + remapChildSortData[idx] : 'iv.' + sort.name]:
+            sort.desc ? 'DESC' : 'ASC'
         }),
         {}
       )
@@ -101,7 +118,6 @@ export const inventoriesByPalletResolver = {
         })
       )
     }
-
     let [items, total] = await qb.getManyAndCount()
 
     items = await Promise.all(
@@ -116,7 +132,8 @@ export const inventoriesByPalletResolver = {
           // product: item.product,
           productName: item.product.name,
           productSKU: item.product.sku,
-          productBrand: item.product.brand
+          productBrand: item.product.brand,
+          productId: item.product.id
         }
       })
     )

package/server/graphql/resolvers/worksheet/loaded-inventories.ts

@@ -1,13 +1,14 @@
-import { DeliveryOrder, OrderInventory, ORDER_STATUS, ReleaseGood } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
-import { getRepository, In } from 'typeorm'
+import { In } from 'typeorm'
+
+import { DeliveryOrder, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
+import { getRepository } from '@things-factory/shell'
 
 export const loadedInventories = {
-  async loadedInventories(_: any, { releaseGoodNo }, context: any) {
-    const { domain }: { domain: Domain } = context.state
+  async loadedInventories(_: any, { releaseGoodNo }, context: ResolverContext) {
+    const { domain } = context.state
     const foundRO: ReleaseGood = await getRepository(ReleaseGood).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         name: releaseGoodNo,
         status: ORDER_STATUS.LOADING
       },

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

@@ -1,13 +1,15 @@
+import { EntityManager, Equal, Not } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager, Equal, Not } from 'typeorm'
+
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
 import { LoadingWorksheetController } from '../../../../controllers'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
 
 export const activateLoadingResolver = {
-  async activateLoading(_: any, { worksheetNo, loadingWorksheetDetails }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async activateLoading(_: any, { worksheetNo, loadingWorksheetDetails }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     const foundWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
       where: {
         domain: domain,

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

@@ -13,8 +13,8 @@ import { LoadingWorksheetController, ReturningWorksheetController } from '../../
 import { Worksheet, WorksheetDetail } from '../../../../entities'
 
 export const completeLoadingResolver = {
-  async completeLoading(_: any, { releaseGoodNo }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async completeLoading(_: any, { releaseGoodNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     await completeLoading(tx, domain, user, releaseGoodNo)
   }
 }
@@ -29,7 +29,7 @@ export async function completeLoading(
   const releaseGood: ReleaseGood = await worksheetController.findRefOrder(
     ReleaseGood,
     {
-      domain,
+      domain: { id: domain.id },
       name: releaseGoodNo,
       status: ORDER_STATUS.LOADING
     },
@@ -49,39 +49,39 @@ export async function completeLoading(
   // Search Warehouse Company Domain
   const warehouseCompanyBizplace: Bizplace = await tx
     .getRepository(Bizplace)
-    .findOne({ where: { domain }, relations: ['company'] })
+    .findOne({ where: { domain: { id: domain.id } }, relations: ['company'] })
 
   const warehouseCompany: Company = warehouseCompanyBizplace.company
   const warehouseBizplaces: Bizplace[] = await tx
     .getRepository(Bizplace)
-    .find({ where: { company: warehouseCompany }, relations: ['domain'] })
+    .find({ where: { company: { id: warehouseCompany.id } }, relations: ['domain'] })
   const warehouseCompanyBizplaces: Bizplace[] = warehouseBizplaces.filter(biz => biz.domain.extType == 'company')
   const warehouseCompanyDomain: Domain = warehouseCompanyBizplaces[0].domain
 
   const customerDomain: Domain = releaseGood.bizplace.domain
   const fulfillmentCenter: FulfillmentCenter = await tx
     .getRepository(FulfillmentCenter)
-    .findOne({ domain: warehouseCompanyDomain, centerId: domain.subdomain, status: 'active' })
+    .findOneBy({ domain: { id: warehouseCompanyDomain.id }, centerId: domain.subdomain, status: 'active' })
 
   if (fulfillmentCenter) {
     let customerAvailableSftp: Sftp = await tx.getRepository(Sftp).findOne({
-      where: { domain: customerDomain, status: 'ACTIVE', fulfillmentCenter }
+      where: { domain: { id: customerDomain.id }, status: 'ACTIVE', fulfillmentCenter }
     })
     if (customerAvailableSftp) {
       const responseFileTypes: any = JSON.parse(customerAvailableSftp.responseFileTypes)
 
       let inventoryItems: InventoryItem[] = await tx.getRepository(InventoryItem).find({
-        where: { domain, outboundOrderId: releaseGood.id }
+        where: { domain: { id: domain.id }, outboundOrderId: releaseGood.id }
       })
 
-      if (responseFileTypes.enableShipment) {
-        let shipmentResult: Sftp = await SftpAPI.createShipment(customerAvailableSftp, {
-          releaseGood,
-          orderInventories: targetInventories,
-          sftp: customerAvailableSftp
-        })
-        customerAvailableSftp = await tx.getRepository(Sftp).save(shipmentResult)
-      }
+      // if (responseFileTypes.enableShipment) {
+      //   let shipmentResult: Sftp = await SftpAPI.createShipment(customerAvailableSftp, {
+      //     releaseGood,
+      //     orderInventories: targetInventories,
+      //     sftp: customerAvailableSftp
+      //   })
+      //   customerAvailableSftp = await tx.getRepository(Sftp).save(shipmentResult)
+      // }
 
       if (responseFileTypes.enableSerialNumber) {
         let snResult: Sftp = await SftpAPI.createSerialNumber(customerAvailableSftp, {

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

@@ -1,14 +1,16 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { generateDeliveryOrder, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { LoadingWorksheetController, WorksheetController } from '../../../../controllers'
 import { WorksheetDetail } from '../../../../entities'
 
 export const loadingResolver = {
-  async loading(_: any, { loadedWorksheetDetails, releaseGoodNo, orderInfo }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async loading(_: any, { loadedWorksheetDetails, releaseGoodNo, orderInfo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     const worksheetDetails = await loading(tx, domain, user, loadedWorksheetDetails, releaseGoodNo)
     const worksheetController: WorksheetController = new WorksheetController(tx, domain, user)
     const releaseGood: ReleaseGood = await worksheetController.findRefOrder(

package/server/graphql/resolvers/worksheet/loading/undo-loading.ts

@@ -1,12 +1,14 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { DeliveryOrder } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { LoadingWorksheetController } from '../../../../controllers'
 
 export const undoLoadingResolver = {
-  async undoLoading(_: any, { deliveryOrder, palletIds }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async undoLoading(_: any, { deliveryOrder, palletIds }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     await undoLoading(tx, domain, user, deliveryOrder, palletIds)
   }
 }