@things-factory/sales-base 4.0.11 → 4.0.16

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

@@ -6,6 +6,7 @@ import { Attachment, createAttachments } from '@things-factory/attachment-base'
 import { Partner, Role, User } from '@things-factory/auth-base'
 import {
   Bizplace,
+  getCompanyBizplace,
   getDomainUsers,
   getMyBizplace,
   getOutletBizplace,
@@ -43,6 +44,7 @@ import {
   PRODUCT_GROUP_TYPE
 } from '../../constants'
 import { EcommerceController, SellercraftController } from '../../controllers'
+import { ValidationError } from '../../errors'
 import { InventoryUtil, OrderNoGenerator } from '../../utils'
 import { confirmArrivalNoticeFunction, deleteArrivalNotice } from '../arrival-notice/arrival-notice-mutation'
 import { ReleaseGood } from './release-good'
@@ -91,6 +93,51 @@ export class ReleaseGoodMutation {
     return createdReleaseGood
   }
 
+  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => ReleaseGood)
+  async updateReleaseGoodDetails(
+    @Ctx() context: any,
+    @Arg('releaseGood', type => ReleaseGoodPatch, { nullable: true }) releaseGood?: ReleaseGoodPatch,
+    @Arg('shippingOrder', type => ShippingOrderPatch, { nullable: true }) shippingOrder?: ShippingOrderPatch
+  ): Promise<ReleaseGood> {
+    const { tx, domain, user } = context.state
+    let foundReleaseGood = await tx.getRepository(ReleaseGood).findOne({
+      where: { name: releaseGood.name, domain },
+      relations: ['shippingOrder']
+    })
+
+    if (!foundReleaseGood) {
+      throw new Error(`Release order ${releaseGood.name} is not found.`)
+    }
+
+    // case to update existing shippingOrder
+    if (foundReleaseGood.shippingOrder && shippingOrder) {
+      await tx.getRepository(ShippingOrder).update(foundReleaseGood.shippingOrder.id, shippingOrder)
+    }
+    // case for new shippingOrder
+    else if (!foundReleaseGood.shippingOrder && shippingOrder) {
+      let newShippingOrder: ShippingOrder = await tx.getRepository(ShippingOrder).save({
+        ...shippingOrder,
+        name: OrderNoGenerator.shippingOrder(),
+        domain,
+        bizplace: await getMyBizplace(domain, user),
+        status: ORDER_STATUS.PENDING,
+        creator: user,
+        updater: user
+      })
+
+      releaseGood.shippingOrder = newShippingOrder
+    }
+
+    foundReleaseGood = await tx.getRepository(ReleaseGood).save({
+      ...foundReleaseGood,
+      ...releaseGood
+    })
+
+    return foundReleaseGood
+  }
+
   @Directive('@privilege(category: "order_customer", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => ReleaseGood)
@@ -159,6 +206,71 @@ export class ReleaseGoodMutation {
 
     return receivedRO
   }
+
+  @Directive('@transaction')
+  @Mutation(returns => [ReleaseGood])
+  async bulkAddReleaseGoods(
+    @Ctx() context: any,
+    @Arg('rawReleaseGoods', type => [NewReleaseGood], { nullable: true }) rawReleaseGoods: NewReleaseGood[],
+    @Arg('bizplaceId', type => String) bizplaceId: string
+  ): Promise<ReleaseGood[]> {
+    const { domain, user, tx } = context.state
+
+    if (!bizplaceId) throw new Error('company ID is not provided')
+
+    let createdReleaseGoods: ReleaseGood[] = []
+    const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
+
+    const roNoSetting: Setting = await settingRepo.findOne({
+      where: {
+        domain,
+        name: ORDER_NUMBER_SETTING_KEY.RO_NUMBER_RULE
+      }
+    })
+
+    let releaseGoods: Partial<ReleaseGood[]> = extractRawReleaseGoods(rawReleaseGoods)
+
+    for (let i = 0, l = releaseGoods.length; i < l; i++) {
+      // generate release good by group to avoid duplication
+      // if this function is called simultaneously by different users
+      let availableItems: any[] = await bulkReleaseGoodsAvailableItemsFunction(
+        [...releaseGoods[i].orderInventories],
+        bizplaceId,
+        context,
+        tx
+      )
+
+      if (availableItems.some(item => !item.releaseQty || item.releaseQty > item.assignedQty))
+        throw new ValidationError({
+          ...ValidationError.ERROR_CODES.INSUFFICIENT_STOCK,
+          detail: { data: JSON.stringify(availableItems) }
+        })
+
+      // update orderInventories if availableItems are valid
+      releaseGoods[i].orderInventories = availableItems
+
+      const createdReleaseGood: ReleaseGood = await bulkGenerateReleaseGoods(
+        releaseGoods[i],
+        bizplaceId,
+        roNoSetting,
+        domain,
+        user,
+        tx
+      )
+
+      createdReleaseGoods.push(createdReleaseGood)
+    }
+
+    let confirmedReleaseGoods: ReleaseGood[] = await bulkConfirmReleaseGoods(
+      createdReleaseGoods.map(rg => rg.name),
+      domain,
+      user,
+      context,
+      tx
+    )
+
+    return confirmedReleaseGoods
+  }
 }
 
 export async function deleteReleaseGood(tx: EntityManager, name: string, user: User, domain: Domain): Promise<boolean> {
@@ -571,6 +683,193 @@ export async function generateReleaseGoodFunction(
   }
 }
 
+export async function bulkReleaseGoodsAvailableItemsFunction(
+  rawReleaseGoods: any[],
+  bizplaceId: string,
+  context: any,
+  tx?: EntityManager
+): Promise<any[]> {
+  const { domain }: { domain: Domain } = context.state
+  const companyBizplaceId: Bizplace = await getCompanyBizplace(null, null, bizplaceId)
+
+  if (!rawReleaseGoods) return
+
+  const json_oi = JSON.stringify(
+    rawReleaseGoods.map(raw => {
+      return {
+        sku: raw.sku,
+        packing_type: raw.packingType,
+        packing_size: raw.packingSize,
+        uom: raw.uom,
+        release_qty: raw.releaseQty
+      }
+    })
+  )
+
+  await tx.query(
+    `
+        CREATE TEMP TABLE temp_order_products(
+          product_id VARCHAR(50),
+          sku VARCHAR(150),
+          packing_type VARCHAR(50),
+          packing_size INT,
+          uom VARCHAR(10),
+          release_qty INT
+          );
+      `
+  )
+
+  await tx.query(
+    `
+        INSERT INTO temp_order_products
+        SELECT p.id AS product_id, js.sku,
+        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_type ELSE pd.packing_type END,
+        CASE WHEN js.packing_type NOTNULL AND js.packing_size NOTNULL THEN js.packing_size ELSE pd.packing_size END,
+        CASE WHEN js.uom NOTNULL THEN js.uom ELSE pd.uom END,
+        js.release_qty
+        FROM JSON_POPULATE_RECORDSET(NULL::temp_order_products,'${json_oi}') js
+        LEFT JOIN products p ON js.sku = p.sku AND p.bizplace_id = $1
+        LEFT JOIN product_details pd ON p.id = pd.product_id AND pd.is_default = TRUE;
+      `,
+    [companyBizplaceId.id]
+  )
+
+  let availableItems = await tx.query(
+    `
+        SELECT i.product_id, foo.sku, i.batch_id, i.packing_type, i.packing_size, i.uom,
+          SUM(i.qty - COALESCE(i.locked_qty, 0)) - COALESCE(
+            (
+              SELECT SUM(oi.release_qty) FROM order_inventories oi 
+              WHERE (
+                oi.status = 'PENDING'
+                OR oi.status = 'PENDING_RECEIVE'
+                OR oi.status = 'PENDING_WORKSHEET'
+                OR oi.status = 'PENDING_SPLIT'
+              )
+              AND oi.inventory_id IS null
+              AND oi.product_id = i.product_id::uuid
+              AND oi.packing_type = i.packing_type
+              AND oi.uom = i.uom
+              AND oi.domain_id = $1
+              AND oi.bizplace_id = $2
+            ), 0) as "remain_qty",
+          SUM(i.uom_value - COALESCE(i.locked_uom_value, 0)) - COALESCE(
+            (
+              SELECT SUM(oi.release_uom_value) FROM order_inventories oi 
+              WHERE (
+                oi.status = 'PENDING'
+                OR oi.status = 'PENDING_RECEIVE'
+                OR oi.status = 'PENDING_WORKSHEET'
+                OR oi.status = 'PENDING_SPLIT'
+              )
+              AND oi.inventory_id IS null
+              AND oi.product_id = i.product_id::uuid
+              AND oi.packing_type = i.packing_type
+              AND oi.uom = i.uom
+              AND oi.domain_id = $1
+              AND oi.bizplace_id = $2
+            ), 0) as "remain_uom_value"
+        FROM inventories i
+        INNER JOIN (
+          SELECT top.product_id, top.sku, top.packing_type, top.packing_size, top.uom 
+          FROM temp_order_products top
+          GROUP BY top.product_id, top.sku, top.packing_type, top.packing_size, top.uom
+        ) AS foo
+        ON i.product_id = foo.product_id::uuid
+        AND i.packing_type = foo.packing_type
+        AND i.packing_size = foo.packing_size
+        AND i.uom = foo.uom
+        AND i.domain_id = $1
+        AND i.bizplace_id = $2
+        GROUP BY i.product_id, foo.sku, i.batch_id, i.packing_type, i.packing_size, i.uom
+        ORDER BY foo.sku, remain_qty
+      `,
+    [domain.id, bizplaceId]
+  )
+
+  await tx.query('DROP TABLE temp_order_products')
+
+  availableItems = availableItems.map(item => {
+    return {
+      productId: item.product_id,
+      sku: item.sku,
+      batchId: item.batch_id,
+      packingType: item.packing_type,
+      packingSize: item.packing_size,
+      uom: item.uom,
+      remainQty: item.remain_qty,
+      remainUomValue: item.remain_uom_value
+    }
+  })
+
+  return _extractData(rawReleaseGoods, availableItems)
+}
+
+function _extractData(rawData, validatedData) {
+  return rawData.map(raw => {
+    const idx = validatedData.findIndex(val => {
+      const comparison = ['packingType', 'packingSize', 'uom']
+
+      let a: any = {},
+        b: any = {}
+
+      comparison.forEach(cc => {
+        if (raw[cc]) {
+          a[cc] = raw[cc]
+          b[cc] = val[cc]
+        }
+      })
+
+      a = JSON.stringify(Object.fromEntries(Object.entries(a).sort()))
+      b = JSON.stringify(Object.fromEntries(Object.entries(b).sort()))
+
+      return val.sku == raw.sku && a === b
+    })
+
+    let releaseUomValue = 0
+
+    // if sku is matched, assign qty and product id
+    if (idx >= 0) {
+      // assign qty to rawData as much as possible
+      releaseUomValue =
+        (Math.round((validatedData[idx]?.remainUomValue / validatedData[idx]?.remainQty) * 100) / 100) * raw.releaseQty
+
+      raw.assignedQty =
+        validatedData[idx].remainQty >= raw.releaseQty
+          ? raw.releaseQty > 0
+            ? raw.releaseQty
+            : 0
+          : validatedData[idx].remainQty
+
+      raw.assignedUomValue =
+        validatedData[idx].remainUomValue >= releaseUomValue
+          ? releaseUomValue > 0
+            ? releaseUomValue
+            : 0
+          : validatedData[idx].remainUomValue
+
+      // deduct qty & uomValue from validateData
+      validatedData[idx].remainQty -= raw.assignedQty
+      validatedData[idx].remainUomValue -= raw.assignedUomValue
+
+      raw.productId = validatedData[idx].productId
+      raw.packingType = validatedData[idx].packingType
+      raw.packingSize = validatedData[idx].packingSize
+      raw.uom = validatedData[idx].uom
+      raw.batchId = validatedData[idx].batchId
+    } else {
+      raw.assignedQty = 0
+      raw.assignedUomValue = 0
+      raw.productId = null
+    }
+
+    return {
+      ...raw,
+      releaseUomValue
+    }
+  })
+}
+
 export async function confirmReleaseGood(name: string, context: any, tx?: EntityManager): Promise<ReleaseGood> {
   const { user, domain }: { user: User; domain: Domain } = context.state
 
@@ -859,3 +1158,261 @@ export async function rejectReleaseGood(
 
   return releaseGood
 }
+
+export async function bulkGenerateReleaseGoods(
+  releaseGood: any,
+  bizplaceId: string,
+  roNoSetting: any,
+  domain: Domain,
+  user: User,
+  tx?: EntityManager
+): Promise<ReleaseGood> {
+  try {
+    let warehouseDomain: Domain = domain
+    let { orderInventories } = releaseGood
+
+    let bizplace: Bizplace = await tx.getRepository(Bizplace).findOne(bizplaceId)
+
+    let newReleaseGood: ReleaseGood = {
+      ...releaseGood,
+      name: roNoSetting
+        ? await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.RO_NUMBER, seed: {} })
+        : OrderNoGenerator.releaseGood(),
+      domain: warehouseDomain,
+      bizplace: bizplace,
+      deliveryAddress1: releaseGood?.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,
+      phone2: releaseGood?.phone2 || null,
+      email: releaseGood?.email || null,
+      airwayBill: releaseGood?.airwayBill,
+      refNo: releaseGood.refNo,
+      refNo2: releaseGood.refNo2,
+      refNo3: releaseGood.refNo3,
+      releaseDate: releaseGood.releaseDate,
+      ownTransport: releaseGood?.ownTransport || false,
+      status: ORDER_STATUS.PENDING,
+      creator: user,
+      updater: user
+    }
+
+    newReleaseGood = await tx.getRepository(ReleaseGood).save(newReleaseGood)
+
+    for (let oi of orderInventories) {
+      delete oi.sku
+
+      let newOrderInv: OrderInventory = Object.assign(new OrderInventory(), oi)
+      newOrderInv = {
+        ...newOrderInv,
+        domain: warehouseDomain,
+        bizplace: bizplace,
+        status: ORDER_INVENTORY_STATUS.PENDING,
+        name: OrderNoGenerator.orderInventory(),
+        batchId: oi?.batchId || '',
+        releaseGood: newReleaseGood,
+        product: await tx.getRepository(Product).findOne(oi.productId),
+        creator: user,
+        updater: user
+      }
+
+      let newOrderProduct: OrderProduct = Object.assign(new OrderProduct(), newOrderInv)
+      newOrderProduct = {
+        ...newOrderProduct,
+        packQty: 0,
+        actualPackQty: 0,
+        palletQty: 0,
+        actualPalletQty: 0,
+        status: ORDER_PRODUCT_STATUS.PENDING_ASSIGN
+      }
+
+      newOrderProduct = await tx.getRepository(OrderProduct).save(newOrderProduct)
+
+      await tx.getRepository(OrderInventory).save({ ...newOrderInv, orderProduct: newOrderProduct })
+    }
+
+    // Change the status to PENDING_RECEIVE
+
+    return newReleaseGood
+  } catch (error) {
+    throw error
+  }
+}
+
+export async function bulkConfirmReleaseGoods(
+  releaseGoodsNo: string[],
+  domain: Domain,
+  user: User,
+  context: any,
+  tx?: EntityManager
+): Promise<ReleaseGood[]> {
+  let foundReleaseGoods: ReleaseGood[] = await tx.getRepository(ReleaseGood).find({
+    where: { name: In(releaseGoodsNo), status: ORDER_STATUS.PENDING },
+    relations: [
+      'domain',
+      'bizplace',
+      'bizplace.domain',
+      'bizplace.company',
+      'bizplace.company.domain',
+      'orderProducts',
+      'orderProducts.product',
+      'orderInventories',
+      'orderInventories.product',
+      'orderVass'
+    ]
+  })
+
+  if (!foundReleaseGoods.length) throw new Error(`Release good order doesn't exists.`)
+  let customerBizplace: Bizplace = foundReleaseGoods[0].bizplace
+
+  let foundOrderInventories: OrderInventory[] = foundReleaseGoods
+    .map((releaseGood: ReleaseGood) => releaseGood.orderInventories)
+    .reduce((orderInventories, currOIs) => {
+      orderInventories.push(...currOIs)
+      return orderInventories
+    }, [])
+
+  await tx
+    .getRepository(ReleaseGood)
+    .update({ id: In(foundReleaseGoods.map(rg => rg.id)) }, { status: ORDER_STATUS.PENDING_RECEIVE, updater: user })
+
+  await tx
+    .getRepository(OrderInventory)
+    .update(
+      { id: In(foundOrderInventories.map(oi => oi.id)) },
+      { status: ORDER_INVENTORY_STATUS.PENDING_RECEIVE, updater: user }
+    )
+
+  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) {
+      const receivers: any[] = users.map(user => user.id)
+      const msg = {
+        title: `New Release Order from ${customerBizplace.name}`,
+        body: `New incoming bulk release orders are pending for receiving`,
+        url: context.header.referer,
+        data: { url: context.header.referer }
+      }
+      await sendNotification({
+        receivers,
+        message: { ...msg }
+      })
+    }
+  }
+
+  return foundReleaseGoods.map((releaseGood: ReleaseGood) => {
+    return {
+      ...releaseGood,
+      status: ORDER_STATUS.PENDING_RECEIVE,
+      updater: user
+    }
+  })
+}
+
+export function extractRawReleaseGoods(rawReleaseGoods): Partial<ReleaseGood[]> {
+  return rawReleaseGoods.reduce((releaseGoods, item) => {
+    const idx: number = releaseGoods.findIndex(rg => {
+      // consider these attributes if they are exist in "item"
+      const comparison = [
+        'refNo2',
+        'refNo3',
+        'attentionTo',
+        'phone1',
+        'deliveryAddress1',
+        'deliveryAddress2',
+        'deliveryAddress3',
+        'deliveryAddress4',
+        'postalCode'
+      ]
+
+      let a: any = {},
+        b: any = {}
+
+      comparison.forEach(cc => {
+        if (item[cc]) {
+          a[cc] = item[cc]
+          b[cc] = rg[cc]
+        }
+      })
+
+      a = JSON.stringify(Object.fromEntries(Object.entries(a).sort()))
+      b = JSON.stringify(Object.fromEntries(Object.entries(b).sort()))
+
+      return rg.refNo == item.refNo && rg.releaseDate == item.releaseDate && a === b
+    })
+
+    if (idx >= 0) {
+      const duplicateSkuIdx: number = releaseGoods[idx].orderInventories.findIndex(
+        oi => oi.sku === item.sku && oi.packingType === item.packingType && oi.packingSize === item.packingSize
+      )
+
+      if (duplicateSkuIdx >= 0) {
+        releaseGoods[idx].orderInventories[duplicateSkuIdx].releaseQty += item.releaseQty
+      } else {
+        releaseGoods[idx].orderInventories.push({
+          sku: item.sku,
+          productId: item.productId,
+          packingType: item.packingType,
+          packingSize: item.packingSize,
+          uom: item.uom,
+          releaseQty: item.releaseQty,
+          releaseUomValue: item.releaseUomValue
+        })
+      }
+    } else {
+      releaseGoods.push({
+        releaseDate: item.releaseDate,
+        refNo: item.refNo,
+        refNo2: item.refNo2,
+        refNo3: item.refNo3,
+        attentionTo: item.attentionTo,
+        phone1: item.phone1,
+        deliveryAddress1: item.deliveryAddress1,
+        deliveryAddress2: item.deliveryAddress2,
+        deliveryAddress3: item.deliveryAddress3,
+        deliveryAddress4: item.deliveryAddress4,
+        city: item.city,
+        postalCode: item.postalCode,
+        state: item.state,
+        country: item.country,
+        orderInventories: [
+          {
+            sku: item.sku,
+            productId: item.productId,
+            packingType: item.packingType,
+            packingSize: item.packingSize,
+            uom: item.uom,
+            releaseQty: item.releaseQty,
+            releaseUomValue: item.releaseUomValue
+          }
+        ]
+      })
+    }
+
+    return releaseGoods
+  }, [])
+}