@things-factory/worksheet-base 4.3.461 → 4.3.464

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

@@ -1,19 +1,37 @@
-import { EntityManager } from 'typeorm'
+import { EntityManager, In } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { ORDER_INVENTORY_STATUS, ORDER_STATUS, OrderInventory, ReleaseGood } from '@things-factory/sales-base'
+import { logger } from '@things-factory/env'
+import { StoreAPI } from '@things-factory/integration-marketplace'
+import {
+  MarketplaceOrder,
+  MarketplaceOrderItem,
+  MarketplaceOrderPackage,
+  MarketplaceOrderPackageItem,
+  MarketplaceProductVariation,
+  MarketplaceStore
+} from '@things-factory/marketplace-base'
+import {
+  ORDER_INVENTORY_STATUS,
+  ORDER_STATUS,
+  OrderInventory,
+  OrderNoGenerator,
+  OrderPackage,
+  OrderPackageItem,
+  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'
+import { createLmdParcel } from '../../../../utils'
 
 export const generateReleaseGoodWorksheetResolver = {
   async generateReleaseGoodWorksheet(_: any, { releaseGoodNo, currentStatus = null }, context: any) {
     const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    let worksheet = await generatePickingWorksheet(tx, domain, user, releaseGoodNo, currentStatus)
+    let worksheet = await generatePickingWorksheet(tx, domain, user, releaseGoodNo, currentStatus, context)
     if (worksheet) {
       return true
     } else {
@@ -27,7 +45,8 @@ export async function generatePickingWorksheet(
   domain: Domain,
   user: User,
   releaseGoodNo: string,
-  currentStatus: string = null
+  currentStatus: string = null,
+  context?: any
 ): Promise<Worksheet> {
   try {
     const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
@@ -47,6 +66,8 @@ export async function generatePickingWorksheet(
     if (releaseGood.type == 'b2c' && directReleaseOrder && directReleaseOrder.value.toLowerCase() == 'true') {
       const inventoryUtil = new InventoryUtil(tx, domain, user)
 
+      await mmsProcessOrder(tx, domain, user, releaseGood, context)
+
       let orderInventories: OrderInventory[] = await tx.getRepository(OrderInventory).find({
         where: { domain, releaseGood },
         relations: ['inventory']
@@ -89,7 +110,8 @@ export async function generatePickingWorksheet(
 
     return worksheet
   } catch (error) {
-    return new Worksheet()
+    throw new Error(error.message)
+    //return new Worksheet()
   }
 }
 
@@ -115,3 +137,442 @@ export async function generatePickingWorksheetDetail(
   const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
   return await worksheetController.generatePickingWorksheetDetail(worksheet, targetInventory)
 }
+
+export async function mmsProcessOrder(
+  tx: EntityManager,
+  domain: Domain,
+  user: User,
+  foundReleaseGood: ReleaseGood,
+  context?: any
+): Promise<void> {
+  try {
+    let marketplaceOrder: MarketplaceOrder
+    let marketplaceOrderPackages: MarketplaceOrderPackage
+    let marketplaceOrderItems: MarketplaceOrderItem[]
+    let marketplaceStore: MarketplaceStore
+
+    marketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+      where: {
+        orderNo: foundReleaseGood.refNo
+      },
+      relations: [
+        'marketplaceStore',
+        'marketplaceOrderPackages',
+        'marketplaceOrderPackages.marketplaceOrderPackageItems',
+        'marketplaceOrderPackages.marketplaceOrderPackageItems.marketplaceOrderItem',
+        'marketplaceOrderPackages.marketplaceOrderPackageItems.marketplaceOrderItem.marketplaceProductVariation',
+        'marketplaceOrderItems',
+        'marketplaceOrderItems.marketplaceProductVariation'
+      ]
+    })
+
+    let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+      where: { id: foundReleaseGood.id, domain: domain },
+      relations: [
+        'orderPackages',
+        'orderPackages.orderPackageItems',
+        'orderProducts',
+        'orderProducts.product',
+        'orderProducts.productDetail',
+        'domain',
+        'bizplace',
+        'creator',
+        'updater',
+        'lastMileDelivery'
+      ]
+    })
+
+    if (!releaseGood) throw new Error('unable to find release good')
+
+    marketplaceStore = marketplaceOrder.marketplaceStore
+    marketplaceOrderItems = marketplaceOrder?.marketplaceOrderItems ? marketplaceOrder.marketplaceOrderItems : []
+    marketplaceOrderPackages = marketplaceOrder?.marketplaceOrderPackages
+      ? marketplaceOrder.marketplaceOrderPackages
+      : []
+
+    if (marketplaceOrderPackages?.length <= 0) {
+      let platform = marketplaceOrder.marketplaceStore.platform
+
+      if (platform == 'shopee') {
+        let orderList = marketplaceOrder.id
+        let result = await StoreAPI.getStoreOrderByBatch(marketplaceStore, { orderIdList: orderList })
+
+        if (result.packageList && result.packageList.length > 0) {
+          releaseGood = await mmsPackMarketplaceOrder(
+            releaseGood,
+            marketplaceOrder,
+            marketplaceOrderItems,
+            result,
+            domain,
+            tx
+          )
+        }
+      } else if (platform == 'lazada') {
+        try {
+          let fullOrderItemList = marketplaceOrderItems.map(moi => moi.name)
+          const logisticByPackage = await StoreAPI.getStoreLogisticsByPackage(marketplaceStore, {
+            orderId: marketplaceOrder.orderNo,
+            orderItemIds: fullOrderItemList
+          })
+
+          if (!logisticByPackage) throw new Error('Shipment provider not found')
+
+          //panggil packOrder Lazada utk dapatkan packageId utk create op dan opi
+          let result = await StoreAPI.setStoreOrderStatusPackedByMarketplace(marketplaceStore, {
+            packOrderList: [{ orderId: marketplaceOrder.orderNo, orderItemList: fullOrderItemList }],
+            deliveryType: 'dropship',
+            shippingAllocateType: logisticByPackage.shippingAllocateType
+          })
+
+          //massage data frst one package
+          const data = result.packOrderList.map(pol => {
+            const groupedItems = {}
+
+            pol.orderItemList.forEach(item => {
+              const { packageId, shipmentProvider, trackingNumber, orderItemId } = item
+              if (!groupedItems[packageId]) {
+                groupedItems[packageId] = { packageId, packageItem: [] }
+              }
+              groupedItems[packageId].packageItem.push({ shipmentProvider, trackingNumber, orderItemId })
+            })
+
+            const massagedData = Object.values(groupedItems)
+            result = { packOrderList: massagedData }
+          })
+
+          //create mop , mopi , op & opi
+          if (result.packOrderList && result.packOrderList.length) {
+            releaseGood = await mmsPackMarketplaceOrder(
+              releaseGood,
+              marketplaceOrder,
+              marketplaceOrderItems,
+              result,
+              domain,
+              tx
+            )
+          }
+        } catch (e) {
+          logger.error(`packOrder[lazada]: ${e}`)
+          throw e
+        }
+      }
+    } else {
+      try {
+        releaseGood = await mmsPackMarketplaceOrder(
+          releaseGood,
+          marketplaceOrder,
+          marketplaceOrderItems,
+          [],
+          domain,
+          tx,
+          marketplaceOrderPackages
+        )
+      } catch (e) {
+        logger.error(`packOrder[shopee]: ${e}`)
+        throw e
+      }
+    }
+
+    if (
+      releaseGood?.orderPackages?.length > 0 &&
+      releaseGood.lmdOption &&
+      releaseGood.lastMileDelivery &&
+      releaseGood?.orderPackages?.some(op => op.parcelId == null)
+    ) {
+      try {
+        await createLmdParcel([releaseGood], tx, domain, user, marketplaceOrder)
+
+        let updatedReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+          where: { id: releaseGood.id },
+          relations: ['domain', 'bizplace', 'orderPackages', 'orderPackages.orderPackageItems']
+        })
+
+        let updatedMarketplaceOrderPackages: MarketplaceOrderPackage = await tx
+          .getRepository(MarketplaceOrderPackage)
+          .find({
+            where: { marketplaceOrder: marketplaceOrder.id },
+            relations: ['marketplaceOrder', 'marketplaceOrderPackageItems']
+          })
+
+        let updatedOrderPackage: OrderPackage[] = updatedReleaseGood.orderPackages
+
+        const hasNullAirwaybill = updatedOrderPackage.some(orderPackage => orderPackage.airwaybill === null)
+
+        // if the user had call the awb more than 5 times
+        if (updatedReleaseGood.countParcel > 5 && hasNullAirwaybill) {
+          throw new Error(
+            'It appears that we are unable to retrieve the AWB from the platform. Please reach out to support for assistance'
+          )
+        }
+
+        if (hasNullAirwaybill)
+          throw new Error(
+            'We are in the process to get the AWB. Please retry by clicking the GENERATE PICKING WORKSHEET'
+          )
+
+        for (let updatePackage of updatedOrderPackage) {
+          for (let mop of updatedMarketplaceOrderPackages) {
+            // Find match order package based on packageId and releaseGood refOrderId
+            if (updatePackage.packageId === mop.packageId && updatedReleaseGood.refOrderId === marketplaceOrder.id) {
+              await tx.getRepository(MarketplaceOrderPackage).update(
+                { id: mop.id },
+                {
+                  airwayBill: updatePackage.airwayBill,
+                  trackingNo: updatePackage.trackingNo,
+                  transporter: updatePackage?.transporter
+                }
+              )
+            }
+          }
+        }
+      } catch (e) {
+        logger.error(`mms-create-parcel-error: ${e}`)
+        throw e
+      }
+    }
+
+    //ini belum test fr shopee && lazada
+    try {
+      if (marketplaceOrder?.marketplaceOrderPackages?.length > 0) {
+        await mmsRTSMarketplaceOrder(marketplaceOrder, tx, domain)
+      }
+    } catch (e) {
+      logger.error(`rts-mms-orders:${e}`)
+      throw e
+    }
+  } catch (e) {
+    console.log(e)
+    throw e
+  }
+}
+
+export async function mmsPackMarketplaceOrder(
+  releaseGood,
+  marketplaceOrder,
+  marketplaceOrderItems,
+  result,
+  domain,
+  tx,
+  existingMarketplaceOrderPackage?
+): Promise<ReleaseGood> {
+  try {
+    let newMarketplaceOrderPackage: MarketplaceOrderPackage = new MarketplaceOrderPackage()
+    let newMarketplaceOrderPackageItem: MarketplaceOrderPackageItem = new MarketplaceOrderPackageItem()
+    let orderPackage: OrderPackage = new OrderPackage()
+    let orderPackageItem: OrderPackageItem = new OrderPackageItem()
+    let newMarketplaceOrderPackages = []
+    let newOrderPackages = []
+
+    if (!existingMarketplaceOrderPackage) {
+      let packagePack = result?.packageList ? result.packageList : result.packOrderList
+
+      for (let j = 0; j < packagePack.length; j++) {
+        let marketplacePackage = packagePack[j]
+        let packageItems = marketplacePackage?.packageItem || marketplacePackage?.orderItemList
+        let marketplaceOrderItem
+
+        newMarketplaceOrderPackage.name = result.name || marketplaceOrder.name
+        newMarketplaceOrderPackage.packageId = marketplacePackage.packageId
+        newMarketplaceOrderPackage.transporter = marketplacePackage.transporter
+        newMarketplaceOrderPackage.marketplaceOrder = marketplaceOrder
+        newMarketplaceOrderPackage.domain = domain
+        newMarketplaceOrderPackage.marketplaceOrderPackageItems = []
+
+        await tx.getRepository(MarketplaceOrderPackage).insert(newMarketplaceOrderPackage)
+
+        newMarketplaceOrderPackages.push(newMarketplaceOrderPackage)
+
+        for (let i = 0; i < packageItems.length; i++) {
+          let packageItem = packageItems[i]
+          marketplaceOrderItem = marketplaceOrderItems.find(itm => {
+            return itm.orderId == packageItem.orderItemId
+          })
+
+          newMarketplaceOrderPackageItem.name = marketplaceOrderItem.name
+          newMarketplaceOrderPackageItem.qty = marketplaceOrderItem.qty
+          newMarketplaceOrderPackageItem.domain = domain
+          newMarketplaceOrderPackageItem.marketplaceOrderPackage = newMarketplaceOrderPackage
+          newMarketplaceOrderPackageItem.marketplaceOrderItem = marketplaceOrderItem
+
+          await tx.getRepository(MarketplaceOrderPackageItem).insert(newMarketplaceOrderPackageItem)
+
+          newMarketplaceOrderPackage.marketplaceOrderPackageItems.push(newMarketplaceOrderPackageItem)
+        }
+      }
+      marketplaceOrder.marketplaceOrderPackages = newMarketplaceOrderPackages
+
+      existingMarketplaceOrderPackage = marketplaceOrder?.marketplaceOrderPackages
+        ? marketplaceOrder.marketplaceOrderPackages
+        : []
+    }
+
+    if (releaseGood.orderPackages.length <= 0) {
+      for (let i = 0; i < existingMarketplaceOrderPackage.length; i++) {
+        let mop = existingMarketplaceOrderPackage[i]
+        let mopi = mop.marketplaceOrderPackageItems
+
+        orderPackage.name = OrderNoGenerator.orderPackage()
+        orderPackage.packageId = mop?.packageId
+        orderPackage.transporter = null
+        orderPackage.airwaybill = null
+        orderPackage.status = ORDER_STATUS.PROCESSING
+        orderPackage.releaseGood = releaseGood
+        orderPackage.domain = releaseGood.domain
+        orderPackage.bizplace = releaseGood.bizplace
+        orderPackage.creator = releaseGood.creator
+        orderPackage.updater = releaseGood.updater
+        orderPackage.orderPackageItems = []
+
+        await tx.getRepository(OrderPackage).save(orderPackage)
+        newOrderPackages.push(orderPackage)
+
+        for (let j = 0; j < mopi?.length; j++) {
+          let productVariation: MarketplaceProductVariation = mopi[j].marketplaceOrderItem.marketplaceProductVariation
+
+          let matchedOrderProduct = releaseGood.orderProducts.find(op => op.product.sku == productVariation.sku)
+
+          orderPackageItem.name = OrderNoGenerator.orderPackageItem()
+          orderPackageItem.orderProduct = matchedOrderProduct
+          orderPackageItem.status = ORDER_STATUS.PROCESSING
+          orderPackageItem.orderPackage = orderPackage
+          orderPackageItem.releaseQty = matchedOrderProduct.releaseQty
+          orderPackageItem.domain = releaseGood.domain
+          orderPackageItem.bizplace = releaseGood.bizplace
+          orderPackageItem.creator = releaseGood.creator
+          orderPackageItem.updater = releaseGood.updater
+          orderPackageItem.productDetail = matchedOrderProduct?.productDetail
+
+          await tx.getRepository(OrderPackageItem).save(orderPackageItem)
+          orderPackage.orderPackageItems.push(orderPackageItem)
+        }
+
+        releaseGood.orderPackages = newOrderPackages
+      }
+    }
+    return releaseGood
+  } catch (e) {
+    logger.error(`mmsPackMarketplaceOrder: ${e}`)
+    throw e
+  }
+}
+
+export async function mmsRTSMarketplaceOrder(mop, tx, domain): Promise<Boolean> {
+  try {
+    // const { tx } = context.state
+
+    let marketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+      where: {
+        id: mop.id
+      },
+      relations: [
+        'marketplaceStore',
+        'marketplaceOrderPackages',
+        'marketplaceOrderPackages.marketplaceOrderPackageItems',
+        'marketplaceOrderPackages.marketplaceOrderPackageItems.marketplaceOrderItem',
+        'marketplaceOrderPackages.marketplaceOrderPackageItems.marketplaceOrderItem.marketplaceProductVariation',
+        'marketplaceOrderItems',
+        'marketplaceOrderItems.marketplaceProductVariation'
+      ]
+    })
+
+    let marketplaceStore = marketplaceOrder.marketplaceStore
+    let marketplaceOrderPackages = marketplaceOrder.marketplaceOrderPackages
+    let platform = marketplaceStore.platform
+
+    if (marketplaceOrder?.marketplaceOrderPackages.length > 0) {
+      switch (platform) {
+        case 'shopee':
+          await rtsShopeeOrder(marketplaceOrder, marketplaceOrderPackages, tx, domain)
+          break
+        case 'lazada':
+          await rtsLazadaOrder(marketplaceOrder, marketplaceOrderPackages, tx, domain)
+          break
+        default:
+          break
+      }
+    }
+    return true
+  } catch (e) {
+    logger.error(`mmsRTSMarketplaceOrder[main]: ${e}`)
+    throw e
+  }
+}
+
+async function rtsShopeeOrder(marketplaceOrder, marketplaceOrderPackages, tx, domain) {
+  await Promise.all(
+    marketplaceOrderPackages.map(async marketplaceOrderPackage => {
+      try {
+        let deliveryType = {}
+        let store = marketplaceOrder.marketplaceStore
+        let isMultipackage: Boolean = marketplaceOrderPackages.length > 1 ? true : false
+
+        // call api to know delivery type
+        let shippingParams = await StoreAPI.getLogisticsParam(
+          store,
+          { orderNo: marketplaceOrder.name, packageId: marketplaceOrderPackage.packageId, isMultipackage },
+          tx
+        )
+
+        //let shippingType = shippingParams?.infoNeeded
+        let shippingDetail = shippingParams?.logisticsDetail
+
+        if (shippingParams?.pickup) {
+          deliveryType = {
+            pickup: {
+              addressId: shippingDetail.addressId,
+              branchId: shippingDetail.branchId
+            }
+          }
+        } else if (shippingParams?.non_integrated) {
+          deliveryType = {
+            non_integrated: {
+              trackingNo: marketplaceOrderPackage.trackingNo
+            }
+          }
+        } else if (shippingParams?.dropoff) {
+          deliveryType = {
+            dropoff: shippingDetail?.branchId
+              ? {
+                  branchId: shippingDetail.branchId
+                }
+              : {}
+          }
+        }
+
+        await StoreAPI.initLogistics(marketplaceOrder.marketplaceStore, {
+          deliveryType,
+          orderNo: marketplaceOrder.orderNo,
+          packageId: marketplaceOrderPackage.packageId,
+          isMultipackage
+        })
+        await tx
+          .getRepository(OrderPackage)
+          .update(
+            { packageId: marketplaceOrderPackage.packageId, domain: { id: domain.id } },
+            { marketRtsCallSuccess: new Date() }
+          )
+      } catch (e) {
+        logger.error(`mmsRTSMarketplaceOrder[shopee]: ${e}`)
+        throw e
+      }
+    })
+  )
+}
+
+async function rtsLazadaOrder(marketplaceOrder, marketplaceOrderPackages, tx, domain) {
+  const packages = marketplaceOrderPackages.map(item => {
+    return { packageId: item.packageId }
+  })
+
+  const packageIds = marketplaceOrderPackages.map(item => item.packageId)
+
+  try {
+    await StoreAPI.setStoreOrderStatusReadyToShip(marketplaceOrder.marketplaceStore, { packages })
+    await tx
+      .getRepository(OrderPackage)
+      .update({ packageId: In(packageIds), domain: { id: domain.id } }, { marketRtsCallSuccess: new Date() })
+  } catch (e) {
+    logger.error(`mmsRTSMarketplaceOrder[lazada]: ${e}`)
+    throw e
+  }
+}

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

@@ -1,4 +1,5 @@
 import { batchPickingWorksheetResolver } from './batch-picking-worksheet'
+import { cancelArrivalNoticeResolver } from './cancel-arrival-notice'
 import { cancelDraftReleaseOrder } from './cancel-draft-release-order'
 import { cancelReplenishment } from './cancel-replenishment'
 import { checkInventoryReleaseResolver } from './check-inventory-release'
@@ -7,8 +8,8 @@ import { confirmCancellationReleaseOrder } from './confirm-cancellation-release-
 import { createWorksheet } from './create-worksheet'
 import { crossDockPickingResolver } from './cross-dock-picking'
 import { cycleCountAdjustmentResolver } from './cycle-count-adjustment'
-import { cycleCountWorksheetForPalletResolver } from './cycle-count-worksheet-for-pallet'
 import { cycleCountWorksheetForCartonResolver } from './cycle-count-worksheet-for-carton'
+import { cycleCountWorksheetForPalletResolver } from './cycle-count-worksheet-for-pallet'
 import { deleteWorksheet } from './delete-worksheet'
 import { deliveryOrderByWorksheetResolver } from './delivery-order-by-worksheet'
 import { fetchDeliveryOrderROResolver } from './fetch-delivery-order-ro'
@@ -40,6 +41,7 @@ import { Mutations as PutawayReturnMutations } from './putaway-return'
 import { putawayReturningWorksheetResolver } from './putaway-returning-worksheet'
 import { putawayWorksheetResolver } from './putaway-worksheet'
 import { recommendPutawayLocationResolver } from './recommend-putway-location'
+import { refreshActiveWorksheetPickingViews } from './refresh-active-worksheet-picking-views'
 import { rejectCancellationReleaseOrder } from './reject-cancellation-release-order'
 import { replacePickingPalletsResolver } from './replace-picking-pallets'
 import { Mutations as ReplenishmentMutations } from './replenishment'
@@ -73,7 +75,6 @@ import { worksheetResolver } from './worksheet'
 import { worksheetByOrderNoResolver } from './worksheet-by-order-no'
 import { worksheetWithPaginationResolver } from './worksheet-with-pagination'
 import { worksheetsResolver } from './worksheets'
-import { refreshActiveWorksheetPickingViews } from './refresh-active-worksheet-picking-views'
 
 export const Query = {
   ...refreshActiveWorksheetPickingViews,
@@ -152,5 +153,6 @@ export const Mutation = {
   ...fetchPowrupDocumentResolver,
   ...cancelDraftReleaseOrder,
   ...cancelReplenishment,
-  ...ReplenishmentMutations
+  ...ReplenishmentMutations,
+  ...cancelArrivalNoticeResolver
 }

package/server/graphql/resolvers/worksheet/picking/fetch-and-assign-picking-task.ts

@@ -11,7 +11,7 @@ import { pickingWorksheet } from '../picking-worksheet'
 import { activatePicking } from './activate-picking'
 
 export const fetchAndAssignPickingTaskResolver = {
-  async fetchAndAssignPickingTask(_: any, { }, context: any) {
+  async fetchAndAssignPickingTask(_: any, {}, context: any) {
     try {
       const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
       const assignee: User = await tx.getRepository(User).findOne(user.id, { relations: ['domains'] })
@@ -67,10 +67,12 @@ export const fetchAndAssignPickingTaskResolver = {
               INNER JOIN release_goods rg ON rg.id = ws.release_good_id
               WHERE 
               ws.domain_id = $1 AND 
-              ws.type = 'PICKING' AND 
-              ws.assignee_id IS NULL AND 
-              (ws.status = 'EXECUTING' OR ws.status = 'DEACTIVATED') AND
-              NOT EXISTS (
+              ws.type = 'PICKING' 
+              AND ws.status IN ('EXECUTING', 'DEACTIVATED') 
+              AND ws.assignee_id IS NULL
+              /*
+              (condition is commented as current status in oi not in use)
+              AND NOT EXISTS (
                 SELECT count(id) AS "totalPS"
                 FROM order_inventories oi 
                 WHERE oi.release_good_id = ws.release_good_id AND
@@ -78,22 +80,26 @@ export const fetchAndAssignPickingTaskResolver = {
                 GROUP BY oi.release_good_id 
                 HAVING count(id) > 0
               )
+              */
               ORDER BY rg.release_date, rg.created_at LIMIT 1
             ) src where src.id = ws.id
             RETURNING ws.id;
           `,
             [domain.id, assignee.id]
           )
+
           return x[0]
         })
 
         if (updatedWorksheets.length == 0) throw new Error('no suitable worksheet found')
 
-        // relace worksheet with newly assigned worksheet
+        // replace worksheet with newly assigned worksheetp
         worksheet = await tx
           .getRepository(Worksheet)
-          .findOne({ where: { id: updatedWorksheets[0].id }, relations: ['releaseGood'] })
+          .findOne({ where: { id: updatedWorksheets[0].id, assignee: assignee }, relations: ['releaseGood'] })
       }
+      //validation  of the workheet if its assigned to another user 
+      if (!worksheet) throw new Error('Please try again by clicking the "Get Task" button')
 
       if (worksheet.status == WORKSHEET_STATUS.DEACTIVATED) await activatePicking(tx, domain, user, worksheet.name)
 

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

@@ -4,5 +4,6 @@ export const FindReleaseOrdersByTaskNo = gql`
   type FindReleaseOrdersByTaskNo {
     taskNo: String
     releaseGoods: [ReleaseGood]
+    selectedReleaseGood: String
   }
 `

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

@@ -679,7 +679,11 @@ export const Mutation = /* GraphQL */ `
   cancelReplenishment (
     name: String!
   ): Boolean @transaction
-`
+
+  cancelArrivalNotice (
+    name: String!
+  ): Boolean @transaction
+  `
 
 export const Query = /* GraphQL */ `
   worksheets (

package/server/utils/lmd-util.ts

@@ -99,7 +99,11 @@ export async function createLmdParcel(releaseGoods, tx, domain, user, marketplac
         if (lmd?.platform == 'CITYLINK') {
           const currentDate = new Date()
           let expiredDate = new Date(lmd?.expiresIn)
-          if (currentDate > expiredDate) {
+
+          // Calculate the renewal date as 2 days before the expiry date
+          const renewalDate = new Date(expiredDate.getTime() - 2 * 24 * 60 * 60 * 1000)
+
+          if (currentDate >= renewalDate) {
             let lastMileDelivery = await getAccessTokenCityLink(lmd?.id, { state: { tx } })
             lmd.accessToken = lastMileDelivery.accessToken
           }
@@ -108,7 +112,7 @@ export async function createLmdParcel(releaseGoods, tx, domain, user, marketplac
 
         if (lmd?.platform == 'NINJA_VAN') {
           const currentTimestamp: number = Math.floor(Date.now() / 1000)
-          const renewalTimestamp = lmd?.expiresIn - 2 * 60 * 60
+          const renewalTimestamp = lmd?.expiresIn - 12 * 60 * 60 // Renew 12 hr before expiry
 
           if (currentTimestamp >= renewalTimestamp) {
             const lastMileDelivery = await refreshAccessTokenNinjavan(lmd?.id, { state: { tx } })
@@ -157,7 +161,7 @@ export async function createLmdParcel(releaseGoods, tx, domain, user, marketplac
           address2: releaseGood.deliveryAddress2,
           address3: releaseGood?.deliveryAddress3,
           ward: releaseGood?.ward?.toUpperCase(), //only for viettel lmd
-          city: releaseGood.city?.toUpperCase(),
+          city: lmd.platform == 'CITYLINK' ? ' ' : releaseGood.city?.toUpperCase(),
           postcode: releaseGood?.postalCode,
           district: releaseGood?.district?.toUpperCase() || releaseGood.city?.toUpperCase(),
           state:
@@ -713,7 +717,6 @@ export async function validateLmd(tx, releaseGood, lmdId) {
 
     lmdResult = await qb.getMany()
 
-
     const foundLmd = lmdResult.find(lmd => lmd.id === lmdId)
 
     return foundLmd ? true : false