@things-factory/worksheet-base 4.3.113-alpha.0 → 4.3.114

package/server/controllers/vas/vas-worksheet-controller.ts

@@ -22,8 +22,7 @@ import {
   InventoryNoGenerator,
   Location,
   LOCATION_TYPE,
-  Warehouse,
-  generateInventoryHistory
+  Warehouse
 } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../constants'
@@ -37,6 +36,7 @@ import {
   RefOrderType
 } from '../../graphql/resolvers/worksheet/vas-transactions'
 import { PackingUnits } from '../../graphql/resolvers/worksheet/vas-transactions/interfaces/repackaging'
+import { generateInventoryHistory } from '../../utils'
 import { ReferenceOrderType, WorksheetController } from '../worksheet-controller'
 
 type CompleteTransactionType = (trxMgr: EntityManager, orderVas: OrderVas, user: User) => Promise<void>

package/server/controllers/worksheet-controller.ts

@@ -19,17 +19,11 @@ import {
   VasOrder
 } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import {
-  Inventory,
-  INVENTORY_STATUS,
-  InventoryItem,
-  Pallet,
-  generateInventoryHistory
-} from '@things-factory/warehouse-base'
+import { Inventory, INVENTORY_STATUS, InventoryItem, Pallet } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../constants'
 import { Worksheet, WorksheetDetail } from '../entities'
-import { WorksheetNoGenerator } from '../utils'
+import { generateInventoryHistory, WorksheetNoGenerator } from '../utils'
 
 export type ReferenceOrderType = ArrivalNotice | ReleaseGood | VasOrder | InventoryCheck | DeliveryOrder | ReturnOrder
 export type OrderTargetTypes = OrderProduct | OrderInventory | OrderVas
@@ -1012,9 +1006,11 @@ export class WorksheetController {
   async getChildQty(
     productDetails: ProductDetail[],
     productBarcode: string,
-    orderProductDetail: ProductDetail,
-    scannedProductDetail: ProductDetail
+    orderProductDetail: ProductDetail
   ): Promise<number> {
+    const scannedProductDetail: ProductDetail = productDetails.find(
+      (productDetail: ProductDetail) => productDetail.gtin === productBarcode
+    )
     let hasChildRelation: boolean = Boolean(scannedProductDetail?.childProductDetail)
     let hasMatchingChild: boolean
     let childQty: number
@@ -1063,11 +1059,12 @@ export class WorksheetController {
       let results = await this.trxMgr.query(
         `
         WITH RECURSIVE cte as (
-          select * from (
-            select pd.product_id as "productId", id, pd.packing_size as "packingSize",
-            pd.packing_type as "packingType", pd.uom as "uom", (pd.uom_value * $2::float) as "uomValue", $2::float as "qty", pd.gtin            
-            from product_details pd 
-            where pd.id = $1
+        select * from (
+          select pd2.product_id as "productId", pd2.id, pd2.packing_size as "packingSize",
+          pd2.packing_type as "packingType", pd2.uom as "uom", (pd2.uom_value * $2::float) as "uomValue", $2::float as "qty", pd2.gtin            
+          from product_details pd 
+          inner join product_details pd2 on pd.product_id = pd2.product_id and pd.packing_type = pd2.packing_type and pd.packing_size = pd2.packing_size and pd.uom = pd2.uom
+          where pd.id = $1
           ) as dt
           union all
           select pd.product_id as "productId", pd.id, pd.packing_size as "packingSize",

package/server/entities/index.ts

@@ -1,8 +1,8 @@
-import { WarehouseBizplaceOnhandInventory } from './warehouse-bizplace-onhand-inventory'
 import { Worksheet } from './worksheet'
 import { WorksheetDetail } from './worksheet-detail'
 import { WorksheetMovement } from './worksheet-movement'
+import { WarehouseBizplaceOnhandInventory } from './warehouse-bizplace-onhand-inventory'
 
 export const entities = [Worksheet, WorksheetDetail, WorksheetMovement, WarehouseBizplaceOnhandInventory]
 
-export { WarehouseBizplaceOnhandInventory, Worksheet, WorksheetDetail, WorksheetMovement }
+export { Worksheet, WorksheetDetail, WorksheetMovement }

package/server/entities/warehouse-bizplace-onhand-inventory.ts

@@ -2,23 +2,55 @@ import { ViewColumn, ViewEntity } from 'typeorm'
 
 @ViewEntity({
   expression: `  
-  select d.name as "domain_name", b.name as "bizplace_name", src.* from (
+  select d.name as "domainName", b.name as "bizplaceName", src.* from (
+    WITH oi as (
+      select
+        oi.domain_id,
+        oi.bizplace_id,
+        SUM(oi.release_qty) AS release_qty,
+        SUM(oi.release_uom_value) AS release_uom_value,
+        oi.batch_id,
+        oi.batch_id_ref,
+        oi.product_id,
+        oi.packing_type,
+        oi.packing_size,
+        oi.uom
+      FROM
+        order_inventories oi
+      WHERE
+        (oi.status = 'PENDING' or oi.status = 'PENDING_RECEIVE' or oi.status = 'PENDING_WORKSHEET' or oi.status = 'PENDING_SPLIT')
+        AND oi.batch_id NOTNULL
+        AND oi.product_id NOTNULL
+        AND oi.packing_type NOTNULL
+        AND oi.packing_size NOTNULL
+        AND oi.inventory_id IS NULL
+      GROUP BY
+        oi.domain_id,
+        oi.bizplace_id,
+        oi.batch_id,
+        oi.batch_id_ref,
+        oi.product_id,
+        oi.packing_type,
+        oi.packing_size,
+        oi.uom
+    ) 
     -- SINGLE ITEM INVENTORY QUERY
     select
-    i.domain_id as "domain_id",
-    i.bizplace_id as "bizplace_id",
-    i.packing_type as "packing_type",
-    i.packing_size as "packing_size",
+    i.domain_id as "domainId",
+    i.bizplace_id as "bizplaceId",
+    i.packing_type as "packingType",
+    i.packing_size as "packingSize",
     i.uom,
-    i.product_id as "product_id",
-    null as "product_bundle_id",
-    COALESCE(SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0))) AS "remain_qty",
-    COALESCE(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0))) AS "remain_uom_value",
+    i.product_id as "productId",
+    null as "productBundleId",
+    COALESCE(SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0))) AS "remainQty",
+    COALESCE(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)), 0) AS "remainUomValue",
     COALESCE(sum(COALESCE(i.qty, 0::double precision))) AS "qty",
-    COALESCE(sum(COALESCE(i.uom_value, 0::double precision))) AS "uom_value",
-    'SINGLE' AS "group_type"
+    COALESCE(sum(COALESCE(i.uom_value, 0::double precision))) AS "uomValue",
+    'SINGLE' AS "groupType"
     FROM inventories i
     INNER JOIN locations l2 ON i.location_id = l2.id AND i.domain_id = l2.domain_id AND l2.type NOT IN ('QUARANTINE', 'RESERVE')
+    LEFT JOIN oi ON i.batch_id = oi.batch_id AND i.product_id = oi.product_id AND i.packing_type = oi.packing_type AND i.packing_size = oi.packing_size AND i.uom = oi.uom
     WHERE i.status = 'STORED'
     GROUP by
       i.domain_id,
@@ -30,28 +62,29 @@ import { ViewColumn, ViewEntity } from 'typeorm'
     union all
     -- BUNDLE ITEM INVENTORY QUERY
     SELECT 
-    pbs.domain_id as "domain_id",
-    pbs.bizplace_id as "bizplace_id",
-    pb.packing_type as "packing_type", 
-    pb.packing_size as "packing_size",
+    pbs.domain_id as "domainId",
+    pbs.bizplace_id as "bizplaceId",
+    pb.packing_type as "packingType", 
+    pb.packing_size as "packingSize",
     'UNIT' AS "uom", 
-    null as "product_id",
-    pb.id AS "product_bundle_id",
-    COALESCE(MIN(FLOOR(pbs."available_qty")),0) AS "remain_qty", 
-    COALESCE(MIN(FLOOR(pbs."available_uom_value")),0) AS "remain_uom_value",
+    null as "productId",
+    pb.id AS "productBundleId",
+    COALESCE(MIN(FLOOR(pbs."availableQty")),0) AS "remainQty", 
+    COALESCE(MIN(FLOOR(pbs."availableUomValue")),0) AS "remainUomValue",
     COALESCE(MIN(FLOOR(pbs."qty")), 0::double precision) AS "qty",
-    COALESCE(MIN(FLOOR(pbs."uom_value")), 0::double precision) AS "uom_value",
-    'BUNDLE' AS "group_type"
+    COALESCE(MIN(FLOOR(pbs."uomValue")), 0::double precision) AS "uomValue",
+    'BUNDLE' AS "groupType"
     FROM product_bundles pb
     INNER JOIN (
       SELECT i.domain_id, i.bizplace_id, pbs.product_id, pbs.product_bundle_id, min(pbs.bundle_qty),
-      (SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0))) / min(pbs.bundle_qty) AS "available_qty",
-      (SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0))) / min(pbs.bundle_qty)  AS "available_uom_value",
+      (SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0))) / min(pbs.bundle_qty) AS "availableQty",
+      (SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0))) / min(pbs.bundle_qty)  AS "availableUomValue",
       (sum(COALESCE(i.qty, 0::double precision))) / min(pbs.bundle_qty)::double precision AS "qty",
-      (sum(COALESCE(i.uom_value, 0::double precision))) / min(pbs.bundle_qty)::double precision AS "uom_value"
+      (sum(COALESCE(i.uom_value, 0::double precision))) / min(pbs.bundle_qty)::double precision AS "uomValue"
       FROM product_bundle_settings pbs 
       LEFT JOIN inventories i ON i.product_id = pbs.product_id AND i.status = 'STORED'
-      INNER JOIN locations l ON i.location_id = l.id AND i.domain_id = l.domain_id AND l.type NOT IN ('QUARANTINE', 'RESERVE') 
+      INNER JOIN locations l ON i.location_id = l.id AND i.domain_id = l.domain_id AND l.type NOT IN ('QUARANTINE', 'RESERVE')    
+      LEFT JOIN oi ON oi.product_id = i.product_id
       GROUP by
         i.domain_id, 
         i.bizplace_id,
@@ -68,13 +101,14 @@ import { ViewColumn, ViewEntity } from 'typeorm'
     pb.id
   )
   AS src 
-  inner join domains d on d.id = src."domain_id"
-  inner join bizplaces b on b.id = src."bizplace_id"
-  where src."remain_qty" >= 0
+  inner join domains d on d.id = src."domainId"
+  inner join bizplaces b on b.id = src."bizplaceId"
+  where src."remainQty" >= 0
   and src."qty" > 0
-  order by src."domain_id"
+  order by src."domainId"
   `
 })
+
 export class WarehouseBizplaceOnhandInventory {
   @ViewColumn()
   domainName: string

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

@@ -32,7 +32,6 @@ export const batchPickingWorksheetResolver = {
       .addSelect('"PROD".name', 'productName')
       .addSelect('"PROD".sku', 'productSku')
       .addSelect('"PROD".description', 'productDescription')
-      .addSelect('"PROD_DET".id', 'productDetailId')
       .addSelect('"INV".qty', 'qty')
       .addSelect('"INV".packing_type', 'packingType')
       .addSelect('"INV".packing_size', 'packingSize')
@@ -48,7 +47,6 @@ export const batchPickingWorksheetResolver = {
       .leftJoin('WSD.targetInventory', 'T_INV')
       .leftJoin('T_INV.inventory', 'INV')
       .leftJoin('T_INV.product', 'PROD')
-      .leftJoin('T_INV.productDetail', 'PROD_DET')
       .leftJoin('T_INV.binLocation', 'BIN_LOC')
       .leftJoin('INV.location', 'LOC')
       .where('"WSD"."worksheet_id" = :worksheetId', { worksheetId: worksheet.id })
@@ -66,7 +64,6 @@ export const batchPickingWorksheetResolver = {
       .addGroupBy('"PROD".name')
       .addGroupBy('"PROD".sku')
       .addGroupBy('"PROD".description')
-      .addGroupBy('"PROD_DET".id')
       .addGroupBy('"T_INV".batch_id')
       .addGroupBy('"T_INV".packing_type')
       .addGroupBy('BIN_LOC.name')
@@ -129,9 +126,6 @@ export const batchPickingWorksheetResolver = {
               name: item?.productName,
               description: item?.productDescription,
               sku: item?.productSku
-            },
-            productDetail: {
-              id: item?.productDetailId
             }
           }
         }

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

@@ -1,6 +1,8 @@
 import { EntityManager, In } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
+// import { logger } from '@things-factory/env'
+// import { Account, AccountingAPI } from '@things-factory/integration-accounting'
 import {
   DeliveryOrder,
   ORDER_INVENTORY_STATUS,
@@ -11,9 +13,10 @@ import {
   ReleaseGood
 } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { Inventory, INVENTORY_STATUS, INVENTORY_TRANSACTION_TYPE, Location, generateInventoryHistory } from '@things-factory/warehouse-base'
+import { Inventory, INVENTORY_STATUS, INVENTORY_TRANSACTION_TYPE, Location } from '@things-factory/warehouse-base'
 
 import { Worksheet, WorksheetDetail } from '../../../entities'
+import { generateInventoryHistory } from '../../../utils'
 
 export const confirmCancellationReleaseOrder = {
   async confirmCancellationReleaseOrder(_: any, { name }, context: any) {
@@ -22,9 +25,13 @@ export const confirmCancellationReleaseOrder = {
       where: { domain, name, status: ORDER_STATUS.PENDING_CANCEL },
       relations: [
         'bizplace',
+        'bizplace.domain',
+        'orderProducts',
         'orderInventories',
         'orderInventories.inventory',
         'orderInventories.inventory.location',
+        'orderInventories.inventory.product',
+        'orderInventories.inventory.productDetail',
         'orderVass'
       ]
     })
@@ -189,6 +196,41 @@ export const confirmCancellationReleaseOrder = {
     releaseGood.updater = user
     await tx.getRepository(ReleaseGood).save(releaseGood)
 
+    // if (releaseGood?.refNo3 && releaseGood?.type == 'b2c') {
+    //   const account: Account = await tx
+    //     .getRepository(Account)
+    //     .findOne({ domain: releaseGood.bizplace.domain, status: 'active' })
+
+    //   // Xilnex create shipment and create sales return if sales invoice is completed
+    //   const createSalesReturn = async account => {
+    //     if (account) {
+    //       await getManager().transaction(async txMgr => {
+    //         if (account.platform == 'xilnex') {
+    //           try {
+    //             await AccountingAPI.createShipment(account, {
+    //               releaseGood,
+    //               orderProducts: releaseGood.orderProducts
+    //             })
+    //           } catch (error) {
+    //             logger.error(`confirm-cancellation-release-order[createShipment]: ${error}`)
+    //           }
+
+    //           try {
+    //             await AccountingAPI.createSalesReturn(account, {
+    //               releaseGood,
+    //               orderProducts: releaseGood.orderProducts
+    //             })
+    //           } catch (error) {
+    //             logger.error(`confirm-cancellation-release-order[createSalesReturn]: ${error}`)
+    //           }
+    //         }
+    //       })
+    //     }
+    //   }
+
+    //   createSalesReturn(account)
+    // }
+
     return
   }
 }

package/server/graphql/resolvers/worksheet/cycle-count-adjustment.ts

@@ -4,12 +4,12 @@ import { User } from '@things-factory/auth-base'
 import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
 import { InventoryCheck, ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { Inventory, INVENTORY_STATUS, INVENTORY_TRANSACTION_TYPE, Location, generateInventoryHistory } from '@things-factory/warehouse-base'
+import { Inventory, INVENTORY_STATUS, INVENTORY_TRANSACTION_TYPE, Location } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { SellercraftController } from '../../../controllers'
 import { Worksheet, WorksheetDetail } from '../../../entities'
-import { switchLocationStatus } from '../../../utils'
+import { generateInventoryHistory, switchLocationStatus } from '../../../utils'
 
 export const cycleCountAdjustmentResolver = {
   async cycleCountAdjustment(_: any, { cycleCountNo }, context: any) {

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

@@ -33,6 +33,7 @@ export const cycleCountWorksheetResolver = {
       .leftJoinAndSelect('INV.location', 'LOC')
       .leftJoinAndSelect('INV.product', 'PROD')
       .leftJoinAndSelect('LOC.warehouse', 'WH')
+      .leftJoinAndSelect('INS_LOC.warehouse', 'INS_WH')
 
     if (locationSortingRules?.length > 0) {
       locationSortingRules.forEach((rule: { name: string; desc: boolean }) => {

package/server/graphql/resolvers/worksheet/find-sorting-release-orders-by-task-no.ts

@@ -1,10 +1,10 @@
 import { EntityManager, SelectQueryBuilder } from 'typeorm'
 
 import {
-    ORDER_INVENTORY_STATUS,
-    ORDER_STATUS,
-    OrderInventory as OrderInventoryEntity,
-    ReleaseGood as ReleaseGoodEntity
+  ORDER_INVENTORY_STATUS,
+  ORDER_STATUS,
+  OrderInventory as OrderInventoryEntity,
+  ReleaseGood as ReleaseGoodEntity
 } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Location } from '@things-factory/warehouse-base'
@@ -13,68 +13,68 @@ import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet as WorksheetEntity, WorksheetDetail as WorksheetDetailEntity } from '../../../entities'
 
 export const findSortingReleaseOrdersByTaskNoResolver = {
-    async findSortingReleaseOrdersByTaskNo(_: any, { taskNo }, context: any) {
-        const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
-        let task = await tx.getRepository(WorksheetEntity).findOne({
-            where: { taskNo, status: WORKSHEET_STATUS.EXECUTING, type: WORKSHEET_TYPE.SORTING }
-        })
+  async findSortingReleaseOrdersByTaskNo(_: any, { taskNo }, context: any) {
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+    let task = await tx.getRepository(WorksheetEntity).findOne({
+      where: { taskNo, status: WORKSHEET_STATUS.EXECUTING, type: WORKSHEET_TYPE.SORTING }
+    })
 
-        // Find Task based on Bin
-        if (!task) {
-            const binLocation: Location = await tx.getRepository(Location).findOne({
-                where: { domain, name: taskNo }
-            })
+    // Find Task based on Bin
+    if (!task) {
+      const binLocation: Location = await tx.getRepository(Location).findOne({
+        where: { domain, name: taskNo }
+      })
 
-            const qb: SelectQueryBuilder<OrderInventoryEntity> = tx
-                .getRepository(OrderInventoryEntity)
-                .createQueryBuilder('orderInventory')
+      const qb: SelectQueryBuilder<OrderInventoryEntity> = tx
+        .getRepository(OrderInventoryEntity)
+        .createQueryBuilder('orderInventory')
 
-            qb.innerJoinAndSelect('orderInventory.releaseGood', 'releaseGood')
-                .innerJoinAndSelect('worksheets', 'ws', `orderInventory.ref_worksheet_id = ws.id AND ws.type = 'BATCH_PICKING'`)
-                .innerJoinAndSelect('worksheets', 'ws2', `ws2.task_no = ws.task_no AND ws2.type = 'SORTING'`)
-                .innerJoinAndSelect('releaseGood.bizplace', 'bizplace')
-                .innerJoinAndSelect('bizplace.domain', 'domain')
-                .where('orderInventory.domain_id = :domainId', { domainId: domain.id })
-                .andWhere('orderInventory.status IN (:...orderInventoryStatus)', {
-                    orderInventoryStatus: [ORDER_INVENTORY_STATUS.SORTING]
-                })
-                .andWhere('orderInventory.bin_location_id = :locationId', { locationId: binLocation.id })
-                .andWhere('releaseGood.status = :status', { status: ORDER_STATUS.SORTING })
+      qb.innerJoinAndSelect('orderInventory.releaseGood', 'releaseGood')
+        .innerJoinAndSelect('worksheets', 'ws', `orderInventory.ref_worksheet_id = ws.id AND ws.type = 'BATCH_PICKING'`)
+        .innerJoinAndSelect('worksheets', 'ws2', `ws2.task_no = ws.task_no AND ws2.type = 'SORTING'`)
+        .innerJoinAndSelect('releaseGood.bizplace', 'bizplace')
+        .innerJoinAndSelect('bizplace.domain', 'domain')
+        .where('orderInventory.domain_id = :domainId', { domainId: domain.id })
+        .andWhere('orderInventory.status IN (:...orderInventoryStatus)', {
+          orderInventoryStatus: [ORDER_INVENTORY_STATUS.SORTING]
+        })
+        .andWhere('orderInventory.bin_location_id = :locationId', { locationId: binLocation.id })
+        .andWhere('releaseGood.status = :status', { status: ORDER_STATUS.SORTING })
 
-            const orderInventoryByBin = await qb.getRawOne()
-            if (orderInventoryByBin?.releaseGood_id) {
-                taskNo = orderInventoryByBin.ws_task_no
-                task = await tx.getRepository(WorksheetEntity).findOne({
-                    where: { taskNo, status: WORKSHEET_STATUS.EXECUTING, type: WORKSHEET_TYPE.SORTING }
-                })
-            } else {
-                throw new Error(`Bin do not have any batch picking order.`)
-            }
-        }
+      const orderInventoryByBin = await qb.getRawOne()
+      if (orderInventoryByBin?.releaseGood_id) {
+        taskNo = orderInventoryByBin.ws_task_no
+        task = await tx.getRepository(WorksheetEntity).findOne({
+          where: { taskNo, status: WORKSHEET_STATUS.EXECUTING, type: WORKSHEET_TYPE.SORTING }
+        })
+      } else {
+        throw new Error(`Bin do not have any batch picking order.`)
+      }
+    }
 
-        if (!task) throw new Error('Unable to find task no.')
+    if (!task) throw new Error('Unable to find task no.')
 
-        const qb: SelectQueryBuilder<WorksheetEntity> = tx
-            .getRepository(WorksheetEntity)
-            .createQueryBuilder('ws')
-            .select('rg.id as id')
-            .addSelect('rg.name as name')
-            .addSelect('rg.status as status')
-            .innerJoin(Domain, 'domain', 'ws.domain_id = domain.id')
-            .innerJoin(WorksheetDetailEntity, 'wsd', 'ws.id = wsd.worksheet_id')
-            .innerJoin(OrderInventoryEntity, 'oi', 'oi.id = wsd.target_inventory_id')
-            .innerJoin(ReleaseGoodEntity, 'rg', 'rg.id = oi.release_good_id')
-            .where('domain.id = :domainId', { domainId: domain.id })
-            .andWhere('ws.taskNo = :taskNo', { taskNo: taskNo })
-            .andWhere('ws.type = :worksheetType', { worksheetType: WORKSHEET_TYPE.SORTING })
-            .andWhere('ws.status = :worksheetStatus', { worksheetStatus: WORKSHEET_STATUS.EXECUTING })
-            .andWhere('rg.status = :roStatus', { roStatus: ORDER_STATUS.SORTING })
-            .groupBy('rg.id')
-            .addGroupBy('rg.name')
-            .addGroupBy('rg.status')
-            .orderBy('rg.createdAt', 'ASC')
+    const qb: SelectQueryBuilder<WorksheetEntity> = tx
+      .getRepository(WorksheetEntity)
+      .createQueryBuilder('ws')
+      .select('rg.id as id')
+      .addSelect('rg.name as name')
+      .addSelect('rg.status as status')
+      .innerJoin(Domain, 'domain', 'ws.domain_id = domain.id')
+      .innerJoin(WorksheetDetailEntity, 'wsd', 'ws.id = wsd.worksheet_id')
+      .innerJoin(OrderInventoryEntity, 'oi', 'oi.id = wsd.target_inventory_id')
+      .innerJoin(ReleaseGoodEntity, 'rg', 'rg.id = oi.release_good_id')
+      .where('domain.id = :domainId', { domainId: domain.id })
+      .andWhere('ws.taskNo = :taskNo', { taskNo: taskNo })
+      .andWhere('ws.type = :worksheetType', { worksheetType: WORKSHEET_TYPE.SORTING })
+      .andWhere('ws.status = :worksheetStatus', { worksheetStatus: WORKSHEET_STATUS.EXECUTING })
+      .andWhere('rg.status = :roStatus', { roStatus: ORDER_STATUS.SORTING })
+      .groupBy('rg.id')
+      .addGroupBy('rg.name')
+      .addGroupBy('rg.status')
+      .orderBy('rg.createdAt', 'ASC')
 
-        const releaseGoods: ReleaseGoodEntity[] = await qb.getRawMany()
-        return { releaseGoods, taskNo }
-    }
-}
+    const releaseGoods: ReleaseGoodEntity[] = await qb.getRawMany()
+    return { releaseGoods, taskNo }
+  }
+}

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

@@ -40,7 +40,6 @@ export const inventoriesByPalletResolver = {
     qb.leftJoinAndSelect('iv.domain', 'domain')
       .leftJoinAndSelect('iv.bizplace', 'bizplace')
       .leftJoinAndSelect('iv.product', 'product')
-      .leftJoinAndSelect('iv.productDetail', 'productDetail')
       .leftJoinAndSelect('iv.warehouse', 'warehouse')
       .leftJoinAndSelect('iv.location', 'location')
       .leftJoinAndSelect('iv.creator', 'creator')
@@ -135,8 +134,7 @@ export const inventoriesByPalletResolver = {
           productName: item.product.name,
           productSKU: item.product.sku,
           productBrand: item.product.brand,
-          productId: item.product.id,
-          productDetailId: item.productDetail.id
+          productId: item.product.id
         }
       })
     )

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

@@ -14,7 +14,7 @@ import { PartnerSetting, Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, Location } from '@things-factory/warehouse-base'
 
-import { WORKSHEET_TYPE, WORKSHEET_STATUS } from '../../../constants'
+import { WORKSHEET_TYPE } from '../../../constants'
 import { PackingWorksheetController, SellercraftController } from '../../../controllers'
 import { Worksheet, WorksheetDetail } from '../../../entities'
 
@@ -104,9 +104,7 @@ export const packingWorksheetResolver = {
 
       if (!worksheet) throw new Error('Worksheet does not exist')
 
-      if (worksheet.status === WORKSHEET_STATUS.DONE) {
-        throw new Error(`Worksheet is completed already`)
-      } else if (worksheet.status === WORKSHEET_STATUS.DEACTIVATED) {
+      if (worksheet.status === 'DEACTIVATED') {
         const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
 
         const directActivatePackingWorksheet: Setting = await tx.getRepository(Setting).findOne({

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

@@ -93,9 +93,9 @@ export async function completeBatchPicking(
           break
 
         case ApplicationType.MMS:
-          const companyDomain: Domain = releaseGood.bizplace.company.domain
+          const companyDomain: Domain = foundReleaseGood.bizplace.company.domain
           const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-            where: { orderNo: releaseGood.refNo, domain: companyDomain },
+            where: { orderNo: foundReleaseGood.refNo, domain: companyDomain },
             relations: [
               'marketplaceOrderItems',
               'marketplaceOrderItems.marketplaceOrderShippingItems',
@@ -108,7 +108,7 @@ export async function completeBatchPicking(
 
           if (marketplaceStore?.isAutoUpdateShipment) {
             const ecommerceCtrl: EcommerceController = new EcommerceController(tx, domain, user)
-            await ecommerceCtrl.createOrderShip(releaseGood, marketplaceStore, marketplaceOrder, companyDomain)
+            await ecommerceCtrl.createOrderShip(foundReleaseGood, marketplaceStore, marketplaceOrder, companyDomain)
           }
           break
 

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

@@ -2,6 +2,8 @@ import { EntityManager, getManager } from 'typeorm'
 
 import { ApplicationType, User } from '@things-factory/auth-base'
 import { Bizplace, ContactPoint, getMyBizplace } from '@things-factory/biz-base'
+// import { logger } from '@things-factory/env'
+// import { Account, AccountingAPI } from '@things-factory/integration-accounting'
 import { LastMileAPI, LastMileDelivery } from '@things-factory/integration-lmd'
 import { MarketplaceStore, MarketplaceTransporter } from '@things-factory/integration-marketplace'
 import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
@@ -57,7 +59,15 @@ export async function completePicking(
   const pickingWSCtrl: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
   let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
     where: { domain, name: releaseGoodNo },
-    relations: ['bizplace', 'bizplace.domain', 'bizplace.company', 'bizplace.company.domain']
+    relations: [
+      'bizplace',
+      'bizplace.domain',
+      'bizplace.company',
+      'bizplace.company.domain',
+      'orderProducts',
+      'orderProducts.product',
+      'orderProducts.productDetail'
+    ]
   })
 
   const worksheet: Worksheet = await pickingWSCtrl.findWorksheetByRefOrder(releaseGood, WORKSHEET_TYPE.PICKING, [
@@ -238,6 +248,52 @@ export async function completePicking(
       break
   }
 
+  // const account: Account = await tx
+  //   .getRepository(Account)
+  //   .findOne({ domain: releaseGood.bizplace.domain, status: 'active' })
+
+  // // Xilnex Create Sales Order and Post Sales Order to Sales Invoice
+  // const createSalesOrder = async account => {
+  //   if (account) {
+  //     try {
+  //       await getManager().transaction(async txMgr => {
+  //         if (account.platform == 'xilnex') {
+  //           const salesOrder: any = await AccountingAPI.createSalesOrder(account, {
+  //             releaseGood,
+  //             orderProducts: releaseGood.orderProducts
+  //           })
+
+  //           if (salesOrder) {
+  //             const salesInvoice: any = await AccountingAPI.postSalesOrderToSalesInvoice(account, {
+  //               orderId: salesOrder?.id || null
+  //             })
+
+  //             const salesOrderItems: any = salesInvoice.sale.items
+  //             await Promise.all(
+  //               releaseGood.orderProducts.map(async op => {
+  //                 const matchedProduct: any = salesOrderItems.find(soi => soi.itemId == op.productDetail.refCode)
+  //                 if (matchedProduct) {
+  //                   await tx.getRepository(OrderProduct).update({ id: op.id }, { refItemId: matchedProduct.id })
+  //                 }
+  //               })
+  //             )
+
+  //             await txMgr
+  //               .getRepository(ReleaseGood)
+  //               .update({ id: releaseGood.id }, { refNo3: salesInvoice.salesId, updater: releaseGood.updater })
+  //           }
+  //         }
+  //       })
+  //     } catch (error) {
+  //       logger.error(`complete-picking[createSalesOrder]: ${error}`)
+  //     }
+  //   }
+  // }
+
+  // if (releaseGood.type == 'b2c') {
+  //   createSalesOrder(account)
+  // }
+
   if (releaseGood.packingOption) {
     const packingWSCtrl: PackingWorksheetController = new PackingWorksheetController(tx, domain, user)
     await packingWSCtrl.generatePackingWorksheet(releaseGoodNo)