@things-factory/worksheet-base 8.0.0-beta.1 → 8.0.0-beta.4

package/server/routes.ts

@@ -1,80 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

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

package/server/utils/inventory-util.ts

@@ -1,390 +0,0 @@
-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
-}