@things-factory/sales-base 4.3.355 → 4.3.358

package/server/service/inventory-check-item/inventory-check-item-types.ts

@@ -0,0 +1,77 @@
+import { Field, Float, InputType, Int, ObjectType } from 'type-graphql'
+import { NewProduct } from '@things-factory/product-base'
+import { InventoryPatch } from '@things-factory/warehouse-base'
+import { ObjectRef } from '@things-factory/shell'
+import { InventoryCheckItem } from './inventory-check-item'
+
+@ObjectType()
+export class InventoryCheckItemList {
+  @Field(type => [InventoryCheckItem], { nullable: true })
+  items: InventoryCheckItem[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class NewInventoryCheckItem {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field(type => InventoryPatch, { nullable: true })
+  inventory: InventoryPatch
+
+  @Field(type => NewProduct, { nullable: true })
+  product: NewProduct
+
+  @Field(type => ObjectRef, { nullable: true })
+  productDetail: ObjectRef
+
+  @Field({ nullable: true })
+  type: string
+}
+
+@InputType()
+export class InventoryCheckItemPatch {
+  @Field({ nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  inventory: ObjectRef
+
+  @Field({ nullable: true })
+  batchId: string
+
+  @Field({ nullable: true })
+  batchIdRef: string
+
+  @Field(type => Int, { nullable: true })
+  inspectedQty: number
+
+  @Field(type => Float, { nullable: true })
+  inspectedUomValue: number
+
+  @Field(type => ObjectRef, { nullable: true })
+  inspectedLocation: ObjectRef
+
+  @Field({ nullable: true })
+  inspectedBatchNo: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  product: ObjectRef
+
+  @Field({ nullable: true })
+  productId: string
+
+  @Field({ nullable: true })
+  productDetailId: string
+
+  @Field({ nullable: true })
+  status: string
+}

package/server/service/inventory-check-item/inventory-check-item.ts

@@ -0,0 +1,159 @@
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Domain } from '@things-factory/shell'
+import { Field, ID, ObjectType } from 'type-graphql'
+import { Inventory, Location } from '@things-factory/warehouse-base'
+import { Product, ProductDetail } from '@things-factory/product-base'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+import { InventoryCheck } from '..'
+
+@Entity()
+@Index(
+  'ix_inventory-check-item_0',
+  (inventoryCheckItem: InventoryCheckItem) => [inventoryCheckItem.domain, inventoryCheckItem.name],
+  {
+    unique: true
+  }
+)
+@Index(
+  'ix_inventory-check-item_1',
+  (inventoryCheckItem: InventoryCheckItem) => [
+    inventoryCheckItem.bizplace,
+    inventoryCheckItem.inventoryCheck,
+    inventoryCheckItem.inventory,
+    inventoryCheckItem.countNo
+  ],
+  {
+    unique: true
+  }
+)
+@ObjectType({ description: 'Entity for InventoryCheckItem' })
+export class InventoryCheckItem {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((inventoryCheckItem: InventoryCheckItem) => inventoryCheckItem.domain)
+  domainId: string
+
+  @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace, { nullable: true })
+  bizplace: Bizplace
+
+  @RelationId((inventoryCheckItem: InventoryCheckItem) => inventoryCheckItem.bizplace)
+  bizplaceId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  countNo: number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  originQty: number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  inspectedQty: number
+
+  @Column({ nullable: true, type: 'float' })
+  @Field({ nullable: true })
+  originUomValue: number
+
+  @Column({ nullable: true, type: 'float' })
+  @Field({ nullable: true })
+  inspectedUomValue: number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  originBatchNo: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  inspectedBatchNo: string
+
+  @ManyToOne(type => Location, { nullable: true })
+  @Field(type => Location, { nullable: true })
+  originLocation: Location
+
+  @RelationId((inventoryCheckItem: InventoryCheckItem) => inventoryCheckItem.originLocation)
+  originLocationId: string
+
+  @ManyToOne(type => Location, { nullable: true })
+  @Field(type => Location, { nullable: true })
+  inspectedLocation: Location
+
+  @RelationId((inventoryCheckItem: InventoryCheckItem) => inventoryCheckItem.inspectedLocation)
+  inspectedLocationId: string
+
+  @Column()
+  @Field()
+  status: string
+
+  @ManyToOne(type => InventoryCheck)
+  @Field(type => InventoryCheck, { nullable: true })
+  inventoryCheck: InventoryCheck
+
+  @RelationId((inventoryCheckItem: InventoryCheckItem) => inventoryCheckItem.inventoryCheck)
+  inventoryCheckId: string
+
+  @ManyToOne(type => Inventory, { nullable: true })
+  @Field(type => Inventory, { nullable: true })
+  inventory: Inventory
+
+  @RelationId((inventoryCheckItem: InventoryCheckItem) => inventoryCheckItem.inventory)
+  inventoryId: string
+
+  @ManyToOne(type => Product, { nullable: true })
+  @Field(type => Product, { nullable: true })
+  product: Product
+
+  @RelationId((inventoryCheckItem: InventoryCheckItem) => inventoryCheckItem.product)
+  @Field({ nullable: true })
+  productId: string
+
+  @ManyToOne(type => ProductDetail, { nullable: true })
+  @Field(type => ProductDetail, { nullable: true })
+  productDetail: ProductDetail
+
+  @RelationId((inventoryCheckItem: InventoryCheckItem) => inventoryCheckItem.productDetail)
+  productDetailId: String
+
+  @CreateDateColumn()
+  @Field()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((inventoryCheckItem: InventoryCheckItem) => inventoryCheckItem.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((inventoryCheckItem: InventoryCheckItem) => inventoryCheckItem.updater)
+  updaterId: string
+}

package/server/service/others/other-types.ts

@@ -70,6 +70,12 @@ export class InventoryProductGroup {
   @Field({ nullable: true })
   remainUomValueWithUom: string
 
+  @Field(type => Float, { nullable: true })
+  lockedQty: number
+
+  @Field(type => Float, { nullable: true })
+  unassignedQty: number
+
   @Field({ nullable: true })
   uom: string
 

package/server/utils/inventory-util.ts

@@ -263,110 +263,89 @@ export const InventoryUtil = {
       let queryStrings = `
         CREATE TEMP TABLE temp_inventory_product_group AS (
           SELECT * FROM (
-            WITH oi as (
               SELECT
-                SUM(oi.release_qty) AS release_qty,
-                SUM(oi.release_uom_value) AS release_uom_value,
-                oi.batch_id,
-                oi.batch_id_ref,
-                oi.product_id,
-                p.name AS product_name,
-                oi.packing_type,
-                oi.packing_size,
-                oi.uom
-              FROM
-                order_inventories oi
-              LEFT JOIN
-                products p
-              ON
-                oi.product_id = p.id
-              WHERE
-                (oi.status = 'PENDING' or oi.status = 'PENDING_RECEIVE' or oi.status = 'PENDING_WORKSHEET' or oi.status = 'PENDING_SPLIT')
-                AND oi.batch_id NOTNULL
-                AND oi.product_id NOTNULL
-                AND oi.packing_type NOTNULL
-                AND oi.packing_size NOTNULL
-                AND oi.inventory_id IS NULL
-              GROUP BY
-                oi.batch_id,
-                oi.batch_id_ref,
-                oi.product_id,
-                oi.packing_type,
-                oi.packing_size,
-                oi.uom,
-                p.name
-            )
-            SELECT
-              i.batch_id AS "batchId",
-              i.batch_id_ref AS "batchIdRef",
-              i.packing_type AS "packingType",
-              i.packing_size AS "packingSize",
-              i.uom AS "uom",
-              concat(p.name, ' (', p.description, ')') AS "productName",
-              coalesce(p.sku, '') AS "productSKU",
-              coalesce(p.brand, '') AS "productBrand",
-              p.id AS "productId",
-              i.product_detail_id AS "productDetailId",
-              SUM(COALESCE(i.qty, 0)) - GREATEST(SUM(COALESCE(i.locked_qty, 0)), 0) - MAX(COALESCE(oi.release_qty, 0)) - MAX(COALESCE(bp.bundle_product_release_qty, 0)) - GREATEST(SUM(COALESCE(pds.unassigned_qty, 0)), 0)  AS "remainQty",
-              (
-                CASE WHEN (SUM(COALESCE(i.uom_value, 0)) - GREATEST(SUM(COALESCE(i.locked_uom_value, 0)), 0) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)) - GREATEST(SUM(COALESCE(pds.unassigned_uom_value, 0)), 0)) < 0 THEN 0
-                ELSE SUM(COALESCE(i.uom_value, 0)) - GREATEST(SUM(COALESCE(i.locked_uom_value, 0)), 0) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)) - GREATEST(SUM(COALESCE(pds.unassigned_uom_value, 0)), 0) END
-              )  AS "remainUomValue",
-              (
-                CASE WHEN (SUM(COALESCE(i.uom_value, 0)) - GREATEST(SUM(COALESCE(i.locked_uom_value, 0)), 0) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)) - GREATEST(SUM(COALESCE(pds.unassigned_uom_value, 0)), 0)) < 0 THEN concat(0, ' ', i.uom)
-                ELSE concat(SUM(COALESCE(i.uom_value, 0)) - GREATEST(SUM(COALESCE(i.locked_uom_value, 0)), 0) - MAX(COALESCE(oi.release_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)) - GREATEST(SUM(COALESCE(pds.unassigned_uom_value, 0)), 0), ' ', i.uom) END
-              ) AS "remainUomValueWithUom",
-              'SINGLE' AS "groupType"
-            FROM
-              inventories i
+                  i.batch_id AS "batchId",
+                  i.batch_id_ref AS "batchIdRef",
+                  i.packing_type AS "packingType",
+                  i.packing_size AS "packingSize",
+                  i.uom AS "uom",
+                  CONCAT(p.name, ' (', p.description, ')') AS "productName",
+                  COALESCE(p.sku, '') AS "productSKU",
+                  COALESCE(p.brand, '') AS "productBrand",
+                  p.id AS "productId",
+                  i.product_detail_id AS "productDetailId",
+                  SUM(COALESCE(i.qty, 0)) - SUM(COALESCE(i.locked_qty, 0)) - MAX(COALESCE(bp.bundle_product_release_qty, 0)) - SUM(COALESCE(pds.unassigned_qty, 0)) AS "remainQty",
+                  SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)) - SUM(COALESCE(pds.unassigned_uom_value, 0)) AS "remainUomValue",
+                  SUM(COALESCE(i.locked_qty, 0)) AS "lockedQty",
+                  CONCAT(SUM(COALESCE(i.uom_value, 0)) - SUM(COALESCE(i.locked_uom_value, 0)) - MAX(COALESCE(bp.bundle_product_release_uom_value, 0)) - SUM(COALESCE(pds.unassigned_uom_value, 0)), ' ', i.uom) AS "remainUomValueWithUom",
+                  'SINGLE' AS "groupType",
+                  SUM(COALESCE(pds.unassigned_qty, 0)) AS "unassignedQty"
+              FROM inventories i
               LEFT JOIN products p ON i.product_id = p.id
               LEFT JOIN product_detail_stocks pds ON pds.product_detail_id = i.product_detail_id
-              LEFT JOIN oi ON i.batch_id = oi.batch_id AND p.name = oi.product_name AND i.packing_type = oi.packing_type AND i.packing_size = oi.packing_size AND i.uom = oi.uom
-              LEFT JOIN locations l2 ON i.location_id = l2.id AND i.domain_id = l2.domain_id
               LEFT JOIN (
-                SELECT pbs.product_id, SUM(pbs.bundle_qty * src.release_qty) AS bundle_product_release_qty, SUM(pbs.bundle_qty * src.release_uom_value) AS bundle_product_release_uom_value 
-                FROM product_bundle_settings pbs
-                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
-            AND l2.type NOT IN ('${LOCATION_TYPE.QUARANTINE}', '${LOCATION_TYPE.RESERVE}', '${LOCATION_TYPE.DAMAGE}')
-            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.min_outbound_shelf_life is not null then CURRENT_DATE < i.expiration_date - p.min_outbound_shelf_life else true end
-            ${productWhereClause}
-            GROUP BY
-            i.product_detail_id,
-            i.batch_id,
-            i.batch_id_ref,
-            p.id,
-            i.packing_type,
-            i.packing_size,
-            i.uom
-            UNION 
-            SELECT 'BUNDLE' AS "batchId", null as "batchIdRef", packing_type, packing_size,'UNIT' AS "uom", name AS "productName", sku AS "productSKU", 'brand' AS "productBrand", id AS "productId", pbs.product_detail_id AS "productDetailId",
-            MIN(FLOOR(pbs."availableQty")) AS "remainQty", 
-            MIN(FLOOR(pbs."availableUomValue")) AS "remainUomValue", 
-            CONCAT(MIN(FLOOR(pbs."availableUomValue")),' UNIT') AS "remainUomValueWithUom", 
-            'BUNDLE' AS "groupType"
-            FROM product_bundles pb
-            INNER JOIN (
-              SELECT pbs.product_id, pbs.product_bundle_id, min(pbs.bundle_qty),
-              (SUM(COALESCE(i2.qty, 0)) - GREATEST(SUM(COALESCE(i2.locked_qty, 0)), 0) - MAX(COALESCE(oi.release_qty, 0))) / min(pbs.bundle_qty) AS "availableQty",
-              (SUM(COALESCE(i2.uom_value, 0)) - GREATEST(SUM(COALESCE(i2.locked_uom_value, 0)), 0) - MAX(COALESCE(oi.release_uom_value, 0))) / min(pbs.bundle_qty)  AS "availableUomValue",
-              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.bizplace_id IN (${bizplaceIds})
-              AND i2.status = 'STORED'
-              LEFT JOIN oi ON oi.product_id = i2.product_id
-              GROUP BY pbs.product_id, pbs.product_bundle_id, pbs.product_detail_id
-            ) pbs ON pbs.product_bundle_id = pb.id
-            ${bundleWhereClause}
-            GROUP BY pb.packing_type, pb.packing_size, pb.name, pb.sku, pb.id, pbs.product_detail_id
-          )
-          AS inv_prod_grp
+                  SELECT
+                      pbs.product_id,
+                      SUM(pbs.bundle_qty * src.release_qty) AS bundle_product_release_qty,
+                      SUM(pbs.bundle_qty * src.release_uom_value) AS bundle_product_release_uom_value 
+                  FROM product_bundle_settings pbs
+                  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
+              LEFT JOIN locations l2 ON i.location_id = l2.id AND i.domain_id = l2.domain_id
+              WHERE i.domain_id = $1
+              AND l2.type NOT IN ('${LOCATION_TYPE.QUARANTINE}', '${LOCATION_TYPE.RESERVE}', '${LOCATION_TYPE.DAMAGE}')
+              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.min_outbound_shelf_life IS NOT NULL THEN CURRENT_DATE < i.expiration_date - p.min_outbound_shelf_life ELSE true END
+              ${productWhereClause}
+              GROUP BY
+                  i.product_detail_id,
+                  i.batch_id,
+                  i.batch_id_ref,
+                  p.id,
+                  i.packing_type,
+                  i.packing_size,
+                  i.uom
+              UNION
+              SELECT
+                  'BUNDLE' AS "batchId",
+                  NULL AS "batchIdRef",
+                  pb.packing_type,
+                  pb.packing_size,
+                  'UNIT' AS "uom",
+                  pb.name AS "productName",
+                  pb.sku AS "productSKU",
+                  'brand' AS "productBrand",
+                  id AS "productId",
+                  pbs.product_detail_id AS "productDetailId",
+                  MIN(FLOOR(pbs."availableQty")) AS "remainQty", 
+                  MIN(FLOOR(pbs."availableUomValue")) AS "remainUomValue", 
+                  MIN(FLOOR(pbs."releaseQty")) AS "lockedQty", 
+                  CONCAT(MIN(FLOOR(pbs."availableUomValue")), ' UNIT') AS "remainUomValueWithUom",
+                  'BUNDLE' AS "groupType",
+                  0 AS "unassignedQty"
+              FROM product_bundles pb
+              INNER JOIN (
+                  SELECT
+                      pbs.product_id,
+                      pbs.product_bundle_id,
+                      MIN(pbs.bundle_qty),
+                      (SUM(COALESCE(i2.qty, 0)) - GREATEST(SUM(COALESCE(i2.locked_qty, 0)), 0)) / MIN(pbs.bundle_qty) AS "availableQty",
+                      (SUM(COALESCE(i2.uom_value, 0)) - GREATEST(SUM(COALESCE(i2.locked_uom_value, 0)), 0)) / MIN(pbs.bundle_qty)  AS "availableUomValue",
+                      (SUM(COALESCE(i2.locked_qty, 0))) / min(pbs.bundle_qty) AS "releaseQty",
+                      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.bizplace_id IN (${bizplaceIds})
+                  AND i2.status = 'STORED'
+                  GROUP BY pbs.product_id, pbs.product_bundle_id, pbs.product_detail_id
+              ) pbs ON pbs.product_bundle_id = pb.id
+              ${bundleWhereClause}
+              GROUP BY pb.packing_type, pb.packing_size, pb.name, pb.sku, pb.id, pbs.product_detail_id
+          ) AS inv_prod_grp
           ${whereClause}
         )
       `
@@ -819,7 +798,12 @@ async function getConditions(
   let bundleWhereClause = `
     WHERE pb.status = 'ACTIVATED'
   `
-  let whereClause = hasRemainingQty ? ` WHERE "remainQty" > 0 ` : ` WHERE 1 = 1 `
+  // Find the showAllInventory filter
+  const showAllInventoryFilter = filters.find(filter => filter.name === 'showAllInventory')
+  const showAllInventory = showAllInventoryFilter ? showAllInventoryFilter.value : false
+
+  // Set the whereClause based on the showAllInventory value
+  let whereClause = showAllInventory ? ` WHERE 1 = 1 ` : hasRemainingQty ? ` WHERE "remainQty" > 0 ` : ` WHERE 1 = 1 `
 
   let productDetailWhereClause = ``
 

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

@@ -36,6 +36,10 @@ export class OrderNoGenerator {
     }${currentDate.getDate()}${currentDate.getHours()}${currentDate.getMinutes()}${currentDate.getSeconds()}${currentDate.getMilliseconds()}`
   }
 
+  static inventoryCheckItem() {
+    return uuidv4()
+  }
+
   static jobSheet(domainName) {
     const currentDate = new Date()
     return `${domainName}-${currentDate.getFullYear()}${