@things-factory/sales-base 5.0.13 → 6.0.0-alpha.1

package/server/service/release-good/release-good-mutation.ts

@@ -1,7 +1,7 @@
 import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
 import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, getConnection, getRepository, In, Not, Repository } from 'typeorm'
+import { EntityManager, getConnection, In, Not, Repository } from 'typeorm'
 
 import { Attachment, createAttachments } from '@things-factory/attachment-base'
 import { Partner, Role, User } from '@things-factory/auth-base'
@@ -18,15 +18,16 @@ import { MarketplaceStore } from '@things-factory/integration-marketplace'
 import { Sellercraft, SellercraftStatus } from '@things-factory/integration-sellercraft'
 import { Sftp } from '@things-factory/integration-sftp'
 import { MarketplaceOrder, MarketplaceProductVariation } from '@things-factory/marketplace-base'
-import { sendNotification } from '@things-factory/notification'
 import { Product, ProductBundleSetting } from '@things-factory/product-base'
 import { PartnerSetting, Setting } from '@things-factory/setting-base'
-import { Domain } from '@things-factory/shell'
+import { Domain, getRepository } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
 
+// import { NewOrderProduct } from '../order-product/order-product-types'
 import {
   ATTACHMENT_TYPE,
   ORDER_INVENTORY_STATUS,
+  ORDER_METHOD,
   ORDER_NUMBER_RULE_TYPE,
   ORDER_NUMBER_SETTING_KEY,
   ORDER_PRODUCT_STATUS,
@@ -43,7 +44,7 @@ import { confirmArrivalNoticeFunction, deleteArrivalNotice } from '../arrival-no
 import { OrderInventory } from '../order-inventory/order-inventory'
 import { OrderProduct } from '../order-product/order-product'
 import { OrderVas } from '../order-vas/order-vas'
-import { NewReleaseGood, ReleaseGoodPatch } from '../release-good/release-good-types'
+import { NewReleaseGood, ReleaseGoodPatch, ShippingOrderInfoPatch } from '../release-good/release-good-types'
 import { ShippingOrder } from '../shipping-order/shipping-order'
 import { ShippingOrderPatch } from '../shipping-order/shipping-order-types'
 import { Vas } from '../vas/vas'
@@ -56,7 +57,7 @@ export class ReleaseGoodMutation {
   @Directive('@transaction')
   @Mutation(returns => [ReleaseGood])
   async bulkAddReleaseGoods(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('rawReleaseGoods', type => [NewReleaseGood], { nullable: true }) rawReleaseGoods: NewReleaseGood[],
     @Arg('bizplaceId', type => String) bizplaceId: string
   ): Promise<ReleaseGood[]> {
@@ -69,7 +70,7 @@ export class ReleaseGoodMutation {
 
     const roNoSetting: Setting = await settingRepo.findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         name: ORDER_NUMBER_SETTING_KEY.RO_NUMBER_RULE
       }
     })
@@ -150,18 +151,21 @@ export class ReleaseGoodMutation {
   @Directive('@privilege(category: "order_customer", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteReleaseGood(@Arg('name') name: string, @Ctx() context: any): Promise<Boolean> {
-    const { tx, user, domain }: { tx: EntityManager; user: User; domain: Domain } = context.state
+  async deleteReleaseGood(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Boolean> {
+    const { tx, user, domain } = context.state
     return await deleteReleaseGood(tx, name, user, domain)
   }
 
   @Directive('@privilege(category: "order_customer", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteReleaseGoods(@Arg('names', type => [String]) names: string[], @Ctx() context: any): Promise<Boolean> {
-    const { tx }: { tx: EntityManager } = context.state
+  async deleteReleaseGoods(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<Boolean> {
+    const { tx } = context.state
     await tx.getRepository(ReleaseGood).delete({
-      domain: context.state.domain,
+      domain: { id: context.state.domain.id },
       name: In(names)
     })
     return true
@@ -171,16 +175,19 @@ export class ReleaseGoodMutation {
   @Directive('@transaction')
   @Mutation(returns => ReleaseGood)
   async generateReleaseGood(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('attachments', type => [GraphQLUpload], { nullable: true }) attachments?: FileUpload[],
     @Arg('releaseGood', type => NewReleaseGood, { nullable: true }) releaseGood?: NewReleaseGood,
-    @Arg('shippingOrder', type => ShippingOrderPatch, { nullable: true }) shippingOrder?: ShippingOrderPatch
+    @Arg('shippingOrder', type => ShippingOrderPatch, { nullable: true }) shippingOrder?: ShippingOrderPatch,
+    @Arg('shippingOrderInfo', type => ShippingOrderInfoPatch, { nullable: true })
+    shippingOrderInfo?: ShippingOrderInfoPatch
   ): Promise<ReleaseGood> {
-    const { tx }: { tx: EntityManager } = context.state
+    const { tx } = context.state
     const createdReleaseGood: ReleaseGood = await generateReleaseGoodFunction(
       null,
       releaseGood,
       shippingOrder,
+      shippingOrderInfo,
       attachments,
       context,
       tx
@@ -193,9 +200,11 @@ export class ReleaseGoodMutation {
   @Directive('@transaction')
   @Mutation(returns => ReleaseGood)
   async updateReleaseGoodDetails(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('releaseGood', type => ReleaseGoodPatch, { nullable: true }) releaseGood?: ReleaseGoodPatch,
-    @Arg('shippingOrder', type => ShippingOrderPatch, { nullable: true }) shippingOrder?: ShippingOrderPatch
+    @Arg('shippingOrder', type => ShippingOrderPatch, { nullable: true }) shippingOrder?: ShippingOrderPatch,
+    @Arg('shippingOrderInfo', type => ShippingOrderInfoPatch, { nullable: true })
+    shippingOrderInfo?: ShippingOrderInfoPatch
   ): Promise<ReleaseGood> {
     const { tx, domain, user } = context.state
     let foundReleaseGood = await tx.getRepository(ReleaseGood).findOne({
@@ -208,6 +217,12 @@ export class ReleaseGoodMutation {
     }
 
     // case to update existing shippingOrder
+    if (shippingOrder !== null) {
+      shippingOrder.remark = shippingOrder.exportRemark
+      shippingOrder.containerClosureDateTime = new Date(shippingOrder.containerClosureDate)
+      delete shippingOrder.exportRemark
+    }
+
     if (foundReleaseGood.shippingOrder && shippingOrder) {
       await tx.getRepository(ShippingOrder).update(foundReleaseGood.shippingOrder.id, shippingOrder)
     }
@@ -227,8 +242,9 @@ export class ReleaseGoodMutation {
     }
 
     foundReleaseGood = await tx.getRepository(ReleaseGood).save({
-      ...foundReleaseGood,
+      ...(foundReleaseGood as any),
       ...releaseGood,
+      ...shippingOrderInfo,
       remark: releaseGood?.remark ? releaseGood.remark : null
     })
 
@@ -238,13 +254,14 @@ export class ReleaseGoodMutation {
   @Directive('@privilege(category: "order_customer", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => ReleaseGood)
-  async confirmReleaseGood(@Arg('name') name: string, @Ctx() context: any): Promise<ReleaseGood> {
-    const { tx }: { tx: EntityManager } = context.state
+  async confirmReleaseGood(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ReleaseGood> {
+    const { tx } = context.state
     const releaseGood: ReleaseGood = await confirmReleaseGood(name, context, tx)
 
     // If current RO has cross docking
     if (releaseGood.crossDocking) {
-      const { arrivalNotice } = await tx.getRepository(ReleaseGood).findOne(releaseGood.id, {
+      const { arrivalNotice } = await tx.getRepository(ReleaseGood).findOne({
+        where: { id: releaseGood.id },
         relations: ['arrivalNotice']
       })
 
@@ -260,8 +277,8 @@ export class ReleaseGoodMutation {
   @Directive('@privilege(category: "order_customer", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => ReleaseGood)
-  async receiveReleaseGood(@Arg('name') name: string, @Ctx() context: any): Promise<ReleaseGood> {
-    const { tx }: { tx: EntityManager } = context.state
+  async receiveReleaseGood(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ReleaseGood> {
+    const { tx } = context.state
     const releaseGood: ReleaseGood = await receiveReleaseGood(name, context, tx)
     return releaseGood
   }
@@ -272,9 +289,9 @@ export class ReleaseGoodMutation {
   async rejectReleaseGood(
     @Arg('name') name: string,
     @Arg('patch', type => ReleaseGoodPatch) patch: ReleaseGoodPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ReleaseGood> {
-    const { tx }: { tx: EntityManager } = context.state
+    const { tx } = context.state
 
     return await rejectReleaseGood(tx, context, name, patch.remark)
   }
@@ -282,16 +299,17 @@ export class ReleaseGoodMutation {
   @Directive('@transaction')
   @Mutation(returns => ReleaseGood)
   async addReleaseGood(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('releaseGood', type => NewReleaseGood, { nullable: true }) releaseGood: NewReleaseGood,
     @Arg('shippingOrder', type => ShippingOrderPatch, { nullable: true }) shippingOrder: ShippingOrderPatch,
     @Arg('file', type => GraphQLUpload, { nullable: true }) file: FileUpload
   ): Promise<ReleaseGood> {
-    const { tx }: { tx: EntityManager } = context.state
+    const { tx } = context.state
     const createdRO: ReleaseGood = await generateReleaseGoodFunction(
       null,
       releaseGood,
       shippingOrder,
+      null,
       file,
       context,
       tx
@@ -307,12 +325,15 @@ export class ReleaseGoodMutation {
   @Directive('@privilege(category: "order_customer", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async executeOrderRemark(@Arg('releaseGoodNo') releaseGoodNo: string, @Ctx() context: any): Promise<boolean> {
+  async executeOrderRemark(
+    @Arg('releaseGoodNo') releaseGoodNo: string,
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
     const { domain, tx, user } = context.state
 
     await tx.getRepository(ReleaseGood).update(
       {
-        domain,
+        domain: { id: domain.id },
         name: releaseGoodNo
       },
       {
@@ -328,7 +349,7 @@ export class ReleaseGoodMutation {
 
 export async function deleteReleaseGood(tx: EntityManager, name: string, user: User, domain: Domain): Promise<boolean> {
   let foundReleaseOrder: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-    where: { domain, name },
+    where: { domain: { id: domain.id }, name },
     relations: [
       'arrivalNotice',
       'orderInventories',
@@ -341,7 +362,7 @@ export async function deleteReleaseGood(tx: EntityManager, name: string, user: U
     ]
   })
 
-  if (!foundReleaseOrder) throw new Error(`Arrival notice doesn't exists.`)
+  if (!foundReleaseOrder) throw new Error(`Release order doesn't exists.`)
   const foundOIs: OrderInventory[] = foundReleaseOrder.orderInventories
   const foundOVs: OrderVas[] = foundReleaseOrder.orderVass
   const foundSO: ShippingOrder = foundReleaseOrder.shippingOrder
@@ -350,7 +371,7 @@ export async function deleteReleaseGood(tx: EntityManager, name: string, user: U
   if (foundReleaseOrder?.ownTransport) {
     foundAttachment = await tx.getRepository(Attachment).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         refBy: foundReleaseOrder.id,
         category: ATTACHMENT_TYPE.DELIVERY_ORDER
       }
@@ -361,7 +382,7 @@ export async function deleteReleaseGood(tx: EntityManager, name: string, user: U
   await Promise.all(
     foundOIs.map(async (oi: OrderInventory) => {
       if (oi?.inventory?.id) {
-        oi.inventory = await tx.getRepository(Inventory).findOne(oi.inventory.id)
+        oi.inventory = await tx.getRepository(Inventory).findOneBy({ id: oi.inventory.id })
 
         await tx.getRepository(Inventory).save({
           ...oi.inventory,
@@ -413,13 +434,14 @@ export async function deleteReleaseGood(tx: EntityManager, name: string, user: U
 export async function generateReleaseGoodFunction(
   _: any,
   releaseGood: any,
-  shippingOrder: any,
+  shippingOrder: ShippingOrderPatch,
+  shippingOrderInfo: any,
   attachments: FileUpload[],
-  context: any,
+  context: ResolverContext,
   tx?: EntityManager
 ): Promise<ReleaseGood> {
   try {
-    const { domain, user }: { domain: Domain; user: User } = context.state
+    const { domain, user } = context.state
     const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
 
     // let orderInventories: OrderInventory[] = releaseGood.orderInventories
@@ -429,11 +451,12 @@ export async function generateReleaseGoodFunction(
 
     let bizplace: Bizplace
     let warehouseDomain: Domain = domain
+    let finalOrderInventories: OrderInventory[] = []
 
     if (releaseGood.deliverTo) {
       const deliverTo: ContactPoint = await tx
         .getRepository(ContactPoint)
-        .findOne({ where: { bizplace: releaseGood.deliverTo, domain }, relation: ['bizplace'] })
+        .findOne({ where: { bizplace: releaseGood.deliverTo, domain }, relations: ['bizplace'] })
 
       if (!deliverTo) throw new Error('contact point does not exist')
 
@@ -484,7 +507,7 @@ export async function generateReleaseGoodFunction(
     if (releaseGood.type == 'b2c') {
       const sellercraft: Sellercraft = await tx
         .getRepository(Sellercraft)
-        .findOne({ domain: bizplace.domain, status: SellercraftStatus.ACTIVE })
+        .findOneBy({ domain: bizplace.domain, status: SellercraftStatus.ACTIVE })
 
       let customerAvailableSftp: Sftp = await tx.getRepository(Sftp).findOne({
         where: { domain: bizplace.domain }
@@ -498,7 +521,7 @@ export async function generateReleaseGoodFunction(
         const refNo: string = releaseGood.refNo
         const foundReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
           where: {
-            domain: warehouseDomain,
+            domain: { id: warehouseDomain.id },
             refNo,
             status: Not(In([ORDER_STATUS.CANCELLED, ORDER_STATUS.PENDING_CANCEL]))
           },
@@ -516,7 +539,7 @@ export async function generateReleaseGoodFunction(
             const refNo2: string = releaseGood.refNo2
             const foundSplittedReleaseGood = await tx.getRepository(ReleaseGood).findOne({
               where: {
-                domain: warehouseDomain,
+                domain: { id: warehouseDomain.id },
                 refNo2,
                 status: Not(In([ORDER_STATUS.CANCELLED, ORDER_STATUS.PENDING_CANCEL]))
               },
@@ -535,6 +558,12 @@ export async function generateReleaseGoodFunction(
 
     /** Generate Shipping Order */
     if (shippingOrder) {
+      shippingOrder.remark = shippingOrder.exportRemark
+      if (shippingOrder.containerClosureDate !== undefined) {
+        shippingOrder.containerClosureDateTime = new Date(shippingOrder.containerClosureDate)
+      }
+      delete shippingOrder.exportRemark
+
       const createdSO: ShippingOrder = await tx.getRepository(ShippingOrder).save({
         ...shippingOrder,
         name: OrderNoGenerator.shippingOrder(),
@@ -552,7 +581,7 @@ export async function generateReleaseGoodFunction(
     // find RO number rule setting
     const roNoSetting: Setting = await settingRepo.findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         name: ORDER_NUMBER_SETTING_KEY.RO_NUMBER_RULE
       }
     })
@@ -569,23 +598,35 @@ export async function generateReleaseGoodFunction(
       exportOption: releaseGood.exportOption,
       ownTransport: releaseGood.ownTransport,
       packingOption: releaseGood.packingOption,
+      recall: releaseGood.recall,
       marketplaceOrderStatus: releaseGood?.marketplaceOrderStatus || null,
-      billingAddress: releaseGood?.billingAddress || null,
-      deliverTo: releaseGood?.deliverTo || null,
-      deliveryAddress1: releaseGood?.deliveryAddress1 || null,
+      billingAddress:
+        releaseGood.type == 'b2c' ? releaseGood?.billingAddress || null : shippingOrderInfo.billingAddress || null,
+      deliveryAddress1:
+        releaseGood.type == 'b2c' ? releaseGood?.deliveryAddress1 || null : shippingOrderInfo.deliveryAddress1 || null,
       deliveryAddress2: releaseGood?.deliveryAddress2 || null,
       deliveryAddress3: releaseGood?.deliveryAddress3 || null,
       deliveryAddress4: releaseGood?.deliveryAddress4 || null,
       deliveryAddress5: releaseGood?.deliveryAddress5 || null,
-      attentionTo: releaseGood?.attentionTo || null,
-      attentionCompany: releaseGood?.attentionCompany || null,
-      city: releaseGood?.city || null,
-      state: releaseGood?.state || null,
-      postalCode: releaseGood?.postalCode || null,
-      country: releaseGood?.country || null,
-      phone1: releaseGood?.phone1 || null,
+      attentionTo: releaseGood.type == 'b2c' ? releaseGood?.attentionTo || null : shippingOrderInfo.attentionTo || null,
+      attentionCompany:
+        releaseGood.type == 'b2c' ? releaseGood?.companyName || null : shippingOrderInfo.attentionCompany || null,
+      city: releaseGood.type == 'b2c' ? releaseGood?.city || null : shippingOrderInfo.city || null,
+      state: releaseGood.type == 'b2c' ? releaseGood?.state || null : shippingOrderInfo.state || null,
+      postalCode: releaseGood.type == 'b2c' ? releaseGood?.postalCode || null : shippingOrderInfo.postalCode || null,
+      country: releaseGood.type == 'b2c' ? releaseGood?.country || null : shippingOrderInfo.country || null,
+      phone1: releaseGood.type == 'b2c' ? releaseGood?.phone1 || null : shippingOrderInfo.phone1 || null,
       phone2: releaseGood?.phone2 || null,
       email: releaseGood?.email || null,
+      billingCity: releaseGood.type == 'b2c' ? releaseGood?.billingCity || null : shippingOrderInfo.billingCity || null,
+      billingCountry:
+        releaseGood.type == 'b2c' ? releaseGood?.billingCountry || null : shippingOrderInfo.billingCountry || null,
+      billingPostalCode:
+        releaseGood.type == 'b2c'
+          ? releaseGood?.billingPostalCode || null
+          : shippingOrderInfo.billingPostalCode || null,
+      billingState:
+        releaseGood.type == 'b2c' ? releaseGood?.billingState || null : shippingOrderInfo.billingState || null,
       transporter: releaseGood?.transporter,
       trackingNo: releaseGood?.trackingNo,
       airwayBill: releaseGood?.airwayBill,
@@ -599,7 +640,13 @@ export async function generateReleaseGoodFunction(
       bundleInfo: releaseGood?.bundleInfo || [],
       orderInventories: releaseGood.orderInventories,
       type: releaseGood?.type ? releaseGood.type : 'b2b',
+      orderMethod: releaseGood?.orderMethod
+        ? releaseGood.orderMethod
+        : releaseGood.orderInventories[0]?.inventory?.id
+        ? ORDER_METHOD.SELECT_BY_PALLET
+        : ORDER_METHOD.SELECT_BY_PRODUCT,
       status: ORDER_STATUS.PENDING,
+      packageId: releaseGood?.packageId,
       storeName: releaseGood?.storeName,
       storeId: releaseGood?.storeId,
       routeId: releaseGood?.routeId,
@@ -612,7 +659,7 @@ export async function generateReleaseGoodFunction(
     let crossDockingGAN: ArrivalNotice = undefined
     if (releaseGood.crossDocking && releaseGood.ganNo) {
       crossDockingGAN = await tx.getRepository(ArrivalNotice).findOne({
-        where: { domain, bizplace, name: releaseGood.ganNo, status: ORDER_STATUS.PENDING }
+        where: { domain: { id: domain.id }, bizplace, name: releaseGood.ganNo, status: ORDER_STATUS.PENDING }
       })
       if (!crossDockingGAN) throw new Error(`Failed to find GAN (${releaseGood.ganNo}) for cross docking`)
 
@@ -680,22 +727,11 @@ export async function generateReleaseGoodFunction(
         status: ORDER_INVENTORY_STATUS.PENDING,
         name: OrderNoGenerator.orderInventory(),
         releaseGood: newReleaseGood,
-        product: await tx.getRepository(Product).findOne(oi.product.id),
+        product: await tx.getRepository(Product).findOneBy({ id: oi.product.id }),
         creator: user,
         updater: user
       }
 
-      if (newOrderInv.inventory?.id) {
-        const foundInv: Inventory = await tx.getRepository(Inventory).findOne(newOrderInv.inventory.id)
-        newOrderInv.inventory = foundInv
-
-        foundInv.lockedQty = Number(foundInv.lockedQty) + newOrderInv.releaseQty
-        foundInv.lockedUomValue = Number(foundInv.lockedUomValue) + newOrderInv.releaseUomValue
-        foundInv.updater = user
-
-        await tx.getRepository(Inventory).save(foundInv)
-      }
-
       let newOrderProduct: OrderProduct = Object.assign(new OrderProduct(), newOrderInv)
       newOrderProduct = {
         ...newOrderProduct,
@@ -703,19 +739,81 @@ export async function generateReleaseGoodFunction(
         actualPackQty: 0,
         palletQty: 0,
         actualPalletQty: 0,
-        status: newOrderInv.inventory?.id ? ORDER_PRODUCT_STATUS.ASSIGNED : ORDER_PRODUCT_STATUS.PENDING_ASSIGN
+        status: ORDER_PRODUCT_STATUS.ASSIGNED
       }
 
       newOrderProduct = await tx.getRepository(OrderProduct).save(newOrderProduct)
 
-      await tx.getRepository(OrderInventory).save({ ...newOrderInv, orderProduct: newOrderProduct })
+      if (newOrderInv.inventory?.id) {
+        const foundInv: Inventory = await tx.getRepository(Inventory).findOneBy({ id: newOrderInv.inventory.id })
+        newOrderInv.inventory = foundInv
+        newOrderInv.orderProduct = newOrderProduct
+
+        finalOrderInventories.push(newOrderInv)
+      } else {
+        // Preassign Inventories
+        const inventoryAssignmentSetting: Setting = await tx.getRepository(Setting).findOne({
+          where: { domain: { id: domain.id }, name: 'rule-for-inventory-assignment' }
+        })
+
+        let locationSortingRules = []
+        if (inventoryAssignmentSetting) {
+          let locationSetting = JSON.parse(inventoryAssignmentSetting.value)
+          for (const key in locationSetting) {
+            locationSortingRules.push({ name: key, desc: locationSetting[key] == 'ASC' ? false : true })
+          }
+        }
+
+        let assignedOrderInventories: OrderInventory[] = await InventoryUtil.autoAssignInventoryForRelease(
+          newOrderInv.product,
+          oi,
+          oi.packingType,
+          locationSortingRules,
+          bizplace,
+          warehouseDomain,
+          tx,
+          oi.batchId
+        )
+
+        assignedOrderInventories = assignedOrderInventories.map(aoi => {
+          return {
+            ...aoi,
+            orderProduct: newOrderProduct
+          }
+        })
+
+        finalOrderInventories.push(...assignedOrderInventories)
+      }
+    }
+
+    for (let oi of finalOrderInventories) {
+      let generatedOI: OrderInventory = Object.assign(new OrderInventory(), oi)
+      generatedOI = {
+        ...generatedOI,
+        domain: warehouseDomain,
+        bizplace,
+        status: ORDER_INVENTORY_STATUS.PENDING,
+        name: OrderNoGenerator.orderInventory(),
+        releaseGood: newReleaseGood,
+        creator: user,
+        updater: user
+      }
+
+      await tx.getRepository(OrderInventory).save({ ...generatedOI })
+
+      // update inventory locked qty and uom value
+      await tx.getRepository(Inventory).update({ id: oi.inventory.id }, {
+        lockedQty: (oi.inventory?.lockedQty || 0) + generatedOI.releaseQty,
+        lockedUomValue: (oi.inventory?.lockedUomValue || 0) + generatedOI.releaseUomValue,
+        updater: user
+      } as any)
     }
 
     if (orderVass?.length) {
       orderVass = await Promise.all(
         orderVass.map(async orderVas => {
           if (orderVas?.targetProduct?.id) {
-            orderVas.targetProduct = await tx.getRepository(Product).findOne(orderVas.targetProduct.id)
+            orderVas.targetProduct = await tx.getRepository(Product).findOneBy({ id: orderVas.targetProduct.id })
           }
 
           let newOrderVas: OrderVas = {
@@ -723,7 +821,7 @@ export async function generateReleaseGoodFunction(
             domain: warehouseDomain,
             bizplace,
             name: OrderNoGenerator.releaseVas(),
-            vas: await tx.getRepository(Vas).findOne(orderVas.vas.id),
+            vas: await tx.getRepository(Vas).findOneBy({ id: orderVas.vas.id }),
             type: ORDER_TYPES.RELEASE_OF_GOODS,
             releaseGood: newReleaseGood,
             status: ORDER_VAS_STATUS.PENDING,
@@ -732,7 +830,7 @@ export async function generateReleaseGoodFunction(
           }
 
           if (orderVas?.inventory?.id) {
-            newOrderVas.inventory = await tx.getRepository(Inventory).findOne(orderVas.inventory.id)
+            newOrderVas.inventory = await tx.getRepository(Inventory).findOneBy({ id: orderVas.inventory.id })
           }
 
           return newOrderVas
@@ -755,7 +853,7 @@ export async function generateReleaseGoodFunction(
     }
 
     const directReceiveSetting: Setting = await tx.getRepository(Setting).findOne({
-      where: { domain, category: 'id-rule', name: 'enable-direct-receive-release-order' }
+      where: { domain: { id: domain.id }, category: 'id-rule', name: 'enable-direct-receive-release-order' }
     })
 
     const partnerDirectReceiveSetting: PartnerSetting = await tx.getRepository(PartnerSetting).findOne({
@@ -784,7 +882,7 @@ export async function generateReleaseGoodFunction(
 }
 
 export async function confirmReleaseGood(name: string, context: any, tx?: EntityManager): Promise<ReleaseGood> {
-  const { user, domain }: { user: User; domain: Domain } = context.state
+  const { user, domain } = context.state
 
   let foundReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
     where: { name, status: ORDER_STATUS.PENDING },
@@ -795,13 +893,13 @@ export async function confirmReleaseGood(name: string, context: any, tx?: Entity
 
   // query orderInventories separately from releaseGood to reduce resource usage
   let foundOIs: OrderInventory[] = await tx.getRepository(OrderInventory).find({
-    where: { domain, releaseGood: foundReleaseGood },
+    where: { domain: { id: domain.id }, releaseGood: { id: foundReleaseGood.id } },
     relations: ['product']
   })
 
   // query orderProducts separately from releaseGood to reduce resource usage
   let foundOPs: OrderProduct[] = await tx.getRepository(OrderProduct).find({
-    where: { domain, releaseGood: foundReleaseGood },
+    where: { domain: { id: domain.id }, releaseGood: { id: foundReleaseGood.id } },
     relations: ['bizplace', 'product', 'product.productDetails']
   })
 
@@ -948,10 +1046,15 @@ export async function confirmReleaseGood(name: string, context: any, tx?: Entity
         url: context.header.referer,
         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 }
+      // })
     }
   }
 
@@ -959,10 +1062,10 @@ export async function confirmReleaseGood(name: string, context: any, tx?: Entity
 }
 
 export async function receiveReleaseGood(name: string, context: any, tx: EntityManager): Promise<ReleaseGood> {
-  const { domain, user }: { domain: Domain; user: User } = context.state
+  const { domain, user } = context.state
 
   const foundReleaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-    where: { domain, name, status: ORDER_STATUS.PENDING_RECEIVE },
+    where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING_RECEIVE },
     relations: ['bizplace', 'orderInventories', 'orderVass']
   })
 
@@ -1031,10 +1134,14 @@ export async function receiveReleaseGood(name: string, context: any, tx: EntityM
         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 }
+      // })
     }
   }
 
@@ -1043,14 +1150,14 @@ export async function receiveReleaseGood(name: string, context: any, tx: EntityM
 
 export async function rejectReleaseGood(
   tx: EntityManager,
-  context: any,
+  context: ResolverContext,
   name: string,
   remark: string
 ): Promise<ReleaseGood> {
-  const { domain, user }: { domain: Domain; user: User } = context.state
+  const { domain, user } = context.state
 
   const releaseGood: ReleaseGood = await tx.getRepository(ReleaseGood).findOne({
-    where: { domain, name, status: ORDER_STATUS.PENDING_RECEIVE },
+    where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING_RECEIVE },
     relations: [
       'bizplace',
       'bizplace.domain',
@@ -1077,7 +1184,7 @@ export async function rejectReleaseGood(
       await Promise.all(
         foundOIs.map(async (oi: OrderInventory) => {
           if (oi?.inventory?.id) {
-            oi.inventory = await tx.getRepository(Inventory).findOne(oi.inventory.id)
+            oi.inventory = await tx.getRepository(Inventory).findOneBy({ id: oi.inventory.id })
 
             await tx.getRepository(Inventory).save({
               ...oi.inventory,
@@ -1098,7 +1205,7 @@ export async function rejectReleaseGood(
   if (foundOPs && foundOPs.length) {
     const sellercraft: Sellercraft = await tx
       .getRepository(Sellercraft)
-      .findOne({ domain: releaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
+      .findOneBy({ domain: releaseGood.bizplace.domain, status: SellercraftStatus.ACTIVE })
 
     if (sellercraft) {
       const sellercraftCtrl: SellercraftController = new SellercraftController(tx, domain, user)
@@ -1129,7 +1236,7 @@ export async function rejectReleaseGood(
   if (releaseGood.shippingOrder) {
     // 2. 1) if it's yes update status of collection order
     const shippingOrder: ShippingOrder = await tx.getRepository(ShippingOrder).findOne({
-      where: { domain, name: releaseGood.shippingOrder.name }
+      where: { domain: { id: domain.id }, name: releaseGood.shippingOrder.name }
     })
 
     shippingOrder.status = ORDER_STATUS.REJECTED
@@ -1154,10 +1261,14 @@ export async function rejectReleaseGood(
       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 }
+    // })
   }
 
   return releaseGood
@@ -1173,9 +1284,9 @@ export async function bulkGenerateReleaseGood(
 ): Promise<ReleaseGood> {
   try {
     let warehouseDomain: Domain = domain
-    let { orderInventories } = releaseGood
+    let { orderInventories, shippingOrder } = releaseGood
 
-    let bizplace: Bizplace = await tx.getRepository(Bizplace).findOne(bizplaceId)
+    let bizplace: Bizplace = await tx.getRepository(Bizplace).findOneBy({ id: bizplaceId })
 
     let newReleaseGood: ReleaseGood = {
       ...releaseGood,
@@ -1203,18 +1314,41 @@ export async function bulkGenerateReleaseGood(
       refNo3: releaseGood.refNo3,
       releaseDate: releaseGood.releaseDate,
       ownTransport: releaseGood?.ownTransport || false,
+      orderMethod: ORDER_METHOD.SELECT_BY_PRODUCT,
       status: ORDER_STATUS.PENDING,
       creator: user,
       updater: user
     }
 
     newReleaseGood = await tx.getRepository(ReleaseGood).save(newReleaseGood)
-    let finalOrderInventories: OrderInventory[] = []
+
+    /** Generate Shipping Order */
+    if (shippingOrder) {
+      shippingOrder.remark = shippingOrder.exportRemark
+      if (shippingOrder.containerClosureDate !== undefined) {
+        shippingOrder.containerClosureDateTime = new Date(shippingOrder.containerClosureDate)
+      }
+      delete shippingOrder.exportRemark
+
+      const createdSO: ShippingOrder = await tx.getRepository(ShippingOrder).save({
+        ...shippingOrder,
+        name: OrderNoGenerator.shippingOrder(),
+        domain,
+        bizplace,
+        status: ORDER_STATUS.PENDING,
+        creator: user,
+        updater: user
+      })
+
+      newReleaseGood.shippingOrder = createdSO
+    }
+
+    let finalOrderInventories: Partial<OrderInventory>[] = []
 
     // pre assign inventory to orderInventories
     for (let oi of orderInventories) {
       const pickingProductSetting: Setting = await tx.getRepository(Setting).findOne({
-        where: { domain, name: 'rule-for-picking-product' }
+        where: { domain: { id: domain.id }, name: 'rule-for-picking-product' }
       })
 
       let locationSortingRules = []
@@ -1225,18 +1359,25 @@ export async function bulkGenerateReleaseGood(
         }
       }
 
-      const product: Product = await tx.getRepository(Product).findOne(oi.productId)
+      const product: Product = await tx.getRepository(Product).findOneBy({ id: oi.productId })
+
+      let assignedResult = await InventoryUtil.autoAssignInventoryForRelease(
+        product,
+        oi,
+        oi.packingType,
+        locationSortingRules,
+        bizplace,
+        warehouseDomain,
+        tx
+      )
 
       finalOrderInventories.push(
-        ...(await InventoryUtil.autoAssignInventoryForRelease(
-          product,
-          oi,
-          oi.packingType,
-          locationSortingRules,
-          bizplace,
-          warehouseDomain,
-          tx
-        ))
+        ...assignedResult.map(itm => {
+          return {
+            ...itm,
+            orderProduct: oi?.orderProduct
+          }
+        })
       )
     }
 
@@ -1253,28 +1394,38 @@ export async function bulkGenerateReleaseGood(
         updater: user
       }
 
-      let newOrderProduct: Partial<OrderProduct> = {
-        name: generatedOI.name,
-        product: generatedOI.product,
-        batchId: generatedOI.batchId,
-        packingType: generatedOI.packingType,
-        packingSize: generatedOI.packingSize,
-        uom: generatedOI.uom,
-        domain: warehouseDomain,
-        bizplace,
-        releaseQty: generatedOI.releaseQty,
-        releaseUomValue: generatedOI.releaseUomValue,
-        packQty: 0,
-        actualPackQty: 0,
-        palletQty: 0,
-        actualPalletQty: 0,
-        status: ORDER_PRODUCT_STATUS.PENDING_ASSIGN,
-        releaseGood: newReleaseGood,
-        creator: user,
-        updater: user
-      }
+      let newOrderProduct: Partial<OrderProduct>
+      if (!oi?.orderProduct) {
+        newOrderProduct = {
+          name: generatedOI.name,
+          product: generatedOI.product,
+          batchId: generatedOI.batchId,
+          packingType: generatedOI.packingType,
+          packingSize: generatedOI.packingSize,
+          uom: generatedOI.uom,
+          domain: warehouseDomain,
+          bizplace,
+          releaseQty: generatedOI.releaseQty,
+          releaseUomValue: generatedOI.releaseUomValue,
+          packQty: 0,
+          actualPackQty: 0,
+          palletQty: 0,
+          actualPalletQty: 0,
+          status: ORDER_PRODUCT_STATUS.ASSIGNED,
+          releaseGood: newReleaseGood,
+          creator: user,
+          updater: user
+        }
 
-      newOrderProduct = await tx.getRepository(OrderProduct).save(newOrderProduct)
+        newOrderProduct = await tx.getRepository(OrderProduct).save(newOrderProduct)
+      } else {
+        newOrderProduct = await tx.getRepository(OrderProduct).save({
+          ...oi.orderProduct,
+          totalUomValue: `${oi.orderProduct.releaseUomValue} ${oi.orderProduct.uom}`,
+          status: ORDER_PRODUCT_STATUS.ASSIGNED,
+          updater: user
+        })
+      }
 
       await tx.getRepository(OrderInventory).save({ ...generatedOI, orderProduct: newOrderProduct })
 
@@ -1283,7 +1434,7 @@ export async function bulkGenerateReleaseGood(
         lockedQty: (oi.inventory?.lockedQty || 0) + generatedOI.releaseQty,
         lockedUomValue: (oi.inventory?.lockedUomValue || 0) + generatedOI.releaseUomValue,
         updater: user
-      })
+      } as any)
     }
 
     return newReleaseGood
@@ -1308,7 +1459,7 @@ export async function bulkConfirmReleaseGoods(
   let customerBizplace: Bizplace = foundReleaseGoods[0].bizplace
 
   let foundOrderInventories: OrderInventory[] = await tx.getRepository(OrderInventory).find({
-    where: { domain, releaseGood: In(foundReleaseGoods.map((rg: ReleaseGood) => rg.id)) }
+    where: { domain: { id: domain.id }, releaseGood: In(foundReleaseGoods.map((rg: ReleaseGood) => rg.id)) }
   })
 
   await tx
@@ -1348,10 +1499,15 @@ export async function bulkConfirmReleaseGoods(
         url: context.header.referer,
         data: { url: context.header.referer }
       }
-      await sendNotification({
-        receivers,
-        message
-      })
+
+      /**
+       * @notes Temporary off sendNotification due to suspect of causing wms down
+       */
+
+      // await sendNotification({
+      //   receivers,
+      //   message
+      // })
     }
   }
 
@@ -1359,7 +1515,9 @@ export async function bulkConfirmReleaseGoods(
     foundReleaseGoods.map(async (releaseGood: ReleaseGood) => {
       return {
         ...releaseGood,
-        orderInventories: await tx.getRepository(OrderInventory).find({ where: releaseGood }),
+        orderInventories: await tx
+          .getRepository(OrderInventory)
+          .find({ where: { releaseGood: { id: releaseGood.id } } }) /* CONFIRMME regarding TYPEORM */,
         status: ORDER_STATUS.PENDING_RECEIVE,
         updater: user
       }
@@ -1430,6 +1588,11 @@ function extractRawReleaseGoods(rawReleaseGoods): Partial<ReleaseGood[]> {
         deliveryAddress2: item.deliveryAddress2,
         deliveryAddress3: item.deliveryAddress3,
         deliveryAddress4: item.deliveryAddress4,
+        billingAddress: item.billingAddress,
+        billingCity: item.billingPostalCode,
+        billingState: item.billingState,
+        billingCountry: item.billingCountry,
+        billingPostalCode: item.billingPostalCode,
         city: item.city,
         postalCode: item.postalCode,
         state: item.state,