@things-factory/warehouse-base 4.1.38 → 4.2.0

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

@@ -1,7 +1,8 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { Brackets, getRepository, SelectQueryBuilder } from 'typeorm'
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { Brackets, EntityManager, getRepository, In, Not, SelectQueryBuilder } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
+import { Product } from '@things-factory/product-base'
 import { convertListParams, Domain, ListParam } from '@things-factory/shell'
 
 import { INVENTORY_STATUS } from '../../constants'
@@ -25,11 +26,81 @@ export class InventoryItemQuery {
     const { domain } = context.state
 
     const convertedParams = convertListParams(params, domain.id)
-    const [items, total] = await getRepository(InventoryItem).findAndCount(convertedParams)
+    const [items, total] = await getRepository(InventoryItem).findAndCount({
+      ...convertedParams,
+      relations: ['inventory', 'product']
+    })
 
     return { items, total }
   }
 
+  @Directive('@transaction')
+  @Query(returns => InventoryItemList, { description: 'To fetch multiple InventoryItems with InventoryItemChanges' })
+  async inventoryItemsWithChanges(@Args() params: ListParam, @Ctx() context: any): Promise<InventoryItemList> {
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+
+    const page = params?.pagination?.page
+    const limit = params?.pagination?.limit
+
+    let inventoryFilter = params.filters.find(filter => filter.name == 'inventoryId')
+
+    let items: any = []
+    let total: any = 0
+    if (inventoryFilter) {
+      await tx.query(
+        `
+        create temp table temp_inventory_items on commit drop as (
+          select * from (
+            select ii.id, ii.name, ii.serial_number, '' as "type", 'ORIGINAL' as "transaction_type", i2.id as inventory_id, i2.name as inventory_name, i2.pallet_id as pallet_id, i2.carton_id as carton_id, p2.id as product_id, p2.name as product_name, p2.sku as product_sku from inventory_items ii 
+            inner join inventories i2 on i2.id = ii.inventory_id 
+            inner join products p2 on p2.id = i2.product_id
+            where ii.domain_id = $1 and ii.inventory_id = $2 and ii.status = $3
+          ) src
+        )
+      `,
+        [domain.id, inventoryFilter.value, INVENTORY_STATUS.STORED]
+      )
+
+      const offsetQuery: string = params?.pagination ? `OFFSET ${(page - 1) * limit} LIMIT ${limit}` : ''
+
+      items = await tx.query(`
+        select * from temp_inventory_items ${offsetQuery}
+      `)
+
+      total = await tx.query(`
+        select count(*) from temp_inventory_items
+      `)
+
+      items = items.map(item => {
+        return {
+          id: item.id,
+          name: item.name,
+          serialNumber: item.serial_number,
+          type: item.type,
+          transactionType: item.transaction_type,
+          inventory: {
+            id: item.inventory_id,
+            name: item.inventory_name,
+            palletId: item.pallet_id,
+            cartonId: item.carton_id
+          },
+          product: {
+            id: item.product_id,
+            name: item.product_name,
+            sku: item.product_sku
+          }
+        }
+      })
+
+      total = total[0].count
+    }
+
+    return {
+      items,
+      total
+    }
+  }
+
   @Query(returns => InventoryItemList, { description: 'To fetch multiple InventoryItems by inventory' })
   async inventoryItemsByInventory(@Args() params: ListParam, @Ctx() context: any): Promise<InventoryItemList> {
     const { domain } = context.state
@@ -47,6 +118,7 @@ export class InventoryItemQuery {
     qb.leftJoinAndSelect('ivi.product', 'product').leftJoinAndSelect('ivi.inventory', 'inventory')
     qb.where('ivi.product_id=:productId', { productId: productIdFilter.value })
     qb.andWhere('inventory.status!=:inventoryStatus', { inventoryStatus: INVENTORY_STATUS.PARTIALLY_UNLOADED })
+    qb.andWhere('inventory.domain_id=:domainId', { domainId: domain.id })
 
     if (orderTypeFilter.value == 'inbound') {
       qb.andWhere('ivi.inbound_order_id=:orderId', { orderId: orderIdFilter.value })
@@ -116,3 +188,26 @@ export class InventoryItemQuery {
     return await getRepository(User).findOne(inventoryItem.creatorId)
   }
 }
+
+export async function checkExistingSerialNumber(
+  serialNumber: string,
+  product: Product,
+  context: any,
+  inventory?: Inventory,
+  tx?: EntityManager
+) {
+  const { domain }: { domain: Domain } = context.state
+
+  let countCondition: any = {
+    domain,
+    product,
+    serialNumber,
+    status: Not(In([INVENTORY_STATUS.DELETED, INVENTORY_STATUS.TERMINATED]))
+  }
+
+  if (inventory) countCondition = { ...countCondition, inventory }
+
+  const duplicatedSerialNumberCnt: number = await tx.getRepository(InventoryItem).count(countCondition)
+
+  if (duplicatedSerialNumberCnt) return true
+}

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

@@ -96,4 +96,10 @@ export class InventoryItem {
 
   @RelationId((inventoryItem: InventoryItem) => inventoryItem.creator)
   updaterId?: string
+
+  @Field({ nullable: true })
+  type?: string
+
+  @Field({ nullable: true })
+  transactionType?: string
 }

package/server/service/inventory-item-change/index.ts

@@ -0,0 +1,6 @@
+import { InventoryItemChange } from './inventory-item-change'
+import { InventoryItemChangeQuery } from './inventory-item-change-query'
+import { InventoryItemChangeMutation } from './inventory-item-change-mutation'
+
+export const entities = [InventoryItemChange]
+export const resolvers = [InventoryItemChangeQuery, InventoryItemChangeMutation]

package/server/service/inventory-item-change/inventory-item-change-mutation.ts

@@ -0,0 +1,116 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { InventoryNoGenerator } from '../../utils'
+import { InventoryItemChange } from './inventory-item-change'
+import { InventoryItemChangePatch, NewInventoryItemChange } from './inventory-item-change-type'
+
+@Resolver(InventoryItemChange)
+export class InventoryItemChangeMutation {
+  @Directive('@transaction')
+  @Mutation(returns => InventoryItemChange, { description: 'To create new InventoryItemChange' })
+  async createInventoryItemChange(
+    @Arg('inventoryItemChange') inventoryItemChange: NewInventoryItemChange,
+    @Ctx() context: any
+  ): Promise<InventoryItemChange> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(InventoryItemChange).save({
+      ...inventoryItemChange,
+      name: InventoryNoGenerator.inventoryName(),
+      status: 'PENDING_SUBMISSION',
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => InventoryItemChange, { description: 'To modify InventoryItemChange information' })
+  async updateInventoryItemChange(
+    @Arg('id') id: string,
+    @Arg('patch') patch: InventoryItemChangePatch,
+    @Ctx() context: any
+  ): Promise<InventoryItemChange> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(InventoryItemChange)
+    const inventoryItemChange = await repository.findOne({
+      where: { domain, id }
+    })
+
+    return await repository.save({
+      ...inventoryItemChange,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [InventoryItemChange], { description: "To modify multiple InventoryItemChanges' information" })
+  async updateMultipleInventoryItemChange(
+    @Arg('patches', type => [InventoryItemChangePatch]) patches: InventoryItemChangePatch[],
+    @Ctx() context: any
+  ): Promise<InventoryItemChange[]> {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const inventoryItemChangeRepo = tx.getRepository(InventoryItemChange)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await inventoryItemChangeRepo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const inventoryItemChange = await inventoryItemChangeRepo.findOne(newRecord.id)
+
+        const result = await inventoryItemChangeRepo.save({
+          ...inventoryItemChange,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete InventoryItemChange' })
+  async deleteInventoryItemChange(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(InventoryItemChange).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple inventoryItemChanges' })
+  async deleteInventoryItemChanges(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(InventoryItemChange).delete({
+      domain,
+      id: In(ids)
+    })
+
+    return true
+  }
+}

package/server/service/inventory-item-change/inventory-item-change-query.ts

@@ -0,0 +1,43 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { getRepository } from 'typeorm'
+import { Domain, ListParam, convertListParams } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { InventoryItemChange } from './inventory-item-change'
+import { InventoryItemChangeList } from './inventory-item-change-type'
+
+@Resolver(InventoryItemChange)
+export class InventoryItemChangeQuery {
+  @Query(returns => InventoryItemChange, { description: 'To fetch a InventoryItemChange' })
+  async inventoryItemChange(@Arg('id') id: string, @Ctx() context: any): Promise<InventoryItemChange> {
+    const { domain } = context.state
+
+    return await getRepository(InventoryItemChange).findOne({
+      where: { domain, id }
+    })
+  }
+
+  @Query(returns => InventoryItemChangeList, { description: 'To fetch multiple InventoryItemChanges' })
+  async inventoryItemChanges(@Args() params: ListParam, @Ctx() context: any): Promise<InventoryItemChangeList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, domain.id)
+    const [items, total] = await getRepository(InventoryItemChange).findAndCount(convertedParams)
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() inventoryItemChange: InventoryItemChange): Promise<Domain> {
+    return await getRepository(Domain).findOne(inventoryItemChange.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() inventoryItemChange: InventoryItemChange): Promise<User> {
+    return await getRepository(User).findOne(inventoryItemChange.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() inventoryItemChange: InventoryItemChange): Promise<User> {
+    return await getRepository(User).findOne(inventoryItemChange.creatorId)
+  }
+}

package/server/service/inventory-item-change/inventory-item-change-type.ts

@@ -0,0 +1,68 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { InventoryItemChange } from './inventory-item-change'
+
+@InputType()
+export class NewInventoryItemChange {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  serialNumber?: string
+
+  @Field({ nullable: true })
+  type?: string
+
+  @Field({ nullable: true })
+  status?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  inventory?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  inventoryItem?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  inventoryChange?: ObjectRef
+}
+
+@InputType()
+export class InventoryItemChangePatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  serialNumber?: string
+
+  @Field({ nullable: true })
+  type?: string
+
+  @Field({ nullable: true })
+  status?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  inventory?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  inventoryItem?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  inventoryChange?: ObjectRef
+
+  @Field({ nullable: true })
+  cuFlag: string
+}
+
+@ObjectType()
+export class InventoryItemChangeList {
+  @Field(type => [InventoryItemChange])
+  items: InventoryItemChange[]
+
+  @Field(type => Int)
+  total: number
+}

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

@@ -0,0 +1,92 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { InventoryChange } from '../inventory-change/inventory-change'
+import { InventoryItem } from '../inventory-item/inventory-item'
+import { Inventory } from '../inventory/inventory'
+
+@Entity()
+@Index(
+  'ix_inventory_item_change_0',
+  (inventoryItemChange: InventoryItemChange) => [inventoryItemChange.domain, inventoryItemChange.name],
+  { unique: true }
+)
+@ObjectType({ description: 'Entity for InventoryItemChange' })
+export class InventoryItemChange {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((inventoryItemChange: InventoryItemChange) => inventoryItemChange.domain)
+  domainId?: string
+
+  @ManyToOne(type => InventoryItem, { nullable: true })
+  @Field(type => InventoryItem, { nullable: true })
+  inventoryItem: InventoryItem
+
+  @ManyToOne(type => Inventory, { nullable: true })
+  @Field(type => Inventory, { nullable: true })
+  inventory: Inventory
+
+  @ManyToOne(type => InventoryChange, { nullable: true })
+  @Field(type => InventoryChange, { nullable: true })
+  inventoryChange: InventoryChange
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  serialNumber?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  type?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  status?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((inventoryItemChange: InventoryItemChange) => inventoryItemChange.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((inventoryItemChange: InventoryItemChange) => inventoryItemChange.creator)
+  updaterId?: string
+}

package/server/utils/inventory-util.ts

@@ -383,49 +383,17 @@ export async function getInventoriesByStrategy(
   bizplaceId: string,
   worksheetId: string,
   orderProducts: any[],
-  pickingStrategy: string,
   locationSortingRules: any[],
   trxMgr: EntityManager
 ): Promise<Inventory[]> {
   let orderProductsJSON: string = JSON.stringify(orderProducts)
-  let orderBy: string = 'ORDER BY op."productId"'
-
-  let locationSortings: string[] = (locationSortingRules || []).map((rule: { name: string; descOrder: boolean }) => {
-    return `, l.${rule.name} ${rule.descOrder ? 'DESC' : ''}`
-  })
-
-  switch (pickingStrategy.toUpperCase()) {
-    case 'FIFO':
-      orderBy += ', i.created_at'
-      if (locationSortingRules?.length) {
-        orderBy += locationSortings.join('')
-      }
-      break
-
-    case 'LIFO':
-      orderBy += ', i.created_at DESC'
-      if (locationSortingRules?.length) {
-        orderBy += locationSortings.join('')
-      }
-      break
-
-    case 'FEFO':
-      orderBy += ', i.expiration_date'
-      if (locationSortingRules?.length) {
-        orderBy += locationSortings.join('')
-      }
-      break
-
-    case 'LOCATION':
-      if (locationSortingRules?.length) {
-        orderBy += locationSortings.join('')
-      } else orderBy += ', l.name DESC'
-      break
+  let locationSorting: string = (locationSortingRules || [])
+    .map((rule: { name: string; descOrder: boolean }) => {
+      return `l.${rule.name}${rule.descOrder ? 'DESC' : ''}`
+    })
+    .join(', ')
 
-    default:
-      orderBy += ', i.created_at'
-      break
-  }
+  if (locationSorting === '') locationSorting = 'l.name'
 
   await trxMgr.query(
     `
@@ -435,7 +403,8 @@ export async function getInventoriesByStrategy(
       "packingType" VARCHAR(50),
       "packingSize" INT,
       "uom" VARCHAR(10),
-      "releaseQty" INT
+      "releaseQty" INT,
+      "pickingStrategy" VARCHAR(25)
     );
   `
   )
@@ -443,7 +412,7 @@ export async function getInventoriesByStrategy(
   await trxMgr.query(
     `
     INSERT INTO temp_op2
-    SELECT "productId", "batchId", "packingType", "packingSize", "uom", "releaseQty"
+    SELECT "productId", "batchId", "packingType", "packingSize", "uom", "releaseQty", "pickingStrategy"
     FROM JSON_POPULATE_RECORDSET(NULL::temp_op2, $1) js
   `,
     [orderProductsJSON]
@@ -456,7 +425,7 @@ export async function getInventoriesByStrategy(
       FROM order_inventories oi
       WHERE oi.status IN ('PENDING','PENDING_RECEIVE','PENDING_WORKSHEET','PENDING_SPLIT')
       AND oi.bizplace_id = $1
-      AND oi.inventory_id NOTNULL 
+      AND oi.inventory_id NOTNULL
       AND oi.ref_worksheet_id != $2
       GROUP BY oi.inventory_id
     )
@@ -475,7 +444,16 @@ export async function getInventoriesByStrategy(
     i.uom_value - COALESCE(i.locked_uom_value,0) - COALESCE(foo.total_release_uom_value,0) AS "remainUomValue",
     op."packingType",
     op."packingSize",
-    op."uom"
+    op."uom",
+    ROW_NUMBER() OVER (
+      PARTITION BY op."productId", op."batchId", op."packingType", op."packingSize", op."uom"
+      ORDER BY 
+        CASE WHEN op."pickingStrategy" = 'FIFO' THEN i.created_at END,
+        CASE WHEN op."pickingStrategy" = 'FEFO' THEN i.expiration_date END,
+        CASE WHEN op."pickingStrategy" = 'LIFO' THEN i.created_at END DESC,
+        CASE WHEN op."pickingStrategy" = 'FMFO' THEN i.manufacture_date END,
+        ${locationSorting}
+      ) AS rn
     FROM inventories i
     INNER JOIN locations l ON i.location_id = l.id
       AND l.TYPE NOT IN ($1, $2)
@@ -487,7 +465,7 @@ export async function getInventoriesByStrategy(
     WHERE i.domain_id = $3
     AND i.bizplace_id = $4
     AND i.status = $5
-    ${orderBy}
+    ORDER BY op."productId", rn
   `,
     [LOCATION_TYPE.QUARANTINE, LOCATION_TYPE.RESERVE, domainId, bizplaceId, INVENTORY_STATUS.STORED]
   )