@things-factory/sales-base 4.3.186 → 4.3.188

package/server/service/replenishment/replenishment-type.ts

@@ -0,0 +1,78 @@
+import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
+
+import { Replenishment, ReplenishmentStatus } from './replenishment'
+
+import { Bizplace } from '@things-factory/biz-base'
+import { ProductPatch, ProductDetailPatch } from '@things-factory/product-base'
+
+@InputType()
+export class NewReplenishment {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => ReplenishmentStatus, { nullable: true })
+  state?: ReplenishmentStatus
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  params?: string
+}
+
+@InputType()
+export class ReplenishmentPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => ReplenishmentStatus, { nullable: true })
+  state?: ReplenishmentStatus
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field()
+  cuFlag: string
+}
+
+@InputType()
+export class ReplenishmentInventoryPatch {
+  @Field({ nullable: true })
+  bizplaceId?: string
+
+  @Field({ nullable: true })
+  releaseQty?: number
+
+  @Field({ nullable: true })
+  releaseUomValue?: number
+
+  @Field({ nullable: true })
+  packingType?: string
+
+  @Field({ nullable: true })
+  packingSize?: number
+
+  @Field({ nullable: true })
+  type?: string
+
+  @Field({ nullable: true })
+  productDetailId?: string
+}
+
+@ObjectType()
+export class ReplenishmentList {
+  @Field(type => [Replenishment])
+  items: Replenishment[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/replenishment/replenishment.ts

@@ -0,0 +1,87 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  OneToMany
+} from 'typeorm'
+import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
+
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { OrderInventory, OrderProduct } from '../'
+
+export enum ReplenishmentStatus {
+  STATUS_A = 'STATUS_A',
+  STATUS_B = 'STATUS_B'
+}
+
+registerEnumType(ReplenishmentStatus, {
+  name: 'ReplenishmentStatus',
+  description: 'state enumeration of a replenishment'
+})
+
+@Entity()
+@Index('ix_replenishment_0', (replenishment: Replenishment) => [replenishment.domain, replenishment.name], {
+  unique: true
+})
+@ObjectType({ description: 'Entity for Replenishment' })
+export class Replenishment {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @Column()
+  @Field({ nullable: true })
+  name: string
+
+  @Column()
+  @Field({ nullable: true })
+  status: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((replenishment: Replenishment) => replenishment.domain)
+  domainId: string
+
+  @OneToMany(type => OrderInventory, orderInventory => orderInventory.replenishment)
+  @Field(type => [OrderInventory], { nullable: true })
+  orderInventories: OrderInventory[]
+
+  @OneToMany(type => OrderProduct, orderProduct => orderProduct.replenishment)
+  @Field(type => [OrderProduct], { nullable: true })
+  orderProducts: OrderProduct[]
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((replenishment: Replenishment) => replenishment.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((replenishment: Replenishment) => replenishment.creator)
+  updaterId?: string
+}

package/server/utils/datetime-util.ts

@@ -52,3 +52,17 @@ export class DateTimeConverter {
     return unloadDate
   }
 }
+
+export class DateTimeDifference {
+  static timeDifferenceInSeconds(prevDateTime, curDateTime) {
+    let diffInSeconds: any = ''
+    if (prevDateTime && curDateTime) {
+      let dateA: any = new Date(prevDateTime)
+      let dateB: any = new Date(curDateTime)
+
+      diffInSeconds = (dateB.getTime() - dateA.getTime()) / 1000
+    }
+
+    return diffInSeconds
+  }
+}

package/server/utils/inventory-util.ts

@@ -106,6 +106,8 @@ export const InventoryUtil = {
               COALESCE(SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(oi.release_qty, 0)) - MAX(COALESCE(bp.bundle_product_release_qty, 0)),0) AS "remainQty",
               COALESCE(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)),0) AS "remainUomValue",
               concat(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)), ' ', pd.uom) AS "remainUomValueWithUom",
+              COALESCE(SUM(COALESCE(i.transfer_qty, 0)), 0) AS "transferQty",
+              COALESCE(SUM(COALESCE(i.transfer_uom_value, 0)), 0) AS "transferUomValue",
               'SINGLE' AS "groupType"
             FROM products p
             INNER join product_details pd on pd.product_id = p.id
@@ -148,12 +150,16 @@ export const InventoryUtil = {
             COALESCE(MIN(FLOOR(pbs."availableQty")),0) AS "remainQty", 
             COALESCE(MIN(FLOOR(pbs."availableUomValue")),0) AS "remainUomValue", 
             CONCAT(COALESCE(MIN(FLOOR(pbs."availableUomValue")),0),' UNIT') AS "remainUomValueWithUom", 
+            COALESCE(MIN(FLOOR(pbs."transferQty")),0) AS "transferQty", 
+            COALESCE(MIN(FLOOR(pbs."transferUomValue")),0) AS "transferUomValue", 
             'BUNDLE' AS "groupType"
             FROM product_bundles pb
             LEFT JOIN (
               SELECT pbs.product_id, pbs.product_bundle_id, min(pbs.bundle_qty),
               (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",
+              (SUM(COALESCE(i2.transfer_qty, 0)) / min(pbs.bundle_qty)) AS "transferQty",
+              (SUM(COALESCE(i2.transfer_uom_value, 0)) / min(pbs.bundle_qty)) AS "transferUomValue",
               pbs.product_detail_id
               FROM product_bundle_settings pbs 
               LEFT JOIN inventories i2 ON i2.product_id = pbs.product_id AND i2.domain_id = $1 AND i2.status = 'STORED'
@@ -299,6 +305,8 @@ export const InventoryUtil = {
             WHERE i.domain_id = $1
             AND l2.type NOT IN ('${LOCATION_TYPE.QUARANTINE}', '${LOCATION_TYPE.RESERVE}')
             AND i.obsolete = false
+            AND i.transfer_qty <= 0
+            AND i.transfer_uom_value <= 0
             AND case when i.expiration_date is not null and p.shelf_life is not null then CURRENT_DATE < i.expiration_date - p.shelf_life else true end
             ${productWhereClause}
             GROUP BY
@@ -601,7 +609,8 @@ export const InventoryUtil = {
     customerBizplace: Bizplace,
     domain: Domain,
     trxMgr: EntityManager,
-    batchId?: string
+    batchId?: string,
+    preferLocation: string = null
   ): Promise<OrderInventory[]> {
     let strictProduct = 'false'
 
@@ -627,6 +636,7 @@ export const InventoryUtil = {
 
     let qb: SelectQueryBuilder<Inventory> = trxMgr.getRepository(Inventory).createQueryBuilder('iv')
     qb.innerJoinAndSelect('iv.location', 'loc')
+      .innerJoin('warehouse_inventory_assignment_rankings', 'wiar', '"wiar"."location_type" = "loc"."type"')
       .innerJoin('iv.product', 'p')
       .andWhere('"iv"."domain_id" = :domainId')
       .andWhere('"iv"."bizplace_id" = :bizplaceId')
@@ -634,6 +644,8 @@ export const InventoryUtil = {
       .andWhere('"iv"."qty" - COALESCE("iv"."locked_qty", 0) > 0')
       .andWhere('"loc"."type" NOT IN (:...locationTypes)')
       .andWhere('"iv"."obsolete" = false')
+      .andWhere('"iv"."transfer_qty" <= 0')
+      .andWhere('"iv"."transfer_uom_value" <= 0')
       .andWhere('"iv"."product_id" = :productId')
       .andWhere(
         'case when "iv"."expiration_date" is not null and "p"."shelf_life" is not null then CURRENT_DATE < "iv"."expiration_date" - "p"."shelf_life" else true end'
@@ -650,7 +662,10 @@ export const InventoryUtil = {
       qb.andWhere('"iv"."batch_id" = :batchId', { batchId: batchId })
     }
 
-    if (strictProduct == 'true') {
+    if (preferLocation) {
+      qb.andWhere('"loc"."type" = :preferLocation', { preferLocation })
+    }
+    if (strictProduct == 'true' || preferLocation == 'STORAGE') {
       qb.andWhere('"iv"."product_detail_id" = :productDetailId', { productDetailId: productDetail.id })
     } else {
       qb.andWhere('"iv"."packing_type" = :packingType', { packingType: orderInventory.packingType })
@@ -672,6 +687,8 @@ export const InventoryUtil = {
       return qb
     }
 
+    qb.addOrderBy('"wiar"."rank"', 'ASC')
+
     switch (product?.pickingStrategy) {
       case 'FIFO':
         qb.addOrderBy('"iv"."created_at"', 'ASC')

package/server/utils/order-no-generator.ts

@@ -78,6 +78,13 @@ export class OrderNoGenerator {
     return `OTI-${uuidv4()}`
   }
 
+  static replenishment() {
+    const currentDate = new Date()
+    return `RP-${currentDate.getFullYear()}${
+      currentDate.getMonth() + 1
+    }${currentDate.getDate()}${currentDate.getHours()}${currentDate.getMinutes()}${currentDate.getSeconds()}${currentDate.getMilliseconds()}`
+  }
+
   static purchaseOrder() {
     const currentDate = new Date()
     return `PO-${currentDate.getFullYear()}${