@things-factory/sales-base 4.0.0-y.0 → 4.0.4

package/server/utils/inventory-util.ts

@@ -1,10 +1,39 @@
+import { EntityManager, Equal, getRepository, In, Not, Raw, Repository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
 import { Product, ProductBundle } from '@things-factory/product-base'
-import { Inventory } from '@things-factory/warehouse-base'
 import { Domain, ListParam } from '@things-factory/shell'
-import { EntityManager, In, Raw } from 'typeorm'
+import {
+  Inventory,
+  INVENTORY_STATUS,
+  InventoryHistory,
+  InventoryNoGenerator,
+  Location,
+  LOCATION_STATUS,
+  Pallet
+} from '@things-factory/warehouse-base'
+
 import { ValidationError } from '../errors'
-import { OrderInventory } from 'server/entities'
+import {
+  ArrivalNotice,
+  DeliveryOrder,
+  InventoryCheck,
+  OrderInventory,
+  ReleaseGood,
+  ReturnOrder,
+  ReverseKittingOrder,
+  VasOrder
+} from '../service'
+
+export type ReferenceOrderType =
+  | ArrivalNotice
+  | ReleaseGood
+  | VasOrder
+  | InventoryCheck
+  | DeliveryOrder
+  | ReturnOrder
+  | ReverseKittingOrder
 
 export const InventoryUtil = {
   /**
@@ -18,6 +47,7 @@ export const InventoryUtil = {
   async bizplaceInventoryProductGroup(bizplaces: Bizplace[], params: ListParam, context: any, trxMgr: EntityManager) {
     try {
       let filters = params.filters
+      const { domain }: { domain: Domain } = context.state
 
       const { bizplaceIds, productWhereClause, bundleWhereClause, whereClause, batchBundle } = await getConditions(
         bizplaces,
@@ -81,6 +111,7 @@ export const InventoryUtil = {
               INNER JOIN json_populate_recordset(NULL::order_inventories,'${batchBundle}') src ON src.product_id = pbs.product_bundle_id
               GROUP BY pbs.product_id
             ) bp on i.product_id = bp.product_id
+          WHERE i.domain_id = $1
           ${productWhereClause}
           GROUP BY
           i.batch_id,
@@ -101,7 +132,7 @@ export const InventoryUtil = {
             (SUM(COALESCE(i2.qty, 0)) - SUM(COALESCE(i2.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0))) / min(pbs.bundle_qty) AS "availableQty",
             (SUM(COALESCE(i2.uom_value, 0)) - SUM(COALESCE(i2.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0))) / min(pbs.bundle_qty)  AS "availableUomValue"
             FROM product_bundle_settings pbs 
-            LEFT JOIN inventories i2 ON i2.product_id = pbs.product_id
+            LEFT JOIN inventories i2 ON i2.product_id = pbs.product_id AND i2.domain_id = $1
             AND i2.bizplace_id IN (${bizplaceIds})
             AND i2.status = 'STORED'
             LEFT JOIN oi ON oi.product_id = i2.product_id
@@ -115,7 +146,7 @@ export const InventoryUtil = {
       )
     `
 
-      await trxMgr.query(queryStrings)
+      await trxMgr.query(queryStrings, [domain.id])
 
       const [{ total }]: any = await trxMgr.query(`select count(*) as total from temp_inventory_product_group`)
       let items: any[] = []
@@ -207,6 +238,50 @@ export const InventoryUtil = {
         })
       }
     })
+  },
+
+  async checkPalletDuplication(palletId: string, warehouseDomain: Domain, trxMgr: EntityManager): Promise<void> {
+    const duplicatedPalletCnt: number = await trxMgr.getRepository(Inventory).count({
+      domain: warehouseDomain,
+      palletId,
+      status: Not(Equal(INVENTORY_STATUS.TERMINATED))
+    })
+
+    if (duplicatedPalletCnt) throw new Error(palletId + ` exists`)
+
+    const duplicatedReusablePalletCnt: number = await trxMgr.getRepository(Pallet).count({
+      where: {
+        domain: warehouseDomain,
+        name: palletId
+      }
+    })
+
+    if (duplicatedReusablePalletCnt) throw new Error(palletId + ` exists`)
+  },
+
+  /**
+   * @summary Do transaction on inventory record
+   * @description It will update inventory after set a temp (domain, updater)
+   * and then generate inventory history based on current changes
+   */
+  async transactionInventory(
+    inventory: Partial<Inventory>,
+    referenceOrder: ReferenceOrderType,
+    changedQty: number,
+    changedWeight: number,
+    transactionType: string,
+    user: User,
+    trxMgr: EntityManager
+  ): Promise<Inventory> {
+    if (inventory.id) {
+      inventory = await updateInventory(inventory, trxMgr)
+    } else {
+      inventory = await createInventory(inventory, trxMgr)
+    }
+
+    await generateInventoryHistory(inventory, referenceOrder, transactionType, changedQty, changedWeight, user, trxMgr)
+
+    return inventory
   }
 }
 
@@ -226,7 +301,7 @@ async function getConditions(
   let bizplaceIds = bizplaces.map((bizplace: Bizplace) => `'${bizplace.id}'`).join()
 
   let productWhereClause = `
-    WHERE i.status = 'STORED'
+    AND i.status = 'STORED'
     AND i.bizplace_id IN (${bizplaceIds})
   `
   let bundleWhereClause = `
@@ -368,3 +443,154 @@ async function getConditions(
 
   return { bizplaceIds, productWhereClause, bundleWhereClause, whereClause, batchBundle }
 }
+
+async function createInventory(
+  inventory: Partial<Inventory> | Partial<Inventory>[],
+  trxMgr: EntityManager
+): Promise<Inventory | Inventory[]> {
+  return await trxMgr.getRepository(Inventory).save(inventory)
+}
+
+/**
+ * @summary Update inventory record
+ * @description It will update inventory after set a stamp (domain, updater)
+ * The special point of this function is that this changes won't generate inventory history
+ * If you want to generate inventory history automatically you would better to use transactionInventory function
+ */
+async function updateInventory(
+  inventory: Partial<Inventory> | Partial<Inventory>[],
+  trxMgr: EntityManager
+): Promise<Inventory | Inventory[]> {
+  if (!inventory.id) throw new Error(`Target doesn't have ID`)
+  return await trxMgr.getRepository(Inventory).save(inventory)
+}
+
+async function generateInventoryHistory(
+  inventory: Inventory,
+  refOrder: any,
+  transactionType: string,
+  qty: number,
+  uomValue: number,
+  user: User,
+  trxMgr?: EntityManager
+): 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.count({ domain: inventory.domain, palletId: inventory.palletId })
+  let openingQty: number = 0
+  let openingUomValue: number = 0
+
+  if (seq) {
+    const lastInvHistory: InventoryHistory = await invHistoryRepo.findOne({
+      domain: inventory.domain,
+      palletId: inventory.palletId,
+      seq: seq - 1
+    })
+    openingQty = lastInvHistory.openingQty + lastInvHistory.qty
+    openingUomValue = lastInvHistory.openingUomValue + lastInvHistory.uomValue
+  }
+
+  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.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 = await invHistoryRepo.save(inventoryHistory)
+
+  if (inventory.lastSeq !== seq) {
+    await invRepo.save({
+      ...inventory,
+      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.count({
+    domain,
+    status: INVENTORY_STATUS.STORED,
+    location
+  })
+
+  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
+}

package/server/entities/arrival-notice.ts

@@ -1,168 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace, ContactPoint } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  OneToMany,
-  OneToOne,
-  JoinColumn,
-  PrimaryGeneratedColumn,
-  UpdateDateColumn
-} from 'typeorm'
-
-import { CollectionOrder, OrderProduct, OrderVas, PurchaseOrder, ReleaseGood } from '../entities'
-
-@Entity()
-@Index('ix_arrival-notice_0', (arrivalNotice: ArrivalNotice) => [arrivalNotice.domain, arrivalNotice.name], {
-  unique: true
-})
-export class ArrivalNotice {
-  @PrimaryGeneratedColumn('uuid')
-  id: string
-
-  @ManyToOne(type => Domain, {
-    nullable: false
-  })
-  domain: Domain
-
-  @ManyToOne(type => Bizplace, {
-    nullable: false
-  })
-  bizplace: Bizplace
-
-  @Column()
-  name: string
-
-  @Column({
-    nullable: true
-  })
-  containerNo: string
-
-  @Column({
-    nullable: true
-  })
-  containerSize: String
-
-  @Column({
-    nullable: true
-  })
-  container: boolean
-
-  @Column()
-  ownTransport: boolean
-
-  @Column({ nullable: true })
-  crossDocking: boolean
-
-  @ManyToOne(type => ReleaseGood, { nullable: true })
-  releaseGood: ReleaseGood
-
-  @Column()
-  importCargo: boolean
-
-  @OneToMany(type => OrderProduct, orderProduct => orderProduct.arrivalNotice)
-  orderProducts: OrderProduct[]
-
-  @OneToMany(type => OrderVas, orderVas => orderVas.arrivalNotice)
-  orderVass: OrderVas[]
-
-  @OneToMany(type => CollectionOrder, collectionOrder => collectionOrder.arrivalNotice)
-  collectionOrders: CollectionOrder[]
-
-  @Column({
-    nullable: true
-  })
-  looseItem: boolean
-
-  @Column({
-    nullable: true
-  })
-  eta: Date
-
-  @Column({
-    nullable: true
-  })
-  ata: Date
-
-  @Column({
-    nullable: true
-  })
-  refNo: String
-
-  @Column({
-    nullable: true
-  })
-  refNo2: String
-
-  @Column({
-    nullable: true
-  })
-  refNo3: String
-
-  @Column({
-    nullable: true
-  })
-  etaDate: String
-
-  @Column({
-    nullable: true
-  })
-  truckNo: string
-
-  @Column()
-  status: string
-
-  @Column({
-    nullable: true
-  })
-  remark: string
-
-  @Column({
-    nullable: true
-  })
-  deliveryOrderNo: string
-
-  @Column({
-    nullable: true
-  })
-  description: string
-
-  @OneToOne(type => PurchaseOrder, { nullable: true })
-  @JoinColumn()
-  purchaseOrder: PurchaseOrder
-
-  @CreateDateColumn()
-  createdAt: Date
-
-  @UpdateDateColumn()
-  updatedAt: Date
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  acceptedBy: User
-
-  @Column({
-    nullable: true
-  })
-  acceptedAt: Date
-
-  @ManyToOne(type => ContactPoint, {
-    nullable: true
-  })
-  supplier: ContactPoint
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  creator: User
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  updater: User
-}

package/server/entities/claim-detail.ts

@@ -1,59 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  Entity,
-  Index,
-  Column,
-  OneToMany,
-  ManyToOne,
-  OneToOne,
-  PrimaryGeneratedColumn
-} from 'typeorm'
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { Claim } from '.'
-
-@Entity()
-@Index('ix_claim-detail_0', (claimDetail: ClaimDetail) => [claimDetail.domain, claimDetail.id], { unique: true })
-export class ClaimDetail {
-  @PrimaryGeneratedColumn('uuid')
-  id: string
-
-  @ManyToOne(type => Domain)
-  domain: Domain
-
-  @Column()
-  name: string
-
-  @Column({
-    nullable: true
-  })
-  description: string
-
-  @Column({
-    nullable: true
-  })
-  refNo: String
-
-  @Column('float')
-  amount: number
-
-  @CreateDateColumn()
-  createdAt: Date
-
-  @UpdateDateColumn()
-  updatedAt: Date
-
-  @ManyToOne(type => Claim)
-  claim: Claim
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  creator: User
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  updater: User
-}

package/server/entities/claim-order.ts

@@ -1,63 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  Entity,
-  Index,
-  Column,
-  OneToMany,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  OneToOne,
-  JoinColumn
-} from 'typeorm'
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-
-import { Claim } from '.'
-import { CollectionOrder } from '.'
-import { DeliveryOrder } from '.'
-
-@Entity()
-@Index('ix_claim-order_0', (claimOrder: ClaimOrder) => [claimOrder.domain, claimOrder.id], { unique: true })
-export class ClaimOrder {
-  @PrimaryGeneratedColumn('uuid')
-  id: string
-
-  @ManyToOne(type => Domain)
-  domain: Domain
-
-  @Column()
-  name: string
-
-  @Column({
-    nullable: true
-  })
-  description: string
-
-  @CreateDateColumn()
-  createdAt: Date
-
-  @UpdateDateColumn()
-  updatedAt: Date
-
-  @ManyToOne(type => Claim)
-  claim: Claim
-
-  @ManyToOne(type => CollectionOrder, { nullable: true })
-  @JoinColumn()
-  collectionOrder: CollectionOrder
-
-  @ManyToOne(type => DeliveryOrder, { nullable: true })
-  @JoinColumn()
-  deliveryOrder: DeliveryOrder
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  creator: User
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  updater: User
-}

package/server/entities/claim.ts

@@ -1,123 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  Entity,
-  Index,
-  Column,
-  OneToMany,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  OneToOne,
-  JoinColumn
-} from 'typeorm'
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-
-import { TransportDriver, TransportVehicle } from '@things-factory/transport-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { ClaimDetail, ClaimOrder } from '.'
-
-@Entity()
-@Index('ix_claim_0', (claim: Claim) => [claim.domain, claim.id], { unique: true })
-export class Claim {
-  @PrimaryGeneratedColumn('uuid')
-  id: string
-
-  @ManyToOne(type => Domain)
-  domain: Domain
-
-  @Column()
-  name: string
-
-  @Column({
-    nullable: true
-  })
-  description: string
-
-  @Column({
-    nullable: true
-  })
-  billingMode: string
-
-  @Column({
-    nullable: true
-  })
-  from: string
-
-  @Column({
-    nullable: true
-  })
-  to: string
-
-  @Column({
-    nullable: true
-  })
-  remark: string
-
-  @Column({
-    nullable: true
-  })
-  charges: number
-
-  @Column({
-    nullable: true
-  })
-  drum: number
-
-  @Column({
-    nullable: true
-  })
-  pallet: number
-
-  @Column({
-    nullable: true
-  })
-  carton: number
-
-  @Column({
-    nullable: true
-  })
-  bag: number
-
-  @Column({
-    nullable: true
-  })
-  other: number
-
-  @Column()
-  status: string
-
-  @CreateDateColumn()
-  createdAt: Date
-
-  @UpdateDateColumn()
-  updatedAt: Date
-
-  @OneToMany(type => ClaimDetail, claimDetail => claimDetail.claim)
-  claimDetails: ClaimDetail[]
-
-  @OneToMany(type => ClaimOrder, claimOrder => claimOrder.claim)
-  claimOrders: ClaimOrder[]
-
-  @ManyToOne(type => TransportDriver)
-  @JoinColumn()
-  transportDriver: TransportDriver
-
-  @ManyToOne(type => TransportVehicle)
-  @JoinColumn()
-  transportVehicle: TransportVehicle
-
-  @ManyToOne(type => Bizplace, { nullable: true })
-  @JoinColumn()
-  bizplace: Bizplace
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  creator: User
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  updater: User
-}