@things-factory/worksheet-base 4.3.59 → 4.3.62

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

@@ -1,54 +1,17 @@
 import { EntityManager, SelectQueryBuilder } from 'typeorm'
 
-import {
-  ORDER_STATUS, ORDER_INVENTORY_STATUS,
-  OrderInventory as OrderInventoryEntity,
-  ReleaseGood as ReleaseGoodEntity
-} from '@things-factory/sales-base'
+import { OrderInventory as OrderInventoryEntity, ReleaseGood as ReleaseGoodEntity } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { Location } from '@things-factory/warehouse-base'
 
-import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet as WorksheetEntity, WorksheetDetail as WorksheetDetailEntity } from '../../../entities'
 
 export const findReleaseOrdersByTaskNoResolver = {
   async findReleaseOrdersByTaskNo(_: 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 }
+      where: { 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')
-
-      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.`)
-      }
-    }
-
     if (!task) throw new Error('Unable to find task no.')
 
     const qb: SelectQueryBuilder<WorksheetEntity> = tx
@@ -63,9 +26,6 @@ export const findReleaseOrdersByTaskNoResolver = {
       .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')

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

@@ -0,0 +1,80 @@
+import { EntityManager, SelectQueryBuilder } from 'typeorm'
+
+import {
+    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'
+
+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 }
+        })
+
+        // 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')
+
+            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.`)
+            }
+        }
+
+        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 releaseGoods: ReleaseGoodEntity[] = await qb.getRawMany()
+        return { releaseGoods, taskNo }
+    }
+}

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

@@ -1,14 +1,14 @@
 import { User } from '@things-factory/auth-base'
-import { OrderInventory } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
+import { OrderInventory, GenerateBatchPickInfo } from '@things-factory/sales-base'
+import { Domain, ObjectRef } from '@things-factory/shell'
 import { EntityManager } from 'typeorm'
 import { PickingWorksheetController } from '../../../../controllers/'
 import { Worksheet, WorksheetDetail } from '../../../../entities'
 
 export const generateBatchPickingWorksheetResolver = {
-  async generateBatchPickingWorksheet(_: any, { releaseGoodNos, partnerBizplaceId }, context: any) {
+  async generateBatchPickingWorksheet(_: any, { releaseGoodWithBiz }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    return await generateBatchPickingWorksheet(tx, domain, user, releaseGoodNos, partnerBizplaceId)
+    return await generateBatchPickingWorksheet(tx, domain, user, releaseGoodWithBiz)
   }
 }
 
@@ -16,9 +16,8 @@ export async function generateBatchPickingWorksheet(
   tx: EntityManager,
   domain: Domain,
   user: User,
-  releaseGoodNos: [string],
-  partnerBizplaceId: string
-): Promise<Worksheet> {
+  releaseGoodWithBiz: [[GenerateBatchPickInfo]]
+): Promise<Worksheet[]> {
   const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-  return await worksheetController.generateBatchPickingWorksheet(releaseGoodNos, partnerBizplaceId)
+  return await worksheetController.generateBatchPickingWorksheet(releaseGoodWithBiz)
 }

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

@@ -11,6 +11,7 @@ import { deliveryOrderByWorksheetResolver } from './delivery-order-by-worksheet'
 import { fetchDeliveryOrderROResolver } from './fetch-delivery-order-ro'
 import { fetchSellercraftAirwayBillResolver } from './fetch-sellercraft-airway-bill'
 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'
@@ -99,6 +100,7 @@ export const Query = {
   ...myPickingAssignmentStatusResolver,
   ...recommendPutawayLocationResolver,
   ...sortingWorksheetResolver,
+  ...findSortingReleaseOrdersByTaskNoResolver,
   ...findReleaseOrdersByTaskNoResolver,
   ...fetchDeliveryOrderROResolver
 }

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

@@ -11,8 +11,11 @@ export const inventoriesByPalletResolver = {
     const { domain, user }: { domain: Domain; user: 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 +31,12 @@ export const inventoriesByPalletResolver = {
       params.filters.find(filter => filter.name === 'bizplace').relation = true
     }
 
+    const locationFilters = params.filters.find(x => x.name == 'location')
+
+    const removeLocationIndex = params.filters.findIndex(x => x.name == 'location')
+
+    params.filters.splice(removeLocationIndex, 1)
+
     const qb: SelectQueryBuilder<Inventory> = getRepository(Inventory).createQueryBuilder('iv')
     buildQuery(qb, params, context)
 
@@ -39,9 +48,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 +71,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 arrChildSortData = ['productName', 'productSKU']
+
+      const remapChildSortData = ['name', 'sku']
       const sort = (sortings || []).reduce(
-        (acc, sort) => ({
+        (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 +122,6 @@ export const inventoriesByPalletResolver = {
         })
       )
     }
-
     let [items, total] = await qb.getManyAndCount()
 
     items = await Promise.all(
@@ -116,7 +136,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/picking/fetch-and-assign-picking-task.ts

@@ -28,6 +28,7 @@ export const fetchAndAssignPickingTaskResolver = {
         .addSelect('ws.name')
         .addSelect('ws.status')
         .addSelect('ws.release_good_id')
+        .innerJoin('ws.releaseGood', 'rg')
         .where(
           '(ws.domain_id = :domain_id AND ws.type = :type AND ws.assignee_id =:assignee AND (ws.status = :status1 OR ws.status = :status2))',
           {
@@ -50,6 +51,7 @@ export const fetchAndAssignPickingTaskResolver = {
             .getQuery()
           return 'NOT EXISTS ' + subQuery
         })
+        .orderBy('"rg"."created_at"', 'ASC')
 
       worksheet = await worksheetQb.getRawOne()
 
@@ -61,6 +63,7 @@ export const fetchAndAssignPickingTaskResolver = {
           .addSelect('ws.name')
           .addSelect('ws.status')
           .addSelect('ws.release_good_id')
+          .innerJoin('ws.releaseGood', 'rg')
           .where(
             '(ws.domain_id = :domain_id AND ws.type = :type AND ws.assignee_id IS NULL AND (ws.status = :status1 OR ws.status = :status2))',
             {
@@ -82,6 +85,7 @@ export const fetchAndAssignPickingTaskResolver = {
               .getQuery()
             return 'NOT EXISTS ' + subQuery
           })
+          .orderBy('"rg"."created_at"', 'ASC')
 
         worksheet = await worksheetQb.getRawOne()
 

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

@@ -6,7 +6,7 @@ import { PickingWorksheetController } from '../../../../controllers'
 export const scanProductBatchPickingResolver = {
   async scanProductBatchPicking(
     _: any,
-    { taskNo, worksheetType, cartonId, productBarcode, inventory, binLocationName },
+    { taskNo, worksheetType, cartonId, productBarcode, inventory, binLocationName, pickingQty },
     context: any
   ) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
@@ -19,7 +19,8 @@ export const scanProductBatchPickingResolver = {
       cartonId,
       productBarcode,
       inventory,
-      binLocationName
+      binLocationName,
+      pickingQty
     )
   }
 }
@@ -33,7 +34,8 @@ export async function scanProductBatchPicking(
   cartonId: string,
   productBarcode: string,
   inventory: any,
-  binLocationName?: string
+  binLocationName?: string,
+  pickingQty?: number
 ) {
   const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
   await worksheetController.scanProductBatchPicking(
@@ -42,6 +44,7 @@ export async function scanProductBatchPicking(
     cartonId,
     productBarcode,
     inventory,
-    binLocationName
+    binLocationName,
+    pickingQty
   )
 }

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

@@ -6,7 +6,7 @@ import { PickingWorksheetController } from '../../../../controllers'
 export const scanProductPickingResolver = {
   async scanProductPicking(
     _: any,
-    { worksheetDetailName, worksheetType, productBarcode, cartonId, binLocation, serialNumber, toteNo },
+    { worksheetDetailName, worksheetType, productBarcode, cartonId, binLocation, serialNumber, toteNo, pickingQty },
     context: any
   ) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
@@ -20,7 +20,8 @@ export const scanProductPickingResolver = {
       cartonId,
       binLocation,
       serialNumber,
-      toteNo
+      toteNo,
+      pickingQty
     )
   }
 }
@@ -35,7 +36,8 @@ export async function scanProductPicking(
   cartonId: string,
   binLocation?: string,
   serialNumber?: string,
-  toteNo?: string
+  toteNo?: string,
+  pickingQty?: number
 ) {
   const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
   await worksheetController.scanProductPicking(
@@ -45,6 +47,7 @@ export async function scanProductPicking(
     cartonId,
     binLocation,
     serialNumber,
-    toteNo
+    toteNo,
+    pickingQty
   )
 }

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

@@ -100,6 +100,7 @@ export async function pickingWorksheet(
       refNo: releaseGood.refNo,
       refNo2: releaseGood.refNo2,
       refNo3: releaseGood.refNo3,
+      type: releaseGood.type,
       containerNo: shippingOrder?.containerNo,
       marketplaceStatus: releaseGood.marketplaceOrderStatus,
       shippingProvider: releaseGood.transporter,
@@ -113,10 +114,10 @@ export async function pickingWorksheet(
       const inventoryChangesCount: number = await tx.getRepository(InventoryChange).count({
         where: {
           inventory: inventory.id,
-          status:"PENDING",
-          transactionType:"MISSING"
+          status: "PENDING",
+          transactionType: "MISSING"
         },
-        relations:['inventory','product']
+        relations: ['inventory', 'product']
       })
 
       return {
@@ -138,7 +139,7 @@ export async function pickingWorksheet(
         expirationDate: inventory?.expirationDate,
         location: inventory?.location,
         relatedOrderInv: targetInventory,
-        hasMissingInventoryChanges:inventoryChangesCount > 0 ? true:false
+        hasMissingInventoryChanges: inventoryChangesCount > 0 ? true : false
       }
     })
   }

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

@@ -91,7 +91,7 @@ export const worksheetResolver = {
     }
 
     let pWorksheetPickingItemSorting = getRepository(Setting).findOne({
-      where: { domain, category: 'location', name: 'rule-for-worksheet-release-goods-item' }
+      where: { domain, category: 'location', name: 'rule-for-picking-product' }
     })
 
     if (worksheet?.arrivalNotice?.id) {
@@ -172,10 +172,12 @@ export const worksheetResolver = {
       if (sortingSetting?.value) {
         let settingValue = JSON.parse(sortingSetting.value)
         for (const key in settingValue) {
-          qbOrderInventories.addOrderBy(`location.${key}`, settingValue[key] ? 'ASC' : 'DESC')
+          qbOrderInventories.addOrderBy(`location.${key}`, settingValue[key] == 'ASC' ? 'ASC' : 'DESC')
         }
       }
 
+      qbOrderInventories.addOrderBy(`product.name`, 'ASC')
+
       let orderInventories: OrderInventory[] = await qbOrderInventories.getMany()
       worksheet.orderInventories = orderInventories
     }
@@ -204,10 +206,12 @@ export const worksheetResolver = {
       if (sortingSetting?.value) {
         let settingValue = JSON.parse(sortingSetting.value)
         for (const key in settingValue) {
-          qbOrderInventories.addOrderBy(`location.${key}`, settingValue[key] ? 'ASC' : 'DESC')
+          qbOrderInventories.addOrderBy(`location.${key}`, settingValue[key] == 'ASC' ? 'ASC' : 'DESC')
         }
       }
 
+      qbOrderInventories.addOrderBy(`product.name`, 'ASC')
+
       let orderInventories: OrderInventory[] = await qbOrderInventories.getMany()
       worksheet.orderInventories = orderInventories
 
@@ -248,6 +252,15 @@ export const worksheetResolver = {
       })
     }
 
+    if (worksheet.orderInventories) {
+      worksheet.worksheetDetails.sort(function (a, b) {
+        return (
+          worksheet.orderInventories.map(oi => oi.id).indexOf(a.targetInventory.id) -
+          worksheet.orderInventories.map(oi => oi.id).indexOf(b.targetInventory.id)
+        )
+      })
+    }
+
     if (worksheet?.returnOrder?.id) {
       worksheet.orderInventories = await getRepository(OrderInventory).find({
         where: {

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

@@ -7,6 +7,7 @@ import { generateCartonIdResolver } from './generate-carton-id'
 import { generatePalletIdResolver } from './generate-pallet-id'
 import { generatePickingWorksheetDetailsResolver } from './generate-picking-worksheet-details'
 import { generateReleaseGoodWorksheetDetailsResolver } from './generate-release-good-worksheet-details'
+import { regenerateReleaseGoodWorksheetDetailsResolver } from './regenerate-release-good-worksheet-details'
 import { updateWorksheetDetail } from './update-worksheet-detail'
 import { worksheetDetailResolver } from './worksheet-detail'
 import { worksheetDetailsResolver } from './worksheet-details'
@@ -28,5 +29,6 @@ export const Mutation = {
   ...generateBatchPickingWorksheetDetailsResolver,
   ...generateBatchPickingWorksheetDetailsByBulkResolver,
   ...generatePickingWorksheetDetailsResolver,
-  ...generateReleaseGoodWorksheetDetailsResolver
+  ...generateReleaseGoodWorksheetDetailsResolver,
+  ...regenerateReleaseGoodWorksheetDetailsResolver
 }

package/server/graphql/resolvers/worksheet-detail/regenerate-release-good-worksheet-details.ts

@@ -0,0 +1,164 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Product } from '@things-factory/product-base'
+import {
+  ORDER_INVENTORY_STATUS,
+  ORDER_PRODUCT_STATUS,
+  OrderInventory,
+  OrderNoGenerator,
+  OrderProduct
+} from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
+import { Worksheet, WorksheetDetail } from '../../../entities'
+import { WorksheetNoGenerator } from '../../../utils'
+
+export const regenerateReleaseGoodWorksheetDetailsResolver = {
+  async regenerateReleaseGoodWorksheetDetails(
+    _: any,
+    { worksheetNo, batchId, productId, packingType, packingSize, orderProductId, worksheetDetails },
+    context: any
+  ): Promise<void> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    return await regenerateReleaseGoodWorksheetDetails(
+      tx,
+      domain,
+      user,
+      worksheetNo,
+      batchId,
+      productId,
+      packingType,
+      packingSize,
+      orderProductId,
+      worksheetDetails
+    )
+  }
+}
+
+export async function regenerateReleaseGoodWorksheetDetails(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  worksheetNo: string,
+  batchId: string,
+  productId: string,
+  packingType: string,
+  packingSize: number,
+  orderProductId: string,
+  worksheetDetails: Partial<WorksheetDetail>[]
+): Promise<void> {
+  // 1. Remove prev worksheet details if it's exists
+  const worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+    where: { name: worksheetNo, domain },
+    relations: [
+      'bizplace',
+      'releaseGood',
+      'worksheetDetails',
+      'worksheetDetails.targetInventory',
+      'worksheetDetails.targetInventory.inventory',
+      'worksheetDetails.targetInventory.product',
+      'worksheetDetails.targetInventory.releaseGood',
+      'worksheetDetails.targetInventory.orderProduct',
+      'worksheetDetails.targetInventory.bizplace'
+    ]
+  })
+
+  const prevWSDs: WorksheetDetail[] = worksheet.worksheetDetails.filter((wsd: WorksheetDetail) => {
+    const targetInv: OrderInventory = wsd.targetInventory
+    if (targetInv.orderProductId === orderProductId) return wsd.id
+  })
+
+  // TODO: Update prev inventory locked qty and delete order inventories
+  if (prevWSDs?.length) {
+    const wsdIds: string[] = prevWSDs.map((wsd: WorksheetDetail) => wsd.id)
+    const prevOrderInvIds: string[] = prevWSDs.map((wsd: WorksheetDetail) => wsd.targetInventory.id)
+    const prevOrderInventories: OrderInventory[] = prevWSDs.map((wsd: WorksheetDetail) => wsd.targetInventory)
+    await Promise.all(
+      prevOrderInventories.map(async prevOI => {
+        if (prevOI?.inventory) {
+          await tx.getRepository(Inventory).update(
+            { id: prevOI.inventory.id },
+            {
+              lockedQty: prevOI.inventory.lockedQty - prevOI.releaseQty,
+              lockedUomValue: prevOI.inventory.lockedUomValue - prevOI.releaseUomValue
+            }
+          )
+        }
+      })
+    )
+
+    await tx.getRepository(WorksheetDetail).delete(wsdIds)
+    await tx.getRepository(OrderInventory).delete(prevOrderInvIds)
+  }
+
+  await Promise.all(
+    worksheetDetails.map(async (wsd: WorksheetDetail) => {
+      // 2. Create order inventory
+      let targetInventory: OrderInventory = wsd.targetInventory
+      const inventory: Inventory = await tx.getRepository(Inventory).findOne(targetInventory.inventory.id)
+
+      let targetProduct: OrderProduct = await tx
+        .getRepository(OrderProduct)
+        .findOne({ where: { id: wsd.targetProduct.id }, relations: ['releaseGood'] })
+
+      targetInventory = await tx.getRepository(OrderInventory).save({
+        ...targetInventory,
+        domain,
+        bizplace: worksheet.bizplace,
+        name: OrderNoGenerator.orderInventory(),
+        releaseGood: worksheet.type == WORKSHEET_TYPE.BATCH_PICKING ? targetProduct.releaseGood : worksheet.releaseGood,
+        inventory,
+        batchId: inventory.batchId,
+        batchIdRef: inventory.batchIdRef,
+        status: ORDER_INVENTORY_STATUS.READY_TO_PICK,
+        product: await tx.getRepository(Product).findOne(productId),
+        packingType,
+        packingSize,
+        orderProduct: targetProduct,
+        refWorksheetId: worksheet.type == WORKSHEET_TYPE.BATCH_PICKING ? worksheet.id : null,
+        creator: user,
+        updater: user
+      })
+
+      const currentLockedQty: any = inventory.lockedQty
+      const currentLockedUomValue: any = inventory.lockedUomValue
+
+      await tx.getRepository(Inventory).save({
+        ...targetInventory.inventory,
+        lockedQty: Boolean(currentLockedQty)
+          ? targetInventory.releaseQty + currentLockedQty
+          : targetInventory.releaseQty,
+        lockedUomValue: Boolean(currentLockedUomValue)
+          ? targetInventory.releaseUomValue + currentLockedUomValue
+          : targetInventory.releaseUomValue,
+        updater: user
+      })
+
+      // update order product status to ASSIGNED
+      await tx
+        .getRepository(OrderProduct)
+        .update({ id: targetProduct.id }, { status: ORDER_PRODUCT_STATUS.ASSIGNED, updater: user })
+
+      // 3. Create worksheet details
+      await tx.getRepository(WorksheetDetail).save({
+        ...wsd,
+        domain,
+        bizplace: worksheet.bizplace,
+        worksheet,
+        name:
+          worksheet.type == WORKSHEET_TYPE.BATCH_PICKING
+            ? WorksheetNoGenerator.batchPickingDetail()
+            : WorksheetNoGenerator.pickingDetail(),
+        targetProduct,
+        targetInventory,
+        type: worksheet.type == WORKSHEET_TYPE.BATCH_PICKING ? WORKSHEET_TYPE.BATCH_PICKING : WORKSHEET_TYPE.PICKING,
+        status: WORKSHEET_STATUS.DEACTIVATED,
+        creator: user,
+        updater: user
+      })
+    })
+  )
+}

package/server/graphql/types/worksheet/batch-pick-worksheet-info.ts

@@ -0,0 +1,9 @@
+import { gql } from 'apollo-server-koa'
+
+export const GenerateBatchPickInfo = gql`
+  input GenerateBatchPickInfo {
+    releaseGoodNo: String
+    bizplaceId: String
+    bizplaceName: String
+  }
+`