@things-factory/sales-base 4.3.212 → 4.3.214

package/server/service/arrival-notice/arrival-notice-mutation.ts

@@ -50,7 +50,6 @@ export class ArrivalNoticeMutation {
   @Mutation(returns => Boolean)
   async deleteArrivalNotice(@Arg('name') name: string, @Ctx() context: any): Promise<Boolean> {
     const { tx, user, domain }: { tx: EntityManager; user: User; domain: Domain } = context.state
-
     return await deleteArrivalNotice(tx, name, user, domain)
   }
 
@@ -81,7 +80,6 @@ export class ArrivalNoticeMutation {
   async confirmArrivalNotice(@Arg('name') name: string, @Ctx() context: any): Promise<ArrivalNotice> {
     const { tx }: { tx: EntityManager } = context.state
     const arrivalNotice: ArrivalNotice = await confirmArrivalNoticeFunction(name, context, tx)
-
     // If current GAN has cross docking
     if (arrivalNotice.crossDocking) {
       const { releaseGood } = await tx.getRepository(ArrivalNotice).findOne(arrivalNotice.id, {
@@ -399,55 +397,65 @@ export async function deleteArrivalNotice(
   user: User,
   domain: Domain
 ): Promise<boolean> {
-  let foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-    where: { domain, name },
-    relations: ['bizplace', 'releaseGood', 'orderProducts', 'orderVass', 'collectionOrders', 'creator', 'updater']
-  })
+  try {
+    let foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
+      where: { domain, name },
+      relations: ['bizplace', 'releaseGood', 'orderProducts', 'orderVass', 'collectionOrders', 'creator', 'updater']
+    })
+    if (!foundArrivalNotice) throw new Error(`Arrival notice doesn't exists.`)
 
-  if (!foundArrivalNotice) throw new Error(`Arrival notice doesn't exists.`)
+    const foundJS: JobSheet = await tx.getRepository(JobSheet).findOne({
+      where: {
+        bizplace: foundArrivalNotice.bizplace,
+        arrivalNoticeRefNo: foundArrivalNotice.name
+      }
+    })
 
-  const foundJS: JobSheet = await tx.getRepository(JobSheet).findOne({
-    where: {
-      bizplace: foundArrivalNotice.bizplace,
-      arrivalNoticeRefNo: foundArrivalNotice.name
+    if (foundJS) {
+      await tx.getRepository(JobSheet).createQueryBuilder()
+        .delete()
+        .from(JobSheet)
+        .where('id = :id', { id: foundJS.id })
+        .execute()
     }
-  })
-
-  if (foundJS) await tx.getRepository(JobSheet).delete({ arrivalNoticeRefNo: foundArrivalNotice.name })
 
-  const foundOPs: OrderProduct[] = foundArrivalNotice.orderProducts
-  const foundOVs: OrderVas[] = foundArrivalNotice.orderVass
+    const foundOPs: OrderProduct[] = foundArrivalNotice.orderProducts
+    const foundOVs: OrderVas[] = foundArrivalNotice.orderVass
 
-  // 1. delete order products
-  const productIds = foundOPs.map((product: OrderProduct) => product.id)
-  if (productIds.length) {
-    await tx.getRepository(OrderProduct).delete({ id: In(productIds) })
-  }
+    // 1. delete order products
+    await tx.getRepository(OrderProduct).createQueryBuilder('op')
+      .delete()
+      .from(OrderProduct)
+      .where('arrival_notice_id = :arrivalNoticeId', { arrivalNoticeId: foundArrivalNotice.id })
+      .execute()
 
-  // 2. delete order vass
-  const vasIds = foundOVs.map((vas: OrderVas) => vas.id)
-  if (vasIds.length) {
-    await tx.getRepository(OrderVas).delete({ id: In(vasIds) })
-  }
+    // 2. delete order vass
+    const vasIds = foundOVs.map((vas: OrderVas) => vas.id)
+    if (vasIds.length) {
+      await tx.getRepository(OrderVas).delete({ id: In(vasIds) })
+    }
 
-  await tx.getRepository(ArrivalNotice).save({
-    ...foundArrivalNotice,
-    updater: user
-  })
+    await tx.getRepository(ArrivalNotice).save({
+      ...foundArrivalNotice,
+      updater: user
+    })
 
-  // 4. Remove relation with RO if it's cross docking
-  if (foundArrivalNotice.crossDocking && foundArrivalNotice.releaseGood?.id) {
-    let releaseGood: ReleaseGood = foundArrivalNotice.releaseGood
-    releaseGood.arrivalNotice = null
-    releaseGood = await tx.getRepository(ReleaseGood).save(releaseGood)
+    // 4. Remove relation with RO if it's cross docking
+    if (foundArrivalNotice.crossDocking && foundArrivalNotice.releaseGood?.id) {
+      let releaseGood: ReleaseGood = foundArrivalNotice.releaseGood
+      releaseGood.arrivalNotice = null
+      releaseGood = await tx.getRepository(ReleaseGood).save(releaseGood)
 
-    await tx.getRepository(ArrivalNotice).delete({ domain, name })
-    await deleteReleaseGood(tx, releaseGood.name, user, domain)
-  } else {
-    // 5. delete GAN
-    await tx.getRepository(ArrivalNotice).delete({ domain, name })
+      await tx.getRepository(ArrivalNotice).delete({ domain, name })
+      await deleteReleaseGood(tx, releaseGood.name, user, domain)
+    } else {
+      // 5. delete GAN
+      await tx.getRepository(ArrivalNotice).delete({ domain, name })
+    }
+    return true
+  } catch (e) {
+    console.log(e)
   }
-  return true
 }
 
 export async function generateArrivalNoticeFunction(
@@ -567,122 +575,127 @@ export async function confirmArrivalNoticeFunction(
   context: any,
   tx?: EntityManager
 ): Promise<ArrivalNotice> {
-  const { user, domain }: { user: User; domain: Domain } = context.state
+  try {
+    const { user, domain }: { user: User; domain: Domain } = context.state
 
-  const foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
-    where: { domain, name, status: ORDER_STATUS.PENDING },
-    relations: [
-      'bizplace',
-      'bizplace.domain',
-      'releaseGood',
-      'orderProducts',
-      'orderProducts.product',
-      'orderVass',
-      'orderVass.vas',
-      'creator',
-      'updater'
-    ]
-  })
+    const foundArrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
+      where: { domain, name, status: ORDER_STATUS.PENDING },
+      relations: [
+        'bizplace',
+        'bizplace.domain',
+        'releaseGood',
+        'orderProducts',
+        'orderProducts.product',
+        'orderVass',
+        'orderVass.vas',
+        'creator',
+        'updater'
+      ]
+    })
 
-  let foundOPs: OrderProduct[] = foundArrivalNotice.orderProducts
-  let foundOVs: OrderVas[] = foundArrivalNotice.orderVass
-  let customerBizplace: Bizplace = foundArrivalNotice.bizplace
-  let opStatus = ORDER_PRODUCT_STATUS.PENDING_RECEIVE
-  let anStatus = ORDER_STATUS.PENDING_RECEIVE
-  let ovStatus = ORDER_VAS_STATUS.PENDING_RECEIVE
-  let acceptedByUser = null
-  let acceptedTime = null
-
-  const ganProcessingSetting: Setting = await tx.getRepository(Setting).findOne({
-    where: { domain, category: 'id-rule', name: 'gan-order-processing' }
-  })
+    let foundOPs: OrderProduct[] = foundArrivalNotice.orderProducts
+    let foundOVs: OrderVas[] = foundArrivalNotice.orderVass
+    let customerBizplace: Bizplace = foundArrivalNotice.bizplace
+    let opStatus = ORDER_PRODUCT_STATUS.PENDING_RECEIVE
+    let anStatus = ORDER_STATUS.PENDING_RECEIVE
+    let ovStatus = ORDER_VAS_STATUS.PENDING_RECEIVE
+    let acceptedByUser = null
+    let acceptedTime = null
 
-  const partnerGanProcessingSetting: PartnerSetting = await tx.getRepository(PartnerSetting).findOne({
-    where: { setting: ganProcessingSetting, domain, partnerDomain: customerBizplace?.domain }
-  })
+    const ganProcessingSetting: Setting = await tx.getRepository(Setting).findOne({
+      where: { domain, category: 'id-rule', name: 'gan-order-processing' }
+    })
 
-  // If status of GAN is PENDING_RECEIVE then directly to assign warehouse
-  if (ganProcessingSetting) {
-    let setting = !isNaN(partnerGanProcessingSetting?.value)
-      ? partnerGanProcessingSetting?.value
-      : ganProcessingSetting.value
-
-    // CONFIRM to assign if setting value is 1
-    if (setting == 1) {
-      opStatus = ORDER_PRODUCT_STATUS.ARRIVED
-      anStatus = ORDER_STATUS.ARRIVED
-      ovStatus = ORDER_VAS_STATUS.ARRIVED
-      acceptedByUser = user
-      acceptedTime = new Date()
-    }
-  }
+    const partnerGanProcessingSetting: PartnerSetting = await tx.getRepository(PartnerSetting).findOne({
+      where: { setting: ganProcessingSetting, domain, partnerDomain: customerBizplace?.domain }
+    })
 
-  if (!foundArrivalNotice) throw new Error(`Arrival notice doesn't exists.`)
+    // If status of GAN is PENDING_RECEIVE then directly to assign warehouse
 
-  // 1. GAN Status change (PENDING => PENDING_RECEIVE)
-  let arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).save({
-    ...foundArrivalNotice,
-    status: anStatus,
-    updater: user,
-    acceptedBy: acceptedByUser,
-    acceptedAt: acceptedTime
-  })
+    if (ganProcessingSetting) {
+      let setting = !isNaN(partnerGanProcessingSetting?.value)
+        ? partnerGanProcessingSetting?.value
+        : ganProcessingSetting.value
 
-  foundOPs = foundOPs.map((op: OrderProduct) => {
-    return { ...op, status: opStatus }
-  })
-  await tx.getRepository(OrderProduct).save(foundOPs)
+      // CONFIRM to assign if setting value is 1
+      if (setting == 1) {
+        opStatus = ORDER_PRODUCT_STATUS.ARRIVED
+        anStatus = ORDER_STATUS.ARRIVED
+        ovStatus = ORDER_VAS_STATUS.ARRIVED
+        acceptedByUser = user
+        acceptedTime = new Date()
+      }
+    }
 
-  // 2. Update order vas status if it exists.
-  if (foundOVs && foundOVs.length) {
-    foundOVs = foundOVs.map((ov: OrderVas) => {
-      return { ...ov, status: ovStatus }
+    if (!foundArrivalNotice) throw new Error(`Arrival notice doesn't exists.`)
+
+    // 1. GAN Status change (PENDING => PENDING_RECEIVE)
+    await tx.getRepository(ArrivalNotice).update({ id: foundArrivalNotice.id }, {
+      status: anStatus,
+      updater: user,
+      acceptedBy: acceptedByUser,
+      acceptedAt: acceptedTime
     })
 
-    await tx.getRepository(OrderVas).save(foundOVs)
-  }
+    let arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({ where: { id: foundArrivalNotice.id } })
 
-  // notification logics
-  // get Office Admin Users
-  if (context?.state?.type != 'api') {
-    const users: any[] = await tx
-      .getRepository('users_roles')
-      .createQueryBuilder('ur')
-      .select('ur.users_id', 'id')
-      .where(qb => {
-        const subQuery = qb
-          .subQuery()
-          .select('role.id')
-          .from(Role, 'role')
-          .where("role.name = 'Office Admin'")
-          .andWhere('role.domain_id = :domain', { domain: domain.id })
-          .getQuery()
-        return 'ur.roles_id IN ' + subQuery
-      })
-      .getRawMany()
+    await tx.getRepository(OrderProduct).createQueryBuilder()
+      .update(OrderProduct)
+      .set({ status: opStatus })
+      .whereInIds(foundOPs.map(op => op.id))
+      .execute();
 
-    // send notification to Office Admin Users
-    if (users?.length && context.header?.referer) {
-      const receivers: any[] = users.map(user => user.id)
-      const msg = {
-        title: `New Arrival Notice from ${customerBizplace.name}`,
-        body: `New incoming order, ${foundArrivalNotice.name} is pending for receiving`,
-        url: context.header.referer,
-        data: { url: context.header.referer }
-      }
+    // 2. Update order vas status if it exists.
+    if (foundOVs && foundOVs.length) {
+      foundOVs = foundOVs.map((ov: OrderVas) => {
+        return { ...ov, status: ovStatus }
+      })
 
-      /**
-       * @notes Temporary off sendNotification due to suspect of causing wms down
-       */
+      await tx.getRepository(OrderVas).save(foundOVs)
+    }
 
-      // await sendNotification({
-      //   receivers,
-      //   message: { ...msg }
-      // })
+    // notification logics
+    // get Office Admin Users
+    if (context?.state?.type != 'api') {
+      const users: any[] = await tx
+        .getRepository('users_roles')
+        .createQueryBuilder('ur')
+        .select('ur.users_id', 'id')
+        .where(qb => {
+          const subQuery = qb
+            .subQuery()
+            .select('role.id')
+            .from(Role, 'role')
+            .where("role.name = 'Office Admin'")
+            .andWhere('role.domain_id = :domain', { domain: domain.id })
+            .getQuery()
+          return 'ur.roles_id IN ' + subQuery
+        })
+        .getRawMany()
+      // send notification to Office Admin Users
+      if (users?.length && context.header?.referer) {
+        const receivers: any[] = users.map(user => user.id)
+        const msg = {
+          title: `New Arrival Notice from ${customerBizplace.name}`,
+          body: `New incoming order, ${foundArrivalNotice.name} is pending for receiving`,
+          url: context.header.referer,
+          data: { url: context.header.referer }
+        }
+        /**
+         * @notes Temporary off sendNotification due to suspect of causing wms down
+         */
+
+        // await sendNotification({
+        //   receivers,
+        //   message: { ...msg }
+        // })
+      }
     }
-  }
 
-  return arrivalNotice
+    return arrivalNotice
+  } catch (e) {
+    console.log(e)
+  }
 }
 
 export async function receiveArrivalNoticeFunction(_: any, name: String, context: any): Promise<ArrivalNotice> {
@@ -953,8 +966,8 @@ export async function rejectArrivalNotice(
     }
 
     /**
-     * @notes Temporary off sendNotification due to suspect of causing wms down
-     */
+ * @notes Temporary off sendNotification due to suspect of causing wms down
+ */
 
     // await sendNotification({
     //   receivers,
@@ -972,8 +985,6 @@ export async function addArrivalNoticeProducts(
   user: User,
   tx?: EntityManager
 ): Promise<void> {
-  const productRepo: Repository<Product> = tx?.getRepository(Product) || getRepository(Product)
-  const productDetailRepo: Repository<ProductDetail> = tx?.getRepository(ProductDetail) || getRepository(ProductDetail)
   const orderProductRepo: Repository<OrderProduct> = tx?.getRepository(OrderProduct) || getRepository(OrderProduct)
 
   if (!arrivalNotice?.bizplace || !arrivalNotice?.orderProducts?.length) {
@@ -983,23 +994,44 @@ export async function addArrivalNoticeProducts(
     })
   }
 
-  const createdOrderProducts: OrderProduct[] = await Promise.all(
-    newOrderProducts.map(async (op: OrderProduct) => {
-      return {
-        ...op,
-        domain,
-        bizplace: arrivalNotice.bizplace,
-        name: OrderNoGenerator.orderProduct(),
-        product: await productRepo.findOne(op.product.id),
-        productDetail: await productDetailRepo.findOne(op.productDetail.id),
-        arrivalNotice,
-        creator: user
-      }
+  let createdOrderProducts: any[] = []
+
+  for (let index = 0; index < newOrderProducts.length; index++) {
+    const op = newOrderProducts[index];
+
+    createdOrderProducts.push({
+      name: OrderNoGenerator.orderProduct(),
+      product_id: op.product.id,
+      product_detail_id: op.productDetail.id,
+      batch_id: op.batchId,
+      batch_id_ref: op.batchIdRef,
+      packing_type: op.packingType,
+      packing_size: op.packingSize,
+      uom: op.uom,
+      uom_value: op.uomValue,
+      pack_qty: op.packQty,
+      total_uom_value: op.totalUomValue,
+      unit_price: op.unitPrice,
+      remark: op.remark,
+      manufacture_date: op.manufactureDate,
+      status: op.status,
+      domain_id: domain.id,
+      bizplace_id: arrivalNotice?.bizplaceId || arrivalNotice?.bizplace?.id || arrivalNotice?.bizplace,
+      arrival_notice_id: arrivalNotice.id,
+      creator_id: user.id,
+      updater_id: user.id
+
     })
-  )
+  }
 
-  debug('gan-created-order-products', createdOrderProducts)
-  await orderProductRepo.save(createdOrderProducts)
+  await orderProductRepo.query(
+    `
+    INSERT INTO order_products ("name", "product_detail_id", "product_id", "batch_id", "batch_id_ref", "packing_type", "packing_size", "uom", "uom_value", "pack_qty", "total_uom_value", "unit_price", "remark", "manufacture_date", "status", "domain_id", "bizplace_id", "arrival_notice_id", "creator_id", "updater_id")
+    SELECT "name", "product_detail_id", "product_id", "batch_id", "batch_id_ref", "packing_type", "packing_size", "uom", "uom_value", "pack_qty", "total_uom_value", "unit_price", "remark", "manufacture_date", "status", "domain_id", "bizplace_id", "arrival_notice_id", "creator_id", "updater_id"
+    FROM JSON_POPULATE_RECORDSET(NULL::order_products, $1) op
+  `,
+    [JSON.stringify(createdOrderProducts)]
+  )
 }
 
 export async function editArrivalNoticeProducts(

package/server/service/arrival-notice/arrival-notice-query.ts

@@ -49,12 +49,16 @@ export class ArrivalNoticeQuery {
 
     //separate query to improve typeorm mapping performance. Search for Related Order Product
     let orderProducts = await getRepository(OrderProduct).find({ where: { arrivalNotice: foundGAN }, relations: ['product', 'productDetail'] })
-    foundGAN.orderProducts = orderProducts
-
+    foundGAN.orderProducts = await Promise.all(orderProducts.map(async (orderProduct) => {
+      orderProduct.unitPrice = orderProduct?.unitPrice ? parseFloat(orderProduct.unitPrice.toFixed(2)) : null;
+      orderProduct.adjustedUnitPrice = orderProduct?.adjustedUnitPrice ? parseFloat(orderProduct.adjustedUnitPrice.toFixed(2)) : null;
+      return orderProduct;
+    }))
+    
     //separate query to improve typeorm mapping performance. Search for Related Order Inventory
     let orderInventories = await getRepository(OrderInventory).find({ where: { arrivalNotice: foundGAN }, relations: ['inventory', 'inventory.product', 'inventory.location'] })
     foundGAN.orderInventories = orderInventories
-
+    
     if (name && !foundGAN) throw new Error(`Failed to find arrival notice with ${name}`)
 
     if (foundGAN) {
@@ -75,41 +79,6 @@ export class ArrivalNoticeQuery {
           }
         })
         : []
-
-      // add productDetails data to orderProduct.product
-      foundGAN.orderProducts = await Promise.all(
-        foundGAN.orderProducts.map(async (orderProduct: OrderProduct) => {
-          orderProduct.product['productDetails'] = await getRepository(ProductDetail).find({
-            where: {
-              product: orderProduct.product.id,
-              packingType: orderProduct.packingType,
-              packingSize: orderProduct.packingSize
-            }
-          })
-          orderProduct.unitPrice = orderProduct?.unitPrice ? parseFloat(orderProduct.unitPrice.toFixed(2)) : null
-          orderProduct.adjustedUnitPrice = orderProduct?.adjustedUnitPrice
-            ? parseFloat(orderProduct.adjustedUnitPrice.toFixed(2))
-            : null
-          return orderProduct
-        })
-      )
-
-      // add productDetails data to orderInventory.inventory.product if orderInventory is exist
-      if (foundGAN.orderInventories && foundGAN.orderInventories.length) {
-        foundGAN.orderInventories = await Promise.all(
-          foundGAN.orderInventories.map(async (orderInventory: OrderInventory) => {
-            orderInventory.inventory.product['productDetails'] = await getRepository(ProductDetail).find({
-              where: {
-                product: orderInventory.inventory.product.id,
-                packingType: orderInventory.inventory.packingType,
-                packingSize: orderInventory.inventory.packingSize
-              }
-            })
-            return orderInventory
-          })
-        )
-      }
-
       return {
         ...foundGAN,
         attachment: [...foundPOAttachments, ...foundAttachments]

package/server/service/draft-release-good/draft-release-good-query.ts

@@ -354,7 +354,7 @@ export async function getDraftReleaseGoodFunction(_: any, name: any, context: an
         remainUomValueWithUom: foundProductInv ? foundProductInv.remainUomValueWithUom : 0,
         status: foundProductInv?.transferQty
           ? DRAFT_RELEASE_ORDER_STATUS.TRANSFER
-          : foundProductInv?.remainQty || 0 < itm.releaseQty
+          : (foundProductInv?.remainQty || 0) < itm.releaseQty
           ? DRAFT_RELEASE_ORDER_STATUS.INSUFFICIENT
           : DRAFT_RELEASE_ORDER_STATUS.DRAFT
       }

package/server/service/order-inventory/order-inventory.ts

@@ -66,6 +66,11 @@ import { Replenishment } from '../replenishment/replenishment'
   orderInventory.uom
 ])
 @Index('ix_order-inventory_5', (orderInventory: OrderInventory) => [orderInventory.releaseGood])
+
+
+@Index('ix_order-inventory_6', (orderInventory: OrderInventory) => [orderInventory.id], {
+  unique: true
+})
 @ObjectType()
 export class OrderInventory {
   @PrimaryGeneratedColumn('uuid')