@things-factory/worksheet-base 5.0.0-alpha.5 → 5.0.0-alpha.52

package/server/controllers/render-ro-do.ts

@@ -1,3 +1,4 @@
+import _ from 'lodash'
 import FormData from 'form-data'
 import fetch from 'node-fetch'
 import { Equal, getRepository, In } from 'typeorm'
@@ -10,9 +11,10 @@ import { ProductDetail } from '@things-factory/product-base'
 import { DeliveryOrder, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, Pallet } from '@things-factory/warehouse-base'
-
+import { InventoryItem } from '@things-factory/warehouse-base'
 import { TEMPLATE_TYPE, WORKSHEET_STATUS, WORKSHEET_TYPE } from '../constants'
 import { Worksheet, WorksheetDetail } from '../entities'
+import { DateTimeConverter } from '../utils/datetime-util'
 
 const REPORT_API_URL = config.get('reportApiUrl', 'http://localhost:8888/rest/report/show_html')
 
@@ -48,6 +50,10 @@ export async function renderRODO({ doNo }, context: any) {
   const partnerBiz: Bizplace = foundDO.bizplace //customer bizplace
   const ownRefNo = foundRO.refNo
 
+  let foundInventoryItem: InventoryItem[] = await getRepository(InventoryItem).query(
+    `select row_number() over (partition by p.sku) as "seq",p.sku,p.brand_sku, ii.serial_number from inventory_items ii left join products p on ii.product_id = p.id where outbound_order_id = '${foundDO.releaseGood.id}' group by p.sku,ii.serial_number,p.brand_sku`
+  )
+
   const partnerDomain: Partner = await getRepository(Partner).findOne({
     where: { partnerDomain: partnerBiz.domain, domain },
     relations: ['domain']
@@ -70,6 +76,11 @@ export async function renderRODO({ doNo }, context: any) {
     relations: ['updater']
   })
 
+  const foundLoadingWS: Worksheet = await getRepository(Worksheet).findOne({
+    where: { domain, releaseGood: foundRO, type: WORKSHEET_TYPE.LOADING },
+    relations: ['updater']
+  })
+
   //find reusable pallet
   const foundRP: Pallet[] = await getRepository(Pallet).find({
     where: { domain, refOrderNo: foundRO.name }
@@ -211,6 +222,68 @@ export async function renderRODO({ doNo }, context: any) {
       }
     }, [])
 
+
+
+  let tempFoundInventoryItem: any = []
+
+  const sepProductList = productList.flatMap(p => Array.from({ length: p.product_qty }, () => ({ ...p })))
+
+  sepProductList.forEach((product) => {
+
+    let temp = foundInventoryItem.filter((item) => {
+      return item.sku == product.product_sku
+    })
+
+    if (temp.length > 1) {
+      temp.forEach(res => {
+        console.log(res)
+
+        if (tempFoundInventoryItem.length == 0) {
+          tempFoundInventoryItem.push(res)
+        } else {
+          const index = tempFoundInventoryItem.findIndex(res => res.serial_number == res.serial_number)
+
+          if (!index) {
+            tempFoundInventoryItem.push(res)
+          }
+        }
+
+        tempFoundInventoryItem = _.uniqWith(tempFoundInventoryItem, _.isEqual)
+      })
+    } else {
+      tempFoundInventoryItem.push(Object.assign({}, ...temp))
+    }
+  })
+
+  foundInventoryItem = tempFoundInventoryItem;
+
+  const filterInventoryItem = _.groupBy(foundInventoryItem, i => i.sku)
+
+  const tempIndexArr = []
+
+  const tempTotalQuantity = []
+
+  Object.keys(filterInventoryItem).forEach(k => {
+    const tempIndex = foundInventoryItem.findIndex(i => {
+      return i.sku == k
+    })
+
+    tempIndexArr.push(tempIndex)
+  })
+
+  Object.values(filterInventoryItem).forEach(k => {
+    const tempQuantity = k.length
+
+    tempTotalQuantity.push(tempQuantity)
+  })
+
+  tempIndexArr.forEach((t, index) => {
+    if (t >= 0)
+      foundInventoryItem[t].totalQuantity = tempTotalQuantity[index]
+  })
+
+  foundInventoryItem[0].ref_no = ownRefNo || ""
+
   const data = {
     logo_url: logo,
     customer_biz: partnerBiz.name,
@@ -231,9 +304,16 @@ export async function renderRODO({ doNo }, context: any) {
     customer_name: foundCP ? foundCP.name : null,
     customer_delivery_address: foundCP ? foundCP.address : null,
     customer_billing_address: foundCP ? foundCP.billingAddress : null,
+    new_billing_address: foundRO?.billingAddress || null,
     new_delivery_address: foundRO?.deliveryAddress1 || null,
     new_delivery_address2: foundRO?.deliveryAddress2 || null,
-    new_billing_address: foundRO?.billingAddress || null,
+    new_delivery_address3: foundRO?.deliveryAddress3 || null,
+    new_delivery_address4: foundRO?.deliveryAddress4 || null,
+    new_delivery_address5: foundRO?.deliveryAddress5 || null,
+    new_delivery_city: foundRO?.city || null,
+    new_delivery_state: foundRO?.state || null,
+    new_delivery_postal_code: foundRO?.postalCode || null,
+    new_delivery_country: foundRO?.country || null,
     new_attention_to: foundRO?.attentionTo || null,
     new_attention_company: foundRO?.attentionCompany || null,
     new_phone_no: foundRO?.phone1 || null,
@@ -251,6 +331,8 @@ export async function renderRODO({ doNo }, context: any) {
     ref_no3: foundRO.refNo3 ? `${foundRO.refNo3}` : '',
     order_no: foundDO.name,
     delivery_date: foundDO.deliveryDate || '',
+    complete_loading_date: DateTimeConverter.date(foundLoadingWS.endedAt),
+    ro_created_date: DateTimeConverter.date(foundRO.createdAt),
     truck_no: foundDO.truckNo,
     driver_name: foundDriver || '',
     pallet_qty: foundDO.palletQty,
@@ -266,15 +348,18 @@ export async function renderRODO({ doNo }, context: any) {
         remark: prod?.remark
           ? prod.remark
           : prod.cross_docking
-          ? prod.pallet === ''
-            ? `${prod.palletQty} PALLET(S) [C/D]`
-            : `${prod.palletQty} PALLET(S) (${prod.pallet}) [C/D]`
-          : prod.pallet === ''
-          ? `${prod.palletQty} PALLET(S)`
-          : `${prod.palletQty} PALLET(S) (${prod.pallet})`,
+            ? prod.pallet === ''
+              ? `${prod.palletQty} PALLET(S) [C/D]`
+              : `${prod.palletQty} PALLET(S) (${prod.pallet}) [C/D]`
+            : prod.pallet === ''
+              ? `${prod.palletQty} PALLET(S)`
+              : `${prod.palletQty} PALLET(S) (${prod.pallet})`,
         inventory_remark: prod?.inventory_remark ? prod.inventory_remark : '',
         batch_id_ref: prod.product_batch_ref
       }
+    }),
+    serialNumber: foundInventoryItem.map((item: any, idx) => {
+      return { ...item, delivery_to: foundDO.to }
     })
   } //.. make data from do
   const formData = new FormData()

package/server/controllers/worksheet-controller.ts

@@ -3,7 +3,7 @@ import { EntityManager, EntitySchema, Equal, FindOneOptions, In, Not } from 'typ
 import { Role, User } from '@things-factory/auth-base'
 import { Bizplace, getDomainUsers } from '@things-factory/biz-base'
 import { sendNotification } from '@things-factory/notification'
-import { ProductDetail } from '@things-factory/product-base'
+import { Product, ProductDetail } from '@things-factory/product-base'
 import {
   ArrivalNotice,
   DeliveryOrder,
@@ -19,7 +19,7 @@ import {
   VasOrder
 } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { Inventory, INVENTORY_STATUS, Pallet } 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'
@@ -300,7 +300,7 @@ export class WorksheetController {
 
   /**
    * @summary find worksheet detail by passed condition
-   * @description find worksheey based on passed condition
+   * @description find worksheet detail based on passed condition
    * If you want to get additional relations you need to define reltaions
    * ex) findWorksheetDetail(condition, ['worksheet'])
    */
@@ -390,6 +390,19 @@ export class WorksheetController {
     let refOrderType: string = await this.getRefOrderField(refOrder)
     const bizplace: Bizplace = await this.extractBizplaceFromRefOrder(refOrder)
 
+    let existingWorksheet: Worksheet
+    try {
+      existingWorksheet = await this.findWorksheetByRefOrder(refOrder, type)
+    } catch (e) {}
+
+    if (existingWorksheet)
+      throw new Error(
+        this.ERROR_MSG.VALIDITY.CANT_PROCEED_STEP_BY(
+          `create ${type.toLocaleLowerCase()} worksheet`,
+          'existing worksheet is found'
+        )
+      )
+
     const worksheet: Partial<Worksheet> = {
       domain: this.domain,
       bizplace,
@@ -941,6 +954,22 @@ export class WorksheetController {
     if (duplicatedCartonCnt) throw new Error(this.ERROR_MSG.VALIDITY.DUPLICATED('Carton ID', cartonId))
   }
 
+  /**
+   * @summary Check whether passed serial number is existing already
+   * @description It will try to count inventories which has same domain and same serial number and  and not terminated one
+   * If there's positive result it will throw an error cause serial number is duplicated
+   */
+  async checkSerialNumberDuplication(serialNumber: string, product: Product): Promise<void> {
+    const duplicatedSerialNumberCnt: number = await this.trxMgr.getRepository(InventoryItem).count({
+      domain: this.domain,
+      product,
+      serialNumber,
+      status: Not(Equal(INVENTORY_STATUS.DELETED))
+    })
+
+    if (duplicatedSerialNumberCnt) throw new Error(this.ERROR_MSG.VALIDITY.DUPLICATED('Serial Number', serialNumber))
+  }
+
   /**
    * @summary Check for product child qty at any scanned level
    * @description It will check every level of product detail by comparing scanned level and GAN registered level.

package/server/entities/index.ts

@@ -1,7 +1,8 @@
 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]
+export const entities = [Worksheet, WorksheetDetail, WorksheetMovement, WarehouseBizplaceOnhandInventory]
 
 export { Worksheet, WorksheetDetail, WorksheetMovement }

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

@@ -0,0 +1,147 @@
+import { ViewColumn, ViewEntity } from 'typeorm'
+
+@ViewEntity({
+  expression: `  
+  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 "domainId",
+    i.bizplace_id as "bizplaceId",
+    i.packing_type as "packingType",
+    i.packing_size as "packingSize",
+    i.uom,
+    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 "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,
+      i.bizplace_id,
+      i.product_id,
+      i.packing_type,
+      i.packing_size,
+      i.uom
+    union all
+    -- BUNDLE ITEM INVENTORY QUERY
+    SELECT 
+    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 "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."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)) - 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 "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')    
+      LEFT JOIN oi ON oi.product_id = i.product_id
+      GROUP by
+        i.domain_id, 
+        i.bizplace_id,
+        pbs.product_id, 
+        pbs.product_bundle_id
+    ) pbs ON pbs.product_bundle_id = pb.id
+    GROUP BY 
+    pbs.domain_id,
+    pbs.bizplace_id,
+    pb.packing_type, 
+    pb.packing_size, 
+    pb.name, 
+    pb.sku, 
+    pb.id
+  )
+  AS src 
+  inner join domains d on d.id = src."domainId"
+  inner join bizplaces b on b.id = src."bizplaceId"
+  where src."remainQty" > 0
+  order by src."domainId"
+  `
+})
+
+export class WarehouseBizplaceOnhandInventory {
+  @ViewColumn()
+  domainName: string
+
+  @ViewColumn()
+  bizplaceName: string
+
+  @ViewColumn()
+  domainId: string
+
+  @ViewColumn()
+  bizplaceId: string
+
+  @ViewColumn()
+  packingType: string
+
+  @ViewColumn()
+  packingSize: number
+
+  @ViewColumn()
+  uom: string
+
+  @ViewColumn()
+  productId: string
+
+  @ViewColumn()
+  productBundleId: string
+
+  @ViewColumn()
+  remainQty: number
+
+  @ViewColumn()
+  remainUomValue: number
+
+  @ViewColumn()
+  groupType: string
+}

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

@@ -3,6 +3,7 @@ import { getRepository, SelectQueryBuilder } from 'typeorm'
 import { ORDER_INVENTORY_STATUS } from '@things-factory/sales-base'
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../entities'
+import { InventoryChange } from '@things-factory/warehouse-base'
 
 export const batchPickingWorksheetResolver = {
   async batchPickingWorksheet(_: any, { taskNo, locationSortingRules }, context: any) {
@@ -42,6 +43,7 @@ export const batchPickingWorksheetResolver = {
       .addSelect('LOC.column', 'column')
       .addSelect('LOC.shelf', 'shelf')
       .addSelect('BIN_LOC.name', 'binLocationName')
+      .addSelect('WSD.status', 'status')
       .leftJoin('WSD.targetInventory', 'T_INV')
       .leftJoin('T_INV.inventory', 'INV')
       .leftJoin('T_INV.product', 'PROD')
@@ -70,6 +72,7 @@ export const batchPickingWorksheetResolver = {
       .addGroupBy('LOC.column')
       .addGroupBy('LOC.row')
       .addGroupBy('LOC.shelf')
+      .addGroupBy('WSD.status')
 
     if (locationSortingRules?.length > 0) {
       locationSortingRules.forEach((rule: { name: string; desc: boolean }) => {
@@ -86,6 +89,15 @@ export const batchPickingWorksheetResolver = {
         partnerDomainId: worksheet.bizplace?.domain.id
       },
       worksheetDetailInfos: items.map(async (item: any) => {
+        const inventoryChangesCount: number = await getRepository(InventoryChange).count({
+          where: {
+            inventory: item.inventoryId,
+            status: 'PENDING',
+            transactionType: 'MISSING'
+          },
+          relations: ['inventory', 'product']
+        })
+
         return {
           palletId: item?.palletId,
           cartonId: item?.cartonId,
@@ -98,6 +110,8 @@ export const batchPickingWorksheetResolver = {
           },
           qty: item?.qty,
           releaseQty: item.releaseQty,
+          hasMissingInventoryChanges: inventoryChangesCount > 0 ? true : false,
+          status: item.status,
           pickedQty: item.pickedQty,
           packingType: item?.packingType,
           packingSize: item?.packingSize,

package/server/graphql/resolvers/worksheet/cancel-draft-release-order.ts

@@ -0,0 +1,27 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import {
+  ORDER_STATUS,
+  DraftReleaseGood
+} from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+export const cancelDraftReleaseOrder = {
+  async cancelDraftReleaseOrder(_: any, { name }, context: any) {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    const foundDRO: DraftReleaseGood = await tx.getRepository(DraftReleaseGood).findOne({
+      where: { domain, name }
+    })
+
+    if (foundDRO) {
+      await tx.getRepository(DraftReleaseGood).save({
+        ...foundDRO,
+        status: ORDER_STATUS.CANCELLED,
+        updater: user
+      })
+    }
+    return
+  }
+}

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

@@ -56,7 +56,9 @@ export async function cycleCountAdjustment(
       'targetInventory.inventory.product.productDetails',
       'targetInventory.inventory.product.productDetails.childProductDetail',
       'targetInventory.inventory.bizplace',
+      'targetInventory.inventory.domain',
       'targetInventory.inventory.bizplace.domain',
+      'targetInventory.inventory.warehouse',
       'targetInventory.inventory.location',
       'targetInventory.inspectedLocation',
       'targetInventory.inspectedLocation.warehouse'
@@ -67,11 +69,12 @@ export async function cycleCountAdjustment(
     const targetInventory: OrderInventory = worksheetDetail.targetInventory
     let inventory: Inventory = targetInventory.inventory
 
-    const transactQty: number = targetInventory.inspectedQty - inventory.qty
-    const transactUomValue: number = targetInventory.inspectedUomValue - inventory.uomValue
+    let transactQty: number = targetInventory.inspectedQty - inventory.qty
+    let transactUomValue: number = targetInventory.inspectedUomValue - inventory.uomValue
 
     const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({
-      where: { domain: inventory.bizplace.domain, status: SellercraftStatus.ACTIVE }
+      where: { domain: inventory.bizplace.domain, status: SellercraftStatus.ACTIVE },
+      relations: ['domain']
     })
 
     if (targetInventory.status === ORDER_INVENTORY_STATUS.MISSING) {
@@ -137,16 +140,23 @@ export async function cycleCountAdjustment(
 
       if (targetInventory.inspectedBatchNo !== inventory.batchId) {
         // generate TERMINATED, ADJUSTMENT history
+        const { qty, uomValue }: { qty: number; uomValue: number } = inventory
         inventory.status = INVENTORY_STATUS.TERMINATED
+        inventory.qty = 0
+        inventory.uomValue = 0
+
         await generateInventoryHistory(
           inventory,
           cycleCount,
           INVENTORY_TRANSACTION_TYPE.CC_ADJUSTMENT,
-          -transactQty,
-          -transactUomValue,
+          -qty,
+          -uomValue,
           user,
           tx
         )
+
+        transactQty = targetInventory.inspectedQty
+        transactUomValue = targetInventory.inspectedUomValue
       }
 
       inventory.batchId = targetInventory.inspectedBatchNo

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

@@ -1,11 +1,12 @@
 import { EntityManager, SelectQueryBuilder } from 'typeorm'
 
 import {
-  ORDER_STATUS,
+  ORDER_STATUS, ORDER_INVENTORY_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'
@@ -16,6 +17,38 @@ export const findReleaseOrdersByTaskNoResolver = {
     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
@@ -38,6 +71,6 @@ export const findReleaseOrdersByTaskNoResolver = {
       .addGroupBy('rg.status')
 
     const releaseGoods: ReleaseGoodEntity[] = await qb.getRawMany()
-    return releaseGoods
+    return { releaseGoods, taskNo }
   }
 }

package/server/graphql/resolvers/worksheet/generate-worksheet/generate-arrival-notice-worksheet.ts

@@ -8,34 +8,44 @@ import { Worksheet } from '../../../../entities'
 export const generateArrivalNoticeWorksheetResolver = {
   async generateArrivalNoticeWorksheet(_: any, { arrivalNoticeNo, bufferLocation }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    let unloadingWorksheet = await generateUnloadingWorksheet(tx, domain, user, arrivalNoticeNo, bufferLocation)
-
-    if (!unloadingWorksheet.arrivalNotice?.id) {
-      unloadingWorksheet = await tx.getRepository(Worksheet).findOne({
-        where: unloadingWorksheet,
-        relations: ['arrivalNotice']
-      })
-    }
-
-    let arrivalNotice: ArrivalNotice = unloadingWorksheet.arrivalNotice
-    const crossDocking: boolean = unloadingWorksheet.arrivalNotice.crossDocking
-
-    if (crossDocking) {
-      arrivalNotice = await tx
-        .getRepository(ArrivalNotice)
-        .findOne({ where: { domain: domain, name: arrivalNoticeNo }, relations: ['releaseGood'] })
-
-      const releaseGoodNo: string = arrivalNotice.releaseGood.name
-      const pickingWSCtrl: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-      await pickingWSCtrl.generatePickingWorksheet(releaseGoodNo)
-    }
-
-    const vasWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
-      where: { domain: domain, arrivalNotice }
+    return await generateArrivalNoticeWorksheet(tx, domain, user, arrivalNoticeNo, bufferLocation)
+  }
+}
+
+export async function generateArrivalNoticeWorksheet(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  arrivalNoticeNo: string,
+  bufferLocation: { id: string }
+) {
+  let unloadingWorksheet = await generateUnloadingWorksheet(tx, domain, user, arrivalNoticeNo, bufferLocation)
+
+  if (!unloadingWorksheet.arrivalNotice?.id) {
+    unloadingWorksheet = await tx.getRepository(Worksheet).findOne({
+      where: unloadingWorksheet,
+      relations: ['arrivalNotice']
     })
+  }
+
+  let arrivalNotice: ArrivalNotice = unloadingWorksheet.arrivalNotice
+  const crossDocking: boolean = unloadingWorksheet.arrivalNotice.crossDocking
 
-    return { unloadingWorksheet, vasWorksheet }
+  if (crossDocking) {
+    arrivalNotice = await tx
+      .getRepository(ArrivalNotice)
+      .findOne({ where: { domain: domain, name: arrivalNoticeNo }, relations: ['releaseGood'] })
+
+    const releaseGoodNo: string = arrivalNotice.releaseGood.name
+    const pickingWSCtrl: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+    await pickingWSCtrl.generatePickingWorksheet(releaseGoodNo)
   }
+
+  const vasWorksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
+    where: { domain: domain, arrivalNotice }
+  })
+
+  return { unloadingWorksheet, vasWorksheet }
 }
 
 async function generateUnloadingWorksheet(

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

@@ -22,6 +22,7 @@ import { Mutations as PackingMutations } from './packing'
 import { packingWorksheetResolver } from './packing-worksheet'
 import { palletizingPallets } from './palletizing-pallets'
 import { pendingCancellationReleaseOrder } from './pending-cancellation-release-order'
+import { cancelDraftReleaseOrder } from './cancel-draft-release-order'
 import { Mutations as PickingMutations } from './picking'
 import { pickingWorksheetResolver } from './picking-worksheet'
 import { myPickingAssignmentStatusResolver } from './picking/my-picking-assignment-status'
@@ -132,5 +133,6 @@ export const Mutation = {
   ...crossDockPickingResolver,
   ...unpackingResolver,
   ...palletizingPallets,
-  ...fetchSellercraftAirwayBillResolver
+  ...fetchSellercraftAirwayBillResolver,
+  ...cancelDraftReleaseOrder
 }

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

@@ -78,6 +78,8 @@ export const inventoriesByPalletResolver = {
       locationSortingRules.forEach((rule: { name: string; desc: boolean }) => {
         qb.addOrderBy(`location.${rule.name}`, rule.desc ? 'DESC' : 'ASC')
       })
+    } else {
+      qb.addOrderBy('location.name', 'DESC')
     }
 
     if (productFilters && productFilters.length > 0) {