@things-factory/warehouse-base 4.1.41 → 4.2.0

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]
   )