@things-factory/sales-base 4.0.21 → 4.0.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/sales-base",
-  "version": "4.0.21",
+  "version": "4.0.25",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -24,16 +24,16 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create -d ./server/migrations"
   },
   "dependencies": {
-    "@things-factory/attachment-base": "^4.0.21",
-    "@things-factory/auth-base": "^4.0.21",
-    "@things-factory/biz-base": "^4.0.21",
-    "@things-factory/code-base": "^4.0.21",
-    "@things-factory/notification": "^4.0.21",
-    "@things-factory/product-base": "^4.0.21",
-    "@things-factory/setting-base": "^4.0.21",
-    "@things-factory/shell": "^4.0.21",
-    "@things-factory/transport-base": "^4.0.21",
-    "@things-factory/warehouse-base": "^4.0.21"
+    "@things-factory/attachment-base": "^4.0.25",
+    "@things-factory/auth-base": "^4.0.25",
+    "@things-factory/biz-base": "^4.0.25",
+    "@things-factory/code-base": "^4.0.25",
+    "@things-factory/notification": "^4.0.25",
+    "@things-factory/product-base": "^4.0.25",
+    "@things-factory/setting-base": "^4.0.25",
+    "@things-factory/shell": "^4.0.25",
+    "@things-factory/transport-base": "^4.0.25",
+    "@things-factory/warehouse-base": "^4.0.25"
   },
-  "gitHead": "ab5451f749a4e886ae3668bee82777b566538e17"
+  "gitHead": "9c44141d651dab7b4a9c0f0b6fecb8d6937d116f"
 }

package/server/controllers/ecommerce/ecommerce-controller.ts

@@ -1,8 +1,11 @@
-import { Domain } from '@things-factory/shell'
-import { Product } from '@things-factory/product-base'
-import { Inventory } from '@things-factory/warehouse-base'
-import { MarketplaceStore, MarketplaceSetting, StoreAPI } from '@things-factory/integration-marketplace'
+import { Equal, Not } from 'typeorm'
+
+import { MarketplaceSetting, MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
 import { MarketplaceProductVariation } from '@things-factory/marketplace-base'
+import { Product } from '@things-factory/product-base'
+import { Domain } from '@things-factory/shell'
+import { Inventory, INVENTORY_STATUS, LOCATION_TYPE } from '@things-factory/warehouse-base'
+
 import { OrderController } from '../order-controller'
 
 export class EcommerceController extends OrderController {
@@ -14,10 +17,16 @@ export class EcommerceController extends OrderController {
     const inventoryProducts: any[] = await Promise.all(
       productIds.map(async productId => {
         const product: Product = await this.trxMgr.getRepository(Product).findOne(productId)
-        const inventories: Inventory[] = await this.trxMgr.getRepository(Inventory).find({
-          where: { domain: this.domain, product }
+        let inventories: Inventory[] = await this.trxMgr.getRepository(Inventory).find({
+          where: { domain: this.domain, product, status: Not(Equal(INVENTORY_STATUS.TERMINATED)) },
+          relations: ['location']
         })
 
+        inventories = inventories.filter(
+          inventory =>
+            inventory?.location.type !== LOCATION_TYPE.QUARANTINE || inventory?.location.type !== LOCATION_TYPE.RESERVE
+        )
+
         const inventoryQty: number = inventories.reduce((total, currentValue) => {
           total += currentValue.qty
           return total

package/server/controllers/ecommerce/sellercraft-controller.ts

@@ -1,6 +1,10 @@
+import { Equal, Not } from 'typeorm'
+
 import { Sellercraft, SellercraftAPI } from '@things-factory/integration-sellercraft'
-import { Product } from '@things-factory/product-base'
+import { Product, ProductDetail } from '@things-factory/product-base'
+import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
 
+import { ORDER_PRODUCT_STATUS } from '../../constants'
 import { OrderProduct, ReleaseGood } from '../../service'
 import { OrderController } from '../order-controller'
 
@@ -31,6 +35,78 @@ export class SellercraftController extends OrderController {
     return releaseGood
   }
 
+  async updateSellercraftStock(sellercraft: Sellercraft, orderProducts: OrderProduct[], type: string): Promise<void> {
+    for (var i = 0; i < orderProducts.length; i++) {
+      const orderProduct: OrderProduct = orderProducts[i]
+
+      const product: Product = orderProduct.product
+      const pendingAssignOPs: OrderProduct[] = await this.trxMgr
+        .getRepository(OrderProduct)
+        .find({ where: { domain: this.domain, product, status: ORDER_PRODUCT_STATUS.PENDING_ASSIGN } })
+
+      const productDetails: ProductDetail[] = product.productDetails
+
+      let totalUnassignReleaseQty: number = 0
+      if (pendingAssignOPs?.length) {
+        totalUnassignReleaseQty = pendingAssignOPs.reduce((total, currentValue) => {
+          total += currentValue.releaseQty
+          return total
+        }, 0)
+      }
+
+      const inventories: Inventory[] = await this.trxMgr.getRepository(Inventory).find({
+        where: { domain: this.domain, product, status: Not(Equal(INVENTORY_STATUS.TERMINATED)) }
+      })
+
+      let defaultProductDetail: ProductDetail
+      const sellercraftInvs: any[] = await Promise.all(
+        inventories.map(async (inventory: Inventory) => {
+          const inventoryPackingType: string = inventory.packingType
+          defaultProductDetail = product.productDetails.find(productDetail => productDetail.isDefault)
+
+          let packingSize: number = 1
+          if (inventoryPackingType !== defaultProductDetail.packingType) {
+            const unmatchingProductDetail: ProductDetail = product.productDetails.find(
+              productDetail => productDetail.packingType === inventoryPackingType
+            )
+
+            packingSize = await this.getChildPackingSize(productDetails, defaultProductDetail, unmatchingProductDetail)
+            if (packingSize == 0) packingSize = 1
+          }
+
+          return { quantity: inventory.qty * packingSize - inventory.lockedQty * packingSize }
+        })
+      )
+
+      let inventoryTotalQty: number = sellercraftInvs.reduce((total, currentValue) => {
+        total += currentValue.quantity
+        return total
+      }, 0)
+
+      switch (type) {
+        case 'CONFIRM_ORDER':
+          inventoryTotalQty -= totalUnassignReleaseQty
+          break
+      }
+
+      const sellercraftInv: any = {
+        accountId: sellercraft.accountId,
+        sku: product.sku,
+        uom: 'EA',
+        quantity: inventoryTotalQty,
+        gtin: defaultProductDetail.gtin,
+        weight: defaultProductDetail.nettWeight < 1 ? 1 : defaultProductDetail.nettWeight,
+        packageDimension: {
+          length: defaultProductDetail.depth < 1 ? 1 : defaultProductDetail.depth,
+          width: defaultProductDetail.width < 1 ? 1 : defaultProductDetail.width,
+          height: defaultProductDetail.height < 1 ? 1 : defaultProductDetail.height
+        }
+      }
+
+      await SellercraftAPI.updateProduct(sellercraft, { sellercraftInv })
+    }
+  }
+
   async checkExistingReleaseGood(sellercraft: Sellercraft, releaseGood: ReleaseGood): Promise<void> {
     const { refNo, refNo2 } = releaseGood
     const foundReleaseGood: ReleaseGood = await this.trxMgr.getRepository(ReleaseGood).findOne({

package/server/controllers/order-controller.ts

@@ -1,9 +1,12 @@
+import { EntityManager, EntitySchema, FindOneOptions } from 'typeorm'
+
 import { Role, User } from '@things-factory/auth-base'
 import { Bizplace, getDomainUsers } from '@things-factory/biz-base'
 import { sendNotification } from '@things-factory/notification'
+import { ProductDetail } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
-import { EntityManager, EntitySchema, FindOneOptions } from 'typeorm'
+
 import {
   ArrivalNotice,
   DeliveryOrder,
@@ -48,7 +51,9 @@ export type NotificationMsgInterface = {
 export class OrderController {
   public readonly ERROR_MSG = {
     FIND: {
-      NO_RESULT: (condition: any) => `There's no results matched with condition ${condition}`
+      NO_RESULT: (condition: any) => `There's no results matched with condition ${condition}`,
+      NO_CHILD_RESULT: (condition: any) => `There's no child result matched with condition ${condition}`,
+      NOT_MATCH: (source: any, target: any) => `Unable to find matching ${target} using ${source}`
     },
     CREATE: {
       ID_EXISTS: 'Target has ID already',
@@ -217,6 +222,54 @@ export class OrderController {
     return await this.trxMgr.getRepository(Inventory).save(inventory)
   }
 
+  async getChildPackingSize(
+    productDetails: ProductDetail[],
+    defaultProductDetail: ProductDetail,
+    unmatchingProductDetail: ProductDetail
+  ): Promise<number> {
+    let hasChildRelation: boolean = Boolean(unmatchingProductDetail?.childProductDetail)
+    let hasMatchingChild: boolean
+    let packingSize: number = 1
+    let currentChildProductDetail: ProductDetail
+
+    if (hasChildRelation) {
+      currentChildProductDetail = productDetails.find(
+        (productDetail: ProductDetail) => productDetail.id === unmatchingProductDetail.childProductDetail.id
+      )
+
+      if (!currentChildProductDetail) {
+        throw new Error(this.ERROR_MSG.FIND.NOT_MATCH('packing type', `GTIN (${unmatchingProductDetail.gtin})`))
+      }
+
+      hasMatchingChild = Boolean(defaultProductDetail.id === currentChildProductDetail.id)
+      if (hasMatchingChild) {
+        packingSize = unmatchingProductDetail.packingSize
+      } else {
+        packingSize = unmatchingProductDetail.packingSize * packingSize
+      }
+    } else {
+      throw new Error(this.ERROR_MSG.FIND.NO_CHILD_RESULT(`${unmatchingProductDetail.gtin}`))
+    }
+
+    while (hasChildRelation && !hasMatchingChild) {
+      if (hasMatchingChild) {
+        packingSize = currentChildProductDetail.packingSize * packingSize // 12 x 10
+      } else if (!hasMatchingChild && hasChildRelation) {
+        packingSize = currentChildProductDetail.packingSize * packingSize // 12 x 10
+        currentChildProductDetail = productDetails.find(
+          (productDetail: ProductDetail) => productDetail.id === currentChildProductDetail.childProductDetail.id
+        )
+
+        hasChildRelation = Boolean(currentChildProductDetail?.childProductDetail)
+        hasMatchingChild = Boolean(defaultProductDetail.id === currentChildProductDetail.id)
+      } else if (!hasChildRelation && !hasMatchingChild) {
+        throw new Error(this.ERROR_MSG.FIND.NO_RESULT(unmatchingProductDetail.gtin))
+      }
+    }
+
+    return packingSize
+  }
+
   /**
    * @summary set common stamp like domain, creator, updater
    * @description Set common stamp to passed record

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

@@ -1,6 +1,6 @@
 import { FileUpload, GraphQLUpload } from 'graphql-upload'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, getRepository, In, Repository } from 'typeorm'
+import { EntityManager, getConnection, getRepository, In, Repository } from 'typeorm'
 
 import { Attachment, createAttachments } from '@things-factory/attachment-base'
 import { Role, User } from '@things-factory/auth-base'
@@ -38,10 +38,13 @@ import {
   ORDER_VAS_STATUS
 } from '../../constants'
 import { ATTACHMENT_TYPE } from '../../constants/attachment-type'
+import { ValidationError } from '../../errors'
 import { OrderNoGenerator } from '../../utils/order-no-generator'
 import { generateJobSheet } from '../job-sheet/job-sheet-mutation'
 import { confirmReleaseGood, deleteReleaseGood, rejectReleaseGood } from '../release-good/release-good-mutation'
+import { validateBulkArrivalNoticesFunction } from './'
 import { ArrivalNotice } from './arrival-notice'
+import { ArrivalNoticeList, RawArrivalNotice } from './arrival-notice-types'
 
 const debug = require('debug')('things-factory:operato-wms:addArrivalNotice')
 
@@ -230,6 +233,139 @@ export class ArrivalNoticeMutation {
     await tx.getRepository(ArrivalNotice).update(existingArrivalNotice.id, arrivalNotice)
     return await tx.getRepository(ArrivalNotice).findOne(existingArrivalNotice.id)
   }
+
+  @Directive('@privilege(category: "order_customer", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => ArrivalNoticeList)
+  async bulkGenerateArrivalNotices(
+    @Ctx() context: any,
+    @Arg('rawArrivalNotices', type => [NewArrivalNotice], { nullable: true }) rawArrivalNotices: NewArrivalNotice[],
+    @Arg('bizplaceId', type => String) bizplaceId: string
+  ): Promise<ArrivalNoticeList> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+    let createdArrivalNoticeIds: string[] = [],
+      createdOrderProductIds: string[] = [],
+      errorsCaught: any[] = [],
+      finalArrivalNoticeList: ArrivalNotice[] = []
+
+    const foundBizplace: Bizplace = await tx.getRepository(Bizplace).findOne(bizplaceId)
+
+    if (!foundBizplace) throw new Error('company not found')
+
+    // to check whether the raw data are valid
+    const validatedArrivalNotices: RawArrivalNotice[] = await validateBulkArrivalNoticesFunction(
+      rawArrivalNotices,
+      bizplaceId,
+      tx
+    )
+
+    // check for custom GAN order no setting
+    const ganNoSetting: Setting = await tx.getRepository(Setting).findOne({
+      where: {
+        domain,
+        name: ORDER_NUMBER_SETTING_KEY.GAN_NUMBER_RULE
+      }
+    })
+
+    // extract rawArrivalNotices data into normal ArrivalNotice format
+    let arrivalNotices: Partial<ArrivalNotice[]> = extractArrivalNotices(validatedArrivalNotices)
+
+    for (let i = 0, l = arrivalNotices.length; i < l; i++) {
+      try {
+        await getConnection().transaction(async childTx => {
+          // check for duplication
+          const duplicatedArrivalNotice: ArrivalNotice = await childTx.getRepository(ArrivalNotice).findOne({
+            where: {
+              refNo: arrivalNotices[i].refNo,
+              refNo2: arrivalNotices[i].refNo2,
+              refNo3: arrivalNotices[i].refNo3,
+              etaDate: arrivalNotices[i].etaDate,
+              truckNo: arrivalNotices[i].truckNo,
+              containerNo: arrivalNotices[i].containerNo,
+              containerSize: arrivalNotices[i].containerSize,
+              looseItem: arrivalNotices[i].looseItem,
+              importCargo: arrivalNotices[i].importCargo
+            }
+          })
+
+          if (duplicatedArrivalNotice) {
+            throw new Error(`duplicated with ${duplicatedArrivalNotice.name}`)
+          }
+
+          // save new arrival notice
+          const createdArrivalNotice: ArrivalNotice = await childTx.getRepository(ArrivalNotice).save({
+            ...arrivalNotices[i],
+            name: ganNoSetting
+              ? await generateId({ domain, type: ORDER_NUMBER_RULE_TYPE.GAN_NUMBER, seed: {} })
+              : OrderNoGenerator.arrivalNotice(),
+            domain,
+            bizplace: foundBizplace,
+            status: ORDER_STATUS.PENDING,
+            creator: user,
+            updater: user
+          })
+
+          // save new order products
+          let createdOrderProducts: OrderProduct[] = await Promise.all(
+            arrivalNotices[i].orderProducts.map(async (op: OrderProduct) => {
+              return {
+                ...op,
+                domain,
+                bizplace: foundBizplace,
+                name: OrderNoGenerator.orderProduct(),
+                // product: await childTx.getRepository(Product).findOne(op.product.id),
+                status: ORDER_PRODUCT_STATUS.PENDING,
+                arrivalNotice: createdArrivalNotice,
+                creator: user
+              }
+            })
+          )
+          createdOrderProducts = await childTx.getRepository(OrderProduct).save(createdOrderProducts)
+
+          // generate new jobsheet
+          await generateJobSheet(domain, user, createdArrivalNotice, childTx)
+
+          // push arrivalNotice and orderProducts IDs if successfully saved
+          createdArrivalNoticeIds.push(createdArrivalNotice.id)
+          createdOrderProductIds.push(...createdOrderProducts.map(op => op.id))
+        })
+      } catch (error) {
+        // collect the arrivalNotice details and its error
+        let rawArrivalNotices: RawArrivalNotice[] = formRawArrivalNotices(arrivalNotices[i], error.message)
+        errorsCaught.push(...rawArrivalNotices)
+      }
+    }
+
+    if (createdArrivalNoticeIds.length && createdOrderProductIds.length) {
+      await getConnection().transaction(async childTx => {
+        // update arrivalNotices status to PENDING_RECEIVE
+        await childTx
+          .getRepository(ArrivalNotice)
+          .update({ id: In(createdArrivalNoticeIds) }, { status: ORDER_STATUS.PENDING_RECEIVE, updater: user })
+
+        // update orderProducts status to PENDING_RECEIVE
+        await childTx
+          .getRepository(OrderProduct)
+          .update({ id: In(createdOrderProductIds) }, { status: ORDER_PRODUCT_STATUS.PENDING_RECEIVE, updater: user })
+
+        finalArrivalNoticeList = await childTx.getRepository(ArrivalNotice).find({
+          where: { id: In(createdArrivalNoticeIds) },
+          relations: ['orderProducts', 'orderProducts.product', 'bizplace']
+        })
+      })
+    }
+
+    if (errorsCaught.length) {
+      // should return this error list in the grist so that user know which gan need to amend
+      throw new ValidationError({
+        ...ValidationError.ERROR_CODES.INVALID_DATA_FOUND,
+        detail: { data: JSON.stringify(errorsCaught) }
+      })
+    }
+
+    // return arrivalNotices with its orderProducts list
+    return { items: finalArrivalNoticeList, total: 0 }
+  }
 }
 
 export async function deleteArrivalNotice(
@@ -780,3 +916,103 @@ export async function editArrivalNoticeProducts(
   debug('gan-updated-order-products', updatedOrderProducts)
   await orderProductRepo.save(updatedOrderProducts)
 }
+
+function extractArrivalNotices(rawArrivalNotices): Partial<ArrivalNotice[]> {
+  return rawArrivalNotices.reduce((arrivalNotices, raw) => {
+    // discard the item that has no productId or productDetailId
+    if (!raw.productId || !raw.productDetailId) return
+
+    const idx: number = arrivalNotices.findIndex(an => {
+      // consider these attributes if they are exist in "item"
+      const comparison = [
+        'refNo2',
+        'refNo3',
+        'truckNo',
+        'ownTransport',
+        'container',
+        'containerNo',
+        'containerSize',
+        'looseItem',
+        'importCargo'
+      ]
+
+      let a: any = {},
+        b: any = {}
+
+      comparison.forEach(cc => {
+        if (raw[cc] !== null) {
+          a[cc] = raw[cc]
+          b[cc] = an[cc]
+        }
+      })
+
+      a = JSON.stringify(Object.fromEntries(Object.entries(a).sort()))
+      b = JSON.stringify(Object.fromEntries(Object.entries(b).sort()))
+
+      return an.refNo == raw.refNo && an.etaDate == raw.etaDate && a === b
+    })
+
+    const product: Product = Object.assign(new Product(), { id: raw.productId, sku: raw.sku })
+    const orderProduct: Partial<OrderProduct> = {
+      product,
+      batchId: raw.batchId,
+      packingType: raw.packingType,
+      packingSize: raw.packingSize,
+      packQty: raw.packQty,
+      uomValue: raw.uomValue,
+      uom: raw.uom,
+      totalUomValue: raw.totalUomValue,
+      palletQty: raw.palletQty,
+      unitPrice: raw.unitPrice,
+      manufactureYear: raw.manufactureYear
+    }
+
+    if (idx >= 0) {
+      const duplicateSkuIdx: number = arrivalNotices[idx].orderProducts.findIndex(
+        op =>
+          op.sku === raw.sku &&
+          op.packingType === raw.packingType &&
+          op.packingSize === raw.packingSize &&
+          op.batchId === raw.batchId
+      )
+
+      if (duplicateSkuIdx >= 0) arrivalNotices[idx].orderProducts[duplicateSkuIdx].packQty += raw.packQty
+      else arrivalNotices[idx].orderProducts.push(orderProduct)
+    } else {
+      arrivalNotices.push({
+        refNo: raw.refNo,
+        refNo2: raw.refNo2,
+        refNo3: raw.refNo3,
+        etaDate: raw.etaDate,
+        truckNo: raw.truckNo,
+        ownTransport: raw.ownTransport,
+        container: raw.container,
+        containerNo: raw.containerNo,
+        containerSize: raw.containerSize,
+        importCargo: raw.importCargo,
+        looseItem: raw.looseItem,
+        orderProducts: [orderProduct]
+      })
+    }
+
+    return arrivalNotices
+  }, [])
+}
+
+function formRawArrivalNotices(arrivalNotice, errorMessage) {
+  let rawArrivalNotices = []
+  for (let i = 0, l = arrivalNotice.orderProducts.length; i < l; i++) {
+    let rawArrivalNotice = {
+      ...arrivalNotice,
+      ...arrivalNotice.orderProducts[i],
+      sku: arrivalNotice.orderProducts[i].product.sku,
+      remark: errorMessage
+    }
+
+    delete rawArrivalNotice.orderProducts
+    delete rawArrivalNotice.product
+
+    rawArrivalNotices.push(rawArrivalNotice)
+  }
+  return rawArrivalNotices
+}