@things-factory/worksheet-base 8.0.0-beta.9 → 8.0.0

package/server/routes.ts

@@ -0,0 +1,80 @@
+import { renderElcclGRN } from './controllers/render-elccl-grn'
+import { renderGRN } from './controllers/render-grn'
+import { renderJobSheet } from './controllers/render-job-sheet'
+import { renderKimedaGRN } from './controllers/render-kimeda-grn'
+import { renderManifest } from './controllers/render-manifest'
+import { renderManualDO } from './controllers/render-manual-do'
+import { renderOrientageDO } from './controllers/render-orientage-do'
+import { renderOrientageGRN } from './controllers/render-orientage-grn'
+import { renderRODO } from './controllers/render-ro-do'
+import { renderSeebuuGRN } from './controllers/render-seebuu-grn'
+import { renderFmGRN } from './controllers/render-fm-grn'
+import { renderInvoices } from './controllers/render-invoices'
+import { renderPO } from './controllers/render-po'
+
+
+process.on('bootstrap-module-domain-private-route' as any, (app, routes) => {
+  routes.get('/view_document_ro_do/:doNo', async (context, next) => {
+    context.body = await renderRODO(context.params, context)
+  })
+
+  routes.get('/view_document_orientage_do/:doNo', async (context, next) => {
+    context.body = await renderOrientageDO(context.params, context)
+  })
+
+  routes.get('/view_document_manual_do/:doNo', async (context, next) => {
+    context.body = await renderManualDO(context.params, context)
+  })
+
+  routes.get('/view_elccl_grn/:grnNo', async (context, next) => {
+    context.body = await renderElcclGRN(context.params, context)
+  })
+
+  routes.get('/view_grn/:grnNo/:timezoneOffSet', async (context, next) => {
+    context.body = await renderGRN(context.params, context)
+  })
+
+  routes.get('/view_kimeda_grn/:grnNo/:timezoneOffSet', async (context, next) => {
+    context.body = await renderKimedaGRN(context.params, context)
+  })
+
+  routes.get('/view_orientage_grn/:grnNo', async (context, next) => {
+    context.body = await renderOrientageGRN(context.params, context)
+  })
+
+  routes.get('/view_seebuu_grn/:grnNo', async (context, next) => {
+    context.body = await renderSeebuuGRN(context.params, context)
+  })
+
+  routes.get('/view_fm_grn/:grnNo/:timezoneOffSet', async (context, next) => {
+    context.body = await renderFmGRN(context.params, context)
+  })
+
+  routes.get('/view_job_sheet/:ganNo/:timezoneOffSet', async (context, next) => {
+    context.body = await renderJobSheet(context.params, context)
+  })
+
+  routes.get('/view_manifest/:manifestNo', async (context, next) => {
+    context.body = await renderManifest(context.params, context)
+  })
+
+  routes.post('/view_invoices/:timezoneOffSet', async (context, next) => {
+    let req = context.request.body || {}
+    let timezoneOffSet = context.params.timezoneOffSet || 0
+
+    let data = await renderInvoices({ req, timezoneOffSet }, context)
+
+    context.type = 'application/json'
+    context.body = data
+  })
+
+  routes.post('/view_purchase_orders/:timezoneOffSet', async (context, next) => {
+    let req = context.request.body || {}
+    let timezoneOffSet = context.params.timezoneOffSet || 0
+
+    let data = await renderPO({ req, timezoneOffSet }, context)
+
+    context.type = 'application/json'
+    context.body = data
+  })
+})

package/server/utils/datetime-util.ts

@@ -0,0 +1,54 @@
+export class DateGenerator {
+  static generateDate() {
+    const today = new Date()
+    const year = today.getFullYear()
+    const month = today.getMonth()
+    const day = today.getDate()
+
+    const yy = String(year).substr(String(year).length - 2)
+    const mm = String(month + 1).padStart(2, '0')
+    const dd = String(day).padStart(2, '0')
+
+    return yy + mm + dd
+  }
+}
+
+export class DateTimeConverter {
+  static date(dateTime) {
+    let unloadDate = ''
+    if (dateTime) {
+      const unloadDateTime: Date = new Date(dateTime)
+      var year = unloadDateTime.getFullYear()
+
+      var month = (1 + unloadDateTime.getMonth()).toString()
+      month = month.length > 1 ? month : '0' + month
+
+      var day = unloadDateTime.getDate().toString()
+      day = day.length > 1 ? day : '0' + day
+
+      unloadDate = day + '-' + month + '-' + year
+    }
+    return unloadDate
+  }
+
+  static datetime(dateTime, timezone) {
+    let unloadDate = ''
+    if (dateTime) {
+      const datetime = Number(dateTime)
+      const timezoneOffset = timezone * 60000
+      const newUnloadDate = new Date(datetime - timezoneOffset).toISOString().slice(0, -1)
+
+      var dateTimeParts: any = newUnloadDate.split('T')
+
+      //handle date parts
+      var dateParts = dateTimeParts[0].split('-')
+      var newDate = DateTimeConverter.date(dateParts)
+
+      //handle time part
+      var timeParts = dateTimeParts[1].slice(0, -7)
+
+      unloadDate = newDate + ' ' + timeParts
+    }
+    return unloadDate
+  }
+}

package/server/utils/index.ts

@@ -0,0 +1,4 @@
+export * from './inventory-util'
+export * from './worksheet-no-generator'
+export * from './datetime-util'
+export * from './worksheet-util'

package/server/utils/inventory-util.ts

@@ -0,0 +1,390 @@
+import { EntityManager, Repository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Product } from '@things-factory/product-base'
+import { Domain, getRepository } from '@things-factory/shell'
+import {
+  Inventory,
+  INVENTORY_STATUS,
+  InventoryHistory,
+  InventoryNoGenerator,
+  Location,
+  LOCATION_STATUS,
+  LOCATION_TYPE
+} from '@things-factory/warehouse-base'
+
+/**
+ * @description It will insert new record into inventory histories table.
+ * seq will be calculated based on number of records for one specific pallet id (provided by inventory object)
+ */
+export async function generateInventoryHistory(
+  inventory: Inventory,
+  refOrder: any,
+  transactionType: string,
+  qty: number = 0,
+  uomValue: number = 0,
+  user: User,
+  trxMgr?: EntityManager,
+  targetInventory: Inventory = {} as any
+): Promise<InventoryHistory> {
+  const invHistoryRepo: Repository<InventoryHistory> =
+    trxMgr?.getRepository(InventoryHistory) || getRepository(InventoryHistory)
+  const invRepo: Repository<Inventory> = trxMgr?.getRepository(Inventory) || getRepository(Inventory)
+
+  if (!inventory?.id) throw new Error(`Can't find out ID of inventory.`)
+  if (!refOrder?.id || !refOrder.name) throw new Error(`Can't find out ID or Name of Reference Order`)
+  if (
+    !inventory?.domain ||
+    !inventory?.bizplace ||
+    !inventory?.product?.id ||
+    !inventory?.warehouse?.id ||
+    !inventory?.location?.id
+  ) {
+    inventory = await invRepo.findOne({
+      where: { id: inventory.id },
+      relations: ['domain', 'bizplace', 'product', 'warehouse', 'location']
+    })
+  }
+
+  const domain: Domain = inventory.domain
+  const location: Location = inventory.location
+
+  const seq: number = await invHistoryRepo.countBy({
+    domain: { id: inventory.domain.id },
+    palletId: inventory.palletId
+  })
+  let openingQty: number = 0
+  let openingUomValue: number = 0
+
+  if (seq) {
+    const lastInvHistory: InventoryHistory = await invHistoryRepo.findOneBy({
+      domain: { id: inventory.domain.id },
+      palletId: inventory.palletId,
+      seq: seq - 1
+    })
+
+    openingQty = lastInvHistory.openingQty + lastInvHistory.qty
+    openingUomValue = lastInvHistory.openingUomValue + lastInvHistory.uomValue
+  }
+
+  if (transactionType == 'PICKING' || transactionType == 'UNLOADING') {
+    // @ts-ignore
+    const [findSameOrderHistory, total]: InventoryHistory = await invHistoryRepo.findAndCountBy({
+      domain: { id: inventory.domain.id },
+      palletId: inventory.palletId,
+      refOrderId: refOrder.id
+    })
+
+    if (findSameOrderHistory) {
+      let prevTotalQty = 0
+      let prevTotalUomValue = 0
+      for (let oh of findSameOrderHistory) {
+        prevTotalQty += oh.qty
+        prevTotalUomValue += oh.uomValue
+      }
+      qty -= prevTotalQty
+      uomValue -= prevTotalUomValue
+    }
+  }
+
+  let inventoryHistory: InventoryHistory = new InventoryHistory()
+  inventoryHistory.name = InventoryNoGenerator.inventoryHistoryName()
+  inventoryHistory.description = inventory.description
+  inventoryHistory.seq = seq
+  inventoryHistory.palletId = inventory.palletId
+  inventoryHistory.cartonId = inventory.cartonId
+  inventoryHistory.batchId = inventory.batchId
+  inventoryHistory.batchIdRef = inventory.batchIdRef
+  inventoryHistory.status = inventory.status
+  inventoryHistory.transactionType = transactionType
+  inventoryHistory.refOrderId = refOrder?.id || null
+  inventoryHistory.orderNo = refOrder?.name || null
+  inventoryHistory.orderRefNo = refOrder?.refNo || null
+  inventoryHistory.inventory = inventory
+  ;(inventoryHistory as any).targetInventory = targetInventory as any
+  inventoryHistory.product = inventory.product
+  inventoryHistory.reusablePallet = inventory.reusablePallet
+  inventoryHistory.zone = inventory.zone
+  inventoryHistory.warehouse = inventory.warehouse
+  inventoryHistory.location = inventory.location
+  inventoryHistory.expirationDate = inventory.expirationDate
+  inventoryHistory.packingType = inventory.packingType
+  inventoryHistory.packingSize = inventory.packingSize
+  inventoryHistory.uom = inventory.uom
+  inventoryHistory.qty = qty
+  inventoryHistory.openingQty = openingQty
+  inventoryHistory.uomValue = uomValue
+  inventoryHistory.openingUomValue = openingUomValue
+  inventoryHistory.unitCost = inventory.unitCost
+  inventoryHistory.domain = inventory.domain
+  inventoryHistory.bizplace = inventory.bizplace
+  inventoryHistory.creator = user
+  inventoryHistory.updater = user
+  inventoryHistory.auxInfo3 = inventory.auxInfo3
+
+  inventoryHistory = await invHistoryRepo.save(inventoryHistory)
+
+  if (inventory.lastSeq !== seq) {
+    await invRepo.save({
+      id: inventory.id,
+      lastSeq: inventoryHistory.seq,
+      updater: user
+    })
+  }
+
+  await switchLocationStatus(domain, location, user, trxMgr)
+  return inventoryHistory
+}
+
+/**
+ * @description: Check location emptiness and update status of location
+ * @param domain
+ * @param location
+ * @param updater
+ * @param trxMgr
+ */
+export async function switchLocationStatus(
+  domain: Domain,
+  location: Location,
+  updater: User,
+  trxMgr?: EntityManager
+): Promise<Location> {
+  const invRepo: Repository<Inventory> = trxMgr?.getRepository(Inventory) || getRepository(Inventory)
+  const locationRepo: Repository<Location> = trxMgr?.getRepository(Location) || getRepository(Location)
+  const allocatedItemsCnt: number = await invRepo.countBy({
+    domain: { id: domain.id },
+    status: INVENTORY_STATUS.STORED,
+    location: { id: location.id }
+  })
+
+  if (!allocatedItemsCnt && location.status !== LOCATION_STATUS.EMPTY) {
+    location = await locationRepo.save({
+      ...location,
+      status: LOCATION_STATUS.EMPTY,
+      updater
+    })
+  } else if (allocatedItemsCnt && location.status === LOCATION_STATUS.EMPTY) {
+    location = await locationRepo.save({
+      ...location,
+      status: LOCATION_STATUS.OCCUPIED,
+      updater
+    })
+  }
+
+  return location
+}
+
+export async function checkPalletDuplication(
+  domain: Domain,
+  bizplace: Bizplace,
+  palletId: string,
+  trxMgr?: EntityManager
+): Promise<boolean> {
+  const invRepo: Repository<Inventory> = trxMgr?.getRepository(Inventory) || getRepository(Inventory)
+  const duplicatedPalletCnt: number = await invRepo.countBy({
+    domain: { id: domain.id },
+    bizplace,
+    palletId
+  })
+
+  return Boolean(duplicatedPalletCnt)
+}
+
+/**
+ * @description Check whether inventory is same with passed conditions
+ * @param {Domain} domain
+ * @param {Bizplace} bizplace
+ * @param {String} palletId
+ * @param {String} batchId
+ * @param {String | Product} product
+ * @param {String} packingType
+ * @param {EntityManager} trxMgr
+ */
+export async function checkPalletIdenticallity(
+  domain: Domain,
+  bizplace: Bizplace,
+  palletId: string,
+  batchId: string,
+  product: string | Product,
+  packingType: string,
+  trxMgr?: EntityManager
+): Promise<{ identicallity: boolean; errorMessage?: string }> {
+  const productRepo: Repository<Product> = trxMgr?.getRepository(Product) || getRepository(Product)
+  const invRepo: Repository<Inventory> = trxMgr?.getRepository(Inventory) || getRepository(Inventory)
+
+  if (typeof product === 'string') {
+    const foundProduct: Product = await productRepo.findOneBy({ id: product })
+    if (!foundProduct) throw new Error(`Failed to find product with ${product}`)
+    product = foundProduct
+  }
+
+  const inv: Inventory = await invRepo.findOne({
+    where: { domain: { id: domain.id }, bizplace: { id: bizplace.id }, palletId },
+    relations: ['product']
+  })
+
+  if (batchId !== inv.batchId) return { identicallity: false, errorMessage: `Batch ID is not matched with ${batchId}` }
+
+  if (product?.id !== inv?.product?.id)
+    return { identicallity: false, errorMessage: `Product is not matched with ${product.name}` }
+
+  if (packingType !== inv.packingType)
+    return { identicallity: false, errorMessage: `Packing Type is not matched with ${packingType}` }
+
+  return { identicallity: true }
+}
+
+/**
+ * @description: Get inventory based on picking strategy and sorting rule
+ * @param { worksheetId, batchId, bizplaceId, productId, packingType, pickingStrategy, locationSortingRules }
+ * @param trxMgr
+ */
+export async function inventoriesByStrategy(
+  { worksheetId, batchId, bizplaceId, productId, packingType, packingSize, uom, pickingStrategy, locationSortingRules },
+  domain: Domain,
+  trxMgr: EntityManager
+) {
+  const qb = await trxMgr.getRepository(Inventory).createQueryBuilder('INV')
+  qb.innerJoinAndSelect('INV.product', 'PROD')
+    .innerJoinAndSelect('INV.location', 'LOC')
+    .addSelect(subQuery =>
+      subQuery
+        .select('COALESCE(SUM(release_qty), 0)', 'releaseQty')
+        .from('order_inventories', 'OI')
+        .where('"OI"."inventory_id" = "INV"."id"')
+        .andWhere("\"OI\".\"status\" IN ('PENDING', 'PENDING_RECEIVE', 'PENDING_WORKSHEET', 'PENDING_SPLIT')")
+        .andWhere('"OI"."ref_worksheet_id" <> :worksheetId', { worksheetId: worksheetId })
+    )
+    .addSelect(subQuery =>
+      subQuery
+        .select('COALESCE(SUM(release_uom_value), 0)', 'releaseUomValue')
+        .from('order_inventories', 'OI')
+        .where('"OI"."inventory_id" = "INV"."id"')
+        .andWhere("\"OI\".\"status\" IN ('PENDING', 'PENDING_RECEIVE', 'PENDING_WORKSHEET', 'PENDING_SPLIT')")
+        .andWhere('"OI"."ref_worksheet_id" <> :worksheetId', { worksheetId: worksheetId })
+    )
+    .andWhere('"INV"."domain_id" = :domainId')
+    .andWhere('"PROD"."id" = :productId')
+    .andWhere('"INV"."packing_type" = :packingType')
+    .andWhere('"INV"."packing_size" = :packingSize')
+    .andWhere('"INV"."uom" = :uom')
+    .andWhere('"INV"."status" = :status', { status: 'STORED' })
+    .andWhere('"LOC"."type" NOT IN (:...locationTypes)', {
+      locationTypes: [LOCATION_TYPE.QUARANTINE, LOCATION_TYPE.RESERVE]
+    })
+    .setParameters({
+      domainId: domain.id,
+      productId,
+      packingType,
+      packingSize,
+      uom
+    })
+
+  if (batchId !== '') {
+    qb.andWhere('"INV"."batch_id" = :batchId', { batchId })
+  }
+
+  if (bizplaceId) {
+    qb.andWhere('"INV"."bizplace_id" = :bizplaceId', { bizplaceId: bizplaceId })
+  }
+
+  let locIdx = 0
+
+  switch (pickingStrategy.toUpperCase()) {
+    case 'FIFO':
+      qb.orderBy('"INV"."created_at"', 'ASC')
+      if (locationSortingRules) {
+        for (const key in locationSortingRules) {
+          qb.addOrderBy(`LOC.${key}`, locationSortingRules[key])
+        }
+      }
+      break
+
+    case 'LIFO':
+      qb.orderBy('"INV"."created_at"', 'DESC')
+      if (locationSortingRules) {
+        for (const key in locationSortingRules) {
+          qb.addOrderBy(`LOC.${key}`, locationSortingRules[key])
+        }
+      }
+      break
+
+    case 'FEFO':
+      qb.orderBy('"INV"."expiration_date"', 'ASC')
+      qb.addOrderBy('"INV"."created_at"', 'ASC')
+      if (locationSortingRules) {
+        for (const key in locationSortingRules) {
+          qb.addOrderBy(`LOC.${key}`, locationSortingRules[key])
+        }
+      }
+      break
+
+    case 'FMFO':
+      qb.orderBy('"INV"."manufacture_date"', 'ASC')
+      qb.addOrderBy('"INV"."created_at"', 'ASC')
+      if (locationSortingRules) {
+        for (const key in locationSortingRules) {
+          qb.addOrderBy(`LOC.${key}`, locationSortingRules[key])
+        }
+      }
+      break
+
+    case 'LOCATION':
+      if (locationSortingRules) {
+        for (const key in locationSortingRules) {
+          if (locIdx === 0) {
+            qb.orderBy(`LOC.${key}`, locationSortingRules[key])
+          } else {
+            qb.addOrderBy(`LOC.${key}`, locationSortingRules[key])
+          }
+          ++locIdx
+        }
+      } else qb.orderBy('"LOC"."name"', 'DESC')
+      break
+  }
+
+  const { entities, raw } = await qb.getRawAndEntities()
+  const items = entities
+    .map((inv: Inventory, idx: number) => {
+      const qty: number = inv?.qty > 0 ? inv.qty : 0
+      const uomValue: number = inv?.uomValue > 0 ? inv.uomValue : 0
+      const lockedQty: number = inv.lockedQty || 0
+      const lockedUomValue: number = inv.lockedUomValue || 0
+      const releaseQty: number = parseInt(raw[idx].releaseQty) || 0
+      const releaseUomValue: number = parseFloat(raw[idx].releaseUomValue) || 0
+
+      return {
+        ...inv,
+        qty: qty - lockedQty - releaseQty,
+        uomValue: uomValue - lockedUomValue - releaseUomValue
+      }
+    })
+    .filter((inv: Inventory) => inv.qty > 0)
+
+  const total: number = await qb.getCount()
+  return { items, total }
+}
+
+export async function isInventoryExpiring(inventory: Inventory): Promise<boolean> {
+  if (!inventory.id) throw new Error('No inventory id provided')
+  let product: Product | undefined = inventory.product
+  if (!product) {
+    inventory = await getRepository(Inventory).findOne({
+      where: { id: inventory.id },
+      relations: ['product']
+    })
+    product = inventory.product
+  }
+
+  const { expirationDate } = inventory
+  const { isRequiredCheckExpiry, expirationPeriod } = product
+
+  if (!isRequiredCheckExpiry || !expirationPeriod || Number(expirationDate) <= 0) return false
+
+  let date: Date = new Date()
+  const acceptBefore: Date = new Date(date.setDate(date.getDate() + expirationPeriod))
+  const expiryDate: Date = new Date(expirationDate)
+
+  return expiryDate < acceptBefore
+}