@things-factory/worksheet-base 5.0.12 → 6.0.0-alpha.0

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

@@ -1,7 +1,7 @@
-import { EntityManager, getRepository } from 'typeorm'
+import { EntityManager, getConnection } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { ReleaseGood, OrderInventory } from '@things-factory/sales-base'
+import { OrderInventory, ReleaseGood } from '@things-factory/sales-base'
 import { Setting } from '@things-factory/setting-base'
 import { Domain } from '@things-factory/shell'
 
@@ -11,23 +11,26 @@ import { pickingWorksheet } from '../picking-worksheet'
 import { activatePicking } from './activate-picking'
 
 export const fetchAndAssignPickingTaskResolver = {
-  async fetchAndAssignPickingTask(_: any, {}, context: any) {
+  async fetchAndAssignPickingTask(_: any, {}, context: ResolverContext) {
     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'] })
+      const { tx, domain, user } = context.state
+      const assignee: User = await tx.getRepository(User).findOne({
+        where: { id: user.id },
+        relations: ['domains']
+      })
       if ((assignee?.domains || []).every((userDomain: Domain) => userDomain.id !== domain.id))
         throw new Error('Target user is not belong to current domain')
 
       if (!assignee) throw new Error('failed to find target user')
 
-      let worksheet: any
+      let worksheet: Worksheet
       let worksheetQb = await tx
         .getRepository(Worksheet)
         .createQueryBuilder('ws')
         .select('ws.id')
         .addSelect('ws.name')
         .addSelect('ws.status')
-        .addSelect('ws.release_good_id')
+        .innerJoinAndSelect('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,50 +53,55 @@ export const fetchAndAssignPickingTaskResolver = {
             .getQuery()
           return 'NOT EXISTS ' + subQuery
         })
+        .orderBy('"rg"."created_at"', 'ASC')
 
-      worksheet = await worksheetQb.getRawOne()
+      worksheet = await worksheetQb.getOne()
 
       if (!worksheet) {
-        let worksheetQb = await tx
-          .getRepository(Worksheet)
-          .createQueryBuilder('ws')
-          .select('ws.id')
-          .addSelect('ws.name')
-          .addSelect('ws.status')
-          .addSelect('ws.release_good_id')
-          .where(
-            '(ws.domain_id = :domain_id AND ws.type = :type AND ws.assignee_id IS NULL AND (ws.status = :status1 OR ws.status = :status2))',
-            {
-              domain_id: domain.id,
-              type: WORKSHEET_TYPE.PICKING,
-              status1: WORKSHEET_STATUS.EXECUTING,
-              status2: WORKSHEET_STATUS.DEACTIVATED
-            }
+        // update and return updated worksheet id
+        let updatedWorksheets = await getConnection().transaction(async (tx2: EntityManager) => {
+          let x = await tx2.getRepository(Worksheet).query(
+            `
+            UPDATE worksheets ws SET assignee_id = $2,
+            updated_at = NOW(),
+            updater_id = $2
+            FROM (
+              SELECT ws.id, ws.name, ws.status, ws.release_good_id FROM worksheets ws
+              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 (
+                SELECT count(id) AS "totalPS"
+                FROM order_inventories oi 
+                WHERE oi.release_good_id = ws.release_good_id AND
+                oi.status = 'PENDING_SPLIT'
+                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]
           )
-          .andWhere(qb => {
-            const subQuery = qb
-              .subQuery()
-              .select('COUNT(*) AS totalPS')
-              .from(OrderInventory, 'OrderInventory')
-              .where('OrderInventory.release_good_id = ws.release_good_id')
-              .andWhere(`OrderInventory.status = 'PENDING_SPLIT'`)
-              .groupBy('OrderInventory.release_good_id')
-              .having('COUNT(*) > 0')
-              .getQuery()
-            return 'NOT EXISTS ' + subQuery
-          })
+          return x[0]
+        })
 
-        worksheet = await worksheetQb.getRawOne()
+        if (updatedWorksheets.length == 0) throw new Error('no suitable worksheet found')
 
-        if (!worksheet) throw new Error('no suitable worksheet found')
-        await getRepository(Worksheet).update({ id: worksheet.ws_id }, { assignee: assignee })
+        // relace worksheet with newly assigned worksheet
+        worksheet = await tx
+          .getRepository(Worksheet)
+          .findOne({ where: { id: updatedWorksheets[0].id }, relations: ['releaseGood'] })
       }
 
-      if (worksheet.ws_status == WORKSHEET_STATUS.DEACTIVATED)
-        await activatePicking(tx, domain, user, worksheet.ws_name)
+      if (worksheet.status == WORKSHEET_STATUS.DEACTIVATED) await activatePicking(tx, domain, user, worksheet.name)
 
       const locationSortingRules: Setting = await tx.getRepository(Setting).findOne({
-        where: { domain, name: 'rule-for-picking-product' }
+        where: { domain: { id: domain.id }, name: 'rule-for-picking-product' }
       })
 
       const sortingRule = JSON.parse(locationSortingRules.value)
@@ -101,7 +109,9 @@ export const fetchAndAssignPickingTaskResolver = {
         return { name: field, desc: sortingRule[field] === 'DESC' }
       })
 
-      const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne(worksheet.release_good_id)
+      const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOneBy({
+        id: worksheet.releaseGood.id
+      })
 
       return await pickingWorksheet(domain, releaseGood.name, locationSortingRule, tx)
     } catch (error) {

package/server/graphql/resolvers/worksheet/picking/my-picking-assignment-status.ts

@@ -1,17 +1,26 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { getRepository, In } from 'typeorm'
+import { In } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
 import { WORKSHEET_STATUS } from '../../../../constants'
 import { Worksheet } from '../../../../entities'
 
 type AssignmentStatusType = { userId: string; pending?: Worksheet[]; picking: Worksheet[] }
 
 export const myPickingAssignmentStatusResolver = {
-  async myPickingAssignmentStatus(_parentObj: void, _params: void, context: any): Promise<AssignmentStatusType> {
-    const { domain, user }: { domain: Domain; user: User } = context.state
+  async myPickingAssignmentStatus(
+    _parentObj: void,
+    _params: void,
+    context: ResolverContext
+  ): Promise<AssignmentStatusType> {
+    const { domain, user } = context.state
 
     const pickingWorksheets: Worksheet[] = await getRepository(Worksheet).find({
-      where: { domain, assignee: user, status: In([WORKSHEET_STATUS.DEACTIVATED, WORKSHEET_STATUS.EXECUTING]) }
+      where: {
+        domain: { id: domain.id },
+        assignee: { id: user.id },
+        status: In([WORKSHEET_STATUS.DEACTIVATED, WORKSHEET_STATUS.EXECUTING])
+      }
     })
 
     return (pickingWorksheets || []).reduce(

package/server/graphql/resolvers/worksheet/picking/picking-assignment-status-by-user.ts

@@ -1,6 +1,8 @@
-import { getDomainUsers, User, Role } from '@things-factory/auth-base'
-import { Domain, ListParam, buildQuery, Sorting} from '@things-factory/shell'
-import { FindManyOptions, getRepository, ILike, In, EntityManager, getManager, SelectQueryBuilder } from 'typeorm'
+import { getManager, SelectQueryBuilder } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { getRepository, ListParam } from '@things-factory/shell'
+
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../../constants'
 import { Worksheet } from '../../../../entities'
 
@@ -12,31 +14,38 @@ export const pickingAssignmentStatusByUsersResolver = {
     params: ListParam,
     context: any
   ): Promise<AssignmentStatusByUserType[]> {
-    
-    const { domain }: { domain: Domain } = context.state
-
-    const nameFilter = params.filters.find(p=>{return p.name == "name"});
-    const emailFilter = params.filters.find(p=>{return p.name == "email"});
-    const roleFilter = params.filters.find(p=>{return p.name == 'roles'});
-
-    const pendingSorter = params.sortings.find(p=>{return p.name == 'pending'});
-    const pickingSorter = params.sortings.find(p=>{return p.name == 'picking'});
+    const { domain } = context.state
 
+    const nameFilter = params.filters.find(p => {
+      return p.name == 'name'
+    })
+    const emailFilter = params.filters.find(p => {
+      return p.name == 'email'
+    })
+    const roleFilter = params.filters.find(p => {
+      return p.name == 'roles'
+    })
 
+    const pendingSorter = params.sortings.find(p => {
+      return p.name == 'pending'
+    })
+    const pickingSorter = params.sortings.find(p => {
+      return p.name == 'picking'
+    })
 
-    const getUserInfoQb:SelectQueryBuilder<User> = await getRepository(User).createQueryBuilder('u')
+    const getUserInfoQb: SelectQueryBuilder<User> = await getRepository(User).createQueryBuilder('u')
 
     getUserInfoQb.select('u.id')
     getUserInfoQb.addSelect('u.name')
     getUserInfoQb.addSelect('u.email')
     getUserInfoQb.addSelect("string_agg(r.name,', ') as roles")
-    getUserInfoQb.innerJoin('u.roles','r')
-    getUserInfoQb.where('r.domain_id = :domainId',{domainId:domain.id})
-    roleFilter? getUserInfoQb.andWhere('r.name ilike :userRole', { userRole: `%${roleFilter.value}%` }) :""
-    nameFilter? getUserInfoQb.andWhere('u.name ilike :userName', { userName: `%${nameFilter.value}%` }) :""
-    emailFilter? getUserInfoQb.andWhere('u.email ilike :userEmail', { userEmail: `%${emailFilter.value}%` }) :""
-    getUserInfoQb.andWhere('r.name not ilike :userR',{userR:`%CLIENT%`})
-    getUserInfoQb.andWhere('u.user_type = :userType',{userType:"user"})
+    getUserInfoQb.innerJoin('u.roles', 'r')
+    getUserInfoQb.where('r.domain_id = :domainId', { domainId: domain.id })
+    roleFilter ? getUserInfoQb.andWhere('r.name ilike :userRole', { userRole: `%${roleFilter.value}%` }) : ''
+    nameFilter ? getUserInfoQb.andWhere('u.name ilike :userName', { userName: `%${nameFilter.value}%` }) : ''
+    emailFilter ? getUserInfoQb.andWhere('u.email ilike :userEmail', { userEmail: `%${emailFilter.value}%` }) : ''
+    getUserInfoQb.andWhere('r.name not ilike :userR', { userR: `%CLIENT%` })
+    getUserInfoQb.andWhere('u.user_type = :userType', { userType: 'user' })
     getUserInfoQb.groupBy('u.id')
     getUserInfoQb.addGroupBy('u.name')
     getUserInfoQb.addGroupBy('u.email')
@@ -47,36 +56,41 @@ export const pickingAssignmentStatusByUsersResolver = {
     getAssignedWSQb.addSelect('u.name')
     getAssignedWSQb.addSelect("sum(case when ws.status='EXECUTING' then 1 else 0 end) as picking")
     getAssignedWSQb.addSelect("sum(case when ws.status='DEACTIVATED' then 1 else 0 end) as pending")
-    getAssignedWSQb.innerJoin('ws.assignee','u')
-    getAssignedWSQb.where('ws.domain_id = :id',{id:domain.id})
-    getAssignedWSQb.andWhere('ws.type IN (:...type)', {type: [WORKSHEET_TYPE.PICKING, WORKSHEET_TYPE.BATCH_PICKING]})
-    getAssignedWSQb.andWhere('ws.status IN (:...status)', {status: [WORKSHEET_STATUS.DEACTIVATED, WORKSHEET_STATUS.EXECUTING]})
+    getAssignedWSQb.innerJoin('ws.assignee', 'u')
+    getAssignedWSQb.where('ws.domain_id = :id', { id: domain.id })
+    getAssignedWSQb.andWhere('ws.type IN (:...type)', { type: [WORKSHEET_TYPE.PICKING, WORKSHEET_TYPE.BATCH_PICKING] })
+    getAssignedWSQb.andWhere('ws.status IN (:...status)', {
+      status: [WORKSHEET_STATUS.DEACTIVATED, WORKSHEET_STATUS.EXECUTING]
+    })
     getAssignedWSQb.groupBy('ws.assignee_id')
     getAssignedWSQb.addGroupBy('u.name')
-    pendingSorter?.desc ? getAssignedWSQb.orderBy('pending','DESC') : ''
-    pickingSorter?.desc ? getAssignedWSQb.orderBy('picking','DESC') : ''
-    pickingSorter && Object.keys(pickingSorter).length == 1 ?getAssignedWSQb.orderBy('picking','ASC') : ''
-    pendingSorter && Object.keys(pendingSorter).length == 1 ? getAssignedWSQb.orderBy('pending','ASC') : ''
+    pendingSorter?.desc ? getAssignedWSQb.orderBy('pending', 'DESC') : ''
+    pickingSorter?.desc ? getAssignedWSQb.orderBy('picking', 'DESC') : ''
+    pickingSorter && Object.keys(pickingSorter).length == 1 ? getAssignedWSQb.orderBy('picking', 'ASC') : ''
+    pendingSorter && Object.keys(pendingSorter).length == 1 ? getAssignedWSQb.orderBy('pending', 'ASC') : ''
 
-
-    const parameter1= getUserInfoQb.getParameters()
+    const parameter1 = getUserInfoQb.getParameters()
     const parameter2 = getAssignedWSQb.getParameters()
 
     const combineParams = Object.assign(parameter1, parameter2)
-  
+
     const combineQb = getManager().createQueryBuilder()
 
     combineQb.select('u.*')
     combineQb.addSelect('coalesce(ws.picking, 0) as picking')
     combineQb.addSelect('coalesce(ws.pending, 0) as pending')
-    combineQb.from("(" + getUserInfoQb.getQuery() + ")","u")
-    combineQb.leftJoin("(" + getAssignedWSQb.getQuery() + ")","ws",' ws.assignee_id = u.u_id')
+    combineQb.from('(' + getUserInfoQb.getQuery() + ')', 'u')
+    combineQb.leftJoin('(' + getAssignedWSQb.getQuery() + ')', 'ws', ' ws.assignee_id = u.u_id')
     combineQb.setParameters(combineParams)
-    
+
     const combineInfo = await combineQb.getRawMany()
 
     return combineInfo.map(itm => {
-      return { user: { id:itm.u_id,email:itm.u_email,name:itm.u_name, description: itm.roles },pending:itm.pending,picking:itm.picking }
+      return {
+        user: { id: itm.u_id, email: itm.u_email, name: itm.u_name, description: itm.roles },
+        pending: itm.pending,
+        picking: itm.picking
+      } as any
     })
   }
 }

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

@@ -1,6 +1,8 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { PickingWorksheetController } from '../../../../controllers'
 
 export const pickingResolver = {
@@ -9,7 +11,7 @@ export const pickingResolver = {
     { worksheetDetailName, worksheetType, palletId, locationName, releaseQty, binLocation, serialNumber, toteNo },
     context: any
   ) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
     await picking(
       tx,
       domain,

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

@@ -1,15 +1,17 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 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
+    const { tx, domain, user } = context.state
     await scanProductBatchPicking(
       tx,
       domain,
@@ -19,7 +21,8 @@ export const scanProductBatchPickingResolver = {
       cartonId,
       productBarcode,
       inventory,
-      binLocationName
+      binLocationName,
+      pickingQty
     )
   }
 }
@@ -33,7 +36,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 +46,7 @@ export async function scanProductBatchPicking(
     cartonId,
     productBarcode,
     inventory,
-    binLocationName
+    binLocationName,
+    pickingQty
   )
 }

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

@@ -1,50 +1,25 @@
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
 import { PickingWorksheetController } from '../../../../controllers'
 
 export const scanProductPickingResolver = {
   async scanProductPicking(
     _: any,
-    { worksheetDetailName, worksheetType, productBarcode, cartonId, binLocation, serialNumber, toteNo },
-    context: any
+    { worksheetDetailName, worksheetType, productBarcode, cartonId, binLocation, serialNumber, toteNo, pickingQty },
+    context: ResolverContext
   ) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
-    await scanProductPicking(
-      tx,
-      domain,
-      user,
+    const { tx, domain, user } = context.state
+
+    const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
+    let ws = await worksheetController.scanProductPicking(
       worksheetDetailName,
       worksheetType,
       productBarcode,
       cartonId,
       binLocation,
       serialNumber,
-      toteNo
+      toteNo,
+      pickingQty
     )
-  }
-}
 
-export async function scanProductPicking(
-  tx: EntityManager,
-  domain: Domain,
-  user: User,
-  worksheetDetailName: string,
-  worksheetType: string,
-  productBarcode: string,
-  cartonId: string,
-  binLocation?: string,
-  serialNumber?: string,
-  toteNo?: string
-) {
-  const worksheetController: PickingWorksheetController = new PickingWorksheetController(tx, domain, user)
-  await worksheetController.scanProductPicking(
-    worksheetDetailName,
-    worksheetType,
-    productBarcode,
-    cartonId,
-    binLocation,
-    serialNumber,
-    toteNo
-  )
+    // return await pickingWorksheet(domain, releaseGoodNo, locationSortingRule, tx)
+  }
 }

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

@@ -6,8 +6,8 @@ import { Domain } from '@things-factory/shell'
 import { PickingWorksheetController } from '../../../../controllers'
 
 export const sealToteResolver = {
-  async sealTote(_: any, { sealNo, toteNo, orderNo }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async sealTote(_: any, { sealNo, toteNo, orderNo }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     await sealTote(tx, domain, user, sealNo, toteNo, orderNo)
   }
 }

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

@@ -1,11 +1,17 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { PickingWorksheetController } from '../../../../controllers'
 
 export const undoPickingAssigmentResolver = {
-  async undoPickingAssigment(_: any, { worksheetNo, batchId, productId, packingType, packingSize }, context: any): Promise<void> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async undoPickingAssigment(
+    _: any,
+    { worksheetNo, batchId, productId, packingType, packingSize },
+    context: ResolverContext
+  ): Promise<void> {
+    const { tx, domain, user } = context.state
     await undoPickingAssigment(tx, domain, user, worksheetNo, batchId, productId, packingType, packingSize)
   }
 }

package/server/graphql/resolvers/worksheet/picking/undo-serial-number-picking.ts

@@ -6,8 +6,8 @@ import { Domain } from '@things-factory/shell'
 import { PickingWorksheetController } from '../../../../controllers'
 
 export const undoSerialNumberPickingResolver = {
-  async undoSerialNumberPicking(_: any, { worksheetDetailName, inventoryItemId }, context: any) {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async undoSerialNumberPicking(_: any, { worksheetDetailName, inventoryItemId }, context: ResolverContext) {
+    const { tx, domain, user } = context.state
     await undoSerialNumberPicking(tx, domain, user, worksheetDetailName, inventoryItemId)
   }
 }

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

@@ -2,16 +2,15 @@ import { EntityManager, In, SelectQueryBuilder } from 'typeorm'
 
 import { ORDER_INVENTORY_STATUS, OrderInventory, ReleaseGood, ShippingOrder } from '@things-factory/sales-base'
 import { Domain } from '@things-factory/shell'
-import { Inventory, Location, InventoryChange } from '@things-factory/warehouse-base'
+import { Inventory, InventoryChange, Location } from '@things-factory/warehouse-base'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { WorksheetDetail } from '../../../entities'
 import { fetchExecutingWorksheet } from '../../../utils'
-import { VasOrderWorksheet } from 'server/graphql/types/worksheet/vas-order-worksheet'
 
 export const pickingWorksheetResolver = {
-  async pickingWorksheet(_: any, { releaseGoodNo, locationSortingRules }, context: any) {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+  async pickingWorksheet(_: any, { releaseGoodNo, locationSortingRules }, context: ResolverContext) {
+    const { domain, tx } = context.state
 
     return await pickingWorksheet(domain, releaseGoodNo, locationSortingRules, tx)
   }
@@ -24,19 +23,19 @@ export async function pickingWorksheet(
   tx: EntityManager
 ) {
   let releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-    where: { domain, name: releaseGoodNo /*status: ORDER_STATUS.PICKING*/ },
+    where: { domain: { id: domain.id }, name: releaseGoodNo /*status: ORDER_STATUS.PICKING*/ },
     relations: ['bizplace', 'bizplace.domain']
   })
 
   // Find Release Order based on Bin
   if (!releaseGood) {
     const binLocation: Location = await tx.getRepository(Location).findOne({
-      where: { domain, name: releaseGoodNo }
+      where: { domain: { id: domain.id }, name: releaseGoodNo }
     })
 
     const orderInventoryByBin: OrderInventory = await tx.getRepository(OrderInventory).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         binLocation,
         status: In([ORDER_INVENTORY_STATUS.PICKING, ORDER_INVENTORY_STATUS.PICKED])
       },
@@ -100,6 +99,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 +113,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 +138,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/proceed-extra-products.ts

@@ -1,10 +1,6 @@
-import { EntityManager } from 'typeorm'
-
-import { Role, User } from '@things-factory/auth-base'
+import { Role } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
-import { sendNotification } from '@things-factory/notification'
 import { ArrivalNotice, ORDER_PRODUCT_STATUS, ORDER_STATUS, OrderProduct } from '@things-factory/sales-base'
-import { Domain } from '@things-factory/shell'
 
 import { WORKSHEET_STATUS, WORKSHEET_TYPE } from '../../../constants'
 import { Worksheet, WorksheetDetail } from '../../../entities'
@@ -18,7 +14,7 @@ export const proceedExtraProductsResolver = {
     { ganNo, bizplaceId, approvedProducts, rejectedProducts },
     context: any
   ): Promise<void> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
     const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
       where: {
@@ -28,7 +24,7 @@ export const proceedExtraProductsResolver = {
 
     let arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         bizplace: customerBizplace,
         name: ganNo,
         status: ORDER_STATUS.PENDING_APPROVAL
@@ -41,7 +37,7 @@ export const proceedExtraProductsResolver = {
     // Create worksheet details with approved order products
     const worksheet: Worksheet = await tx.getRepository(Worksheet).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         arrivalNotice,
         type: WORKSHEET_TYPE.UNLOADING
       }
@@ -147,7 +143,7 @@ export const proceedExtraProductsResolver = {
             bizplace: customerBizplace,
             worksheet,
             name: WorksheetNoGenerator.unloadingDetail(),
-            targetProduct: await tx.getRepository(OrderProduct).findOne(targetProduct.id),
+            targetProduct: await tx.getRepository(OrderProduct).findOneBy({ id: targetProduct.id }),
             type: WORKSHEET_TYPE.UNLOADING,
             status:
               worksheet.status === WORKSHEET_STATUS.EXECUTING
@@ -231,10 +227,14 @@ export const proceedExtraProductsResolver = {
         data: { url: context.header.referer }
       }
 
-      await sendNotification({
-        receivers,
-        message: { ...msg }
-      })
+      /**
+       * @notes Temporary off sendNotification due to suspect of causing wms down
+       */
+
+      // await sendNotification({
+      //   receivers,
+      //   message: { ...msg }
+      // })
     }
   }
 }

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

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