@things-factory/warehouse-base 4.1.29 → 4.1.34

package/server/service/index.ts

@@ -1,6 +1,7 @@
 import { entities as InventoryEntities, resolvers as InventoryResolvers } from './inventory'
 import { entities as InventoryChangeEntities, resolvers as InventoryChangeResolvers } from './inventory-change'
 import { entities as InventoryHistoryEntities, resolvers as InventoryHistoryResvolers } from './inventory-history'
+import { entities as InventoryItemEntities, resolvers as InventoryItemResolvers } from './inventory-item'
 import { entities as LocationEntities, resolvers as LocationResolvers } from './location'
 import { entities as MovementEntities, resolvers as MovementResolvers } from './movement'
 import { entities as PalletEntities, resolvers as PalletResolvers } from './pallet'
@@ -10,6 +11,7 @@ import { entities as ReducedInventoryHistoryEntities } from './reduced-inventory
 import { entities as WarehouseEntities, resolvers as WarehouseResolvers } from './warehouse'
 
 /* EXPORT ENTITY TYPES */
+export * from './inventory-item/inventory-item'
 export * from './inventory/inventory'
 export * from './inventory-change/inventory-change'
 export * from './inventory-history/inventory-history'
@@ -24,6 +26,7 @@ export * from './reduced-inventory-history/reduced-inventory-history'
 /* EXPORT TYPES */
 export * from './inventory/inventory-types'
 export * from './inventory/inventory-types'
+export * from './inventory-item/inventory-item'
 export * from './inventory-change/inventory-change-types'
 export * from './inventory-history/inventory-history-types'
 export * from './location/location-types'
@@ -37,6 +40,7 @@ export const entities = [
   ...InventoryEntities,
   ...InventoryChangeEntities,
   ...InventoryHistoryEntities,
+  ...InventoryItemEntities,
   ...LocationEntities,
   ...MovementEntities,
   ...PalletEntities,
@@ -51,6 +55,7 @@ export const schema = {
     ...InventoryResolvers,
     ...InventoryChangeResolvers,
     ...InventoryHistoryResvolers,
+    ...InventoryItemResolvers,
     ...LocationResolvers,
     ...MovementResolvers,
     ...PalletResolvers,

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

@@ -0,0 +1,6 @@
+import { InventoryItem } from './inventory-item'
+import { InventoryItemMutation } from './inventory-item-mutation'
+import { InventoryItemQuery } from './inventory-item-query'
+
+export const entities = [InventoryItem]
+export const resolvers = [InventoryItemQuery, InventoryItemMutation]

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

@@ -0,0 +1,210 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { Product } from '@things-factory/product-base'
+
+import { INVENTORY_STATUS } from '../../constants'
+import { InventoryNoGenerator } from '../../utils'
+import { InventoryItem } from './inventory-item'
+import { InventoryItemPatch, NewInventoryItem } from './inventory-item-type'
+
+@Resolver(InventoryItem)
+export class InventoryItemMutation {
+  @Directive('@transaction')
+  @Mutation(returns => InventoryItem, { description: 'To create new InventoryItem' })
+  async createInventoryItem(
+    @Arg('inventoryItem') inventoryItem: NewInventoryItem,
+    @Ctx() context: any
+  ): Promise<InventoryItem> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(InventoryItem).save({
+      ...inventoryItem,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => InventoryItem, { description: 'To modify InventoryItem information' })
+  async updateInventoryItem(
+    @Arg('id') id: string,
+    @Arg('patch') patch: InventoryItemPatch,
+    @Ctx() context: any
+  ): Promise<InventoryItem> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(InventoryItem)
+    const inventoryItem = await repository.findOne({
+      where: { domain, id }
+    })
+
+    return await repository.save({
+      ...inventoryItem,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To modify InventoryItem serial number' })
+  async updateInventoryItemSerialNumber(
+    @Arg('id') id: string,
+    @Arg('serialNumber') serialNumber: string,
+    @Ctx() context: any
+  ): Promise<boolean> {
+    try {
+      const { domain, user, tx } = context.state
+
+      const repository = tx.getRepository(InventoryItem)
+
+      const inventoryItem = await repository.findOne({
+        where: { domain, id },
+        relations: ['product']
+      })
+
+      const product: Product = inventoryItem.product
+      const duplicatedSerialNumberCnt: number = await repository.count({
+        domain,
+        product,
+        serialNumber
+      })
+
+      if (duplicatedSerialNumberCnt) throw new Error(`Serial Number ${serialNumber} is duplicated`)
+
+      await repository.update({ id }, { serialNumber, updater: user })
+
+      return true
+    } catch (error) {
+      throw error
+    }
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [InventoryItem], { description: "To modify multiple InventoryItems' information" })
+  async updateMultipleInventoryItem(
+    @Arg('patches', type => [InventoryItemPatch]) patches: InventoryItemPatch[],
+    @Ctx() context: any
+  ): Promise<InventoryItem[]> {
+    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 inventoryItemRepo = tx.getRepository(InventoryItem)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await inventoryItemRepo.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 inventoryItem = await inventoryItemRepo.findOne(newRecord.id)
+
+        const result = await inventoryItemRepo.save({
+          ...inventoryItem,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete InventoryItem' })
+  async deleteInventoryItem(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(InventoryItem).delete({ domain, id })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple inventoryItems' })
+  async deleteInventoryItems(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(InventoryItem).delete({
+      domain,
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => InventoryItem, { description: 'To update picked InventoryItem with new IventoryItem' })
+  async replacePickedInventoryItem(
+    @Arg('selectedSerialNumber') selectedSerialNumber: InventoryItemPatch,
+    @Arg('newSerialNumber') newSerialNumber: string,
+    @Ctx() context: any
+  ): Promise<InventoryItem> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(InventoryItem)
+    const foundSerialNumber = await repository.findOne({
+      where: { domain, serialNumber: newSerialNumber }
+    })
+
+    await repository.update(
+      {
+        domain,
+        id: selectedSerialNumber.id
+      },
+      {
+        status: INVENTORY_STATUS.STORED,
+        outboundOrderId: null,
+        updater: user
+      }
+    )
+
+    if (foundSerialNumber) {
+      if (foundSerialNumber.productId !== selectedSerialNumber.product?.id) {
+        throw new Error('Invalid Serial Number')
+      }
+
+      if (foundSerialNumber.inventoryId !== selectedSerialNumber.inventory?.id) {
+        throw new Error('Serial Number Registered Under Different Inventory')
+      }
+
+      if (foundSerialNumber.status !== INVENTORY_STATUS.STORED) {
+        throw new Error('Inventory Item is not available')
+      }
+
+      foundSerialNumber.status = INVENTORY_STATUS.PICKED
+      foundSerialNumber.updater = user
+      foundSerialNumber.outboundOrderId = selectedSerialNumber.outboundOrderId
+
+      return await repository.save(foundSerialNumber)
+    } else {
+      let inventoryItem: InventoryItem = new InventoryItem()
+      inventoryItem.name = InventoryNoGenerator.inventoryItemName()
+      inventoryItem.serialNumber = newSerialNumber
+      inventoryItem.status = INVENTORY_STATUS.PICKED
+      inventoryItem.outboundOrderId = selectedSerialNumber.outboundOrderId
+      inventoryItem.product = selectedSerialNumber.product
+      inventoryItem.inventory = selectedSerialNumber.inventory
+      inventoryItem.domain = domain
+
+      return await repository.save(inventoryItem)
+    }
+  }
+}

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

@@ -0,0 +1,118 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { Brackets, getRepository, SelectQueryBuilder } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, ListParam } from '@things-factory/shell'
+
+import { INVENTORY_STATUS } from '../../constants'
+import { Inventory } from '../inventory/inventory'
+import { InventoryItem } from './inventory-item'
+import { InventoryItemList } from './inventory-item-type'
+
+@Resolver(InventoryItem)
+export class InventoryItemQuery {
+  @Query(returns => InventoryItem, { description: 'To fetch a InventoryItem' })
+  async inventoryItem(@Arg('id') id: string, @Ctx() context: any): Promise<InventoryItem> {
+    const { domain } = context.state
+
+    return await getRepository(InventoryItem).findOne({
+      where: { domain, id }
+    })
+  }
+
+  @Query(returns => InventoryItemList, { description: 'To fetch multiple InventoryItems' })
+  async inventoryItems(@Args() params: ListParam, @Ctx() context: any): Promise<InventoryItemList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, domain.id)
+    const [items, total] = await getRepository(InventoryItem).findAndCount(convertedParams)
+
+    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
+
+    const page = params.pagination.page
+    const limit = params.pagination.limit
+    const sortings = params.sortings
+
+    let inventoryInfoFilter = params.filters.find(filter => filter.name == 'inventory_info')
+    let orderTypeFilter = params.filters.find(filter => filter.name == 'orderType')
+    let orderIdFilter = params.filters.find(filter => filter.name == 'orderId')
+    let productIdFilter = params.filters.find(filter => filter.name == 'productId')
+
+    let qb: SelectQueryBuilder<InventoryItem> = getRepository(InventoryItem).createQueryBuilder('ivi')
+    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 })
+
+    if (orderTypeFilter.value == 'inbound') {
+      qb.andWhere('ivi.inbound_order_id=:orderId', { orderId: orderIdFilter.value })
+    } else {
+      qb.andWhere('ivi.outbound_order_id=:orderId', { orderId: orderIdFilter.value })
+    }
+
+    if (inventoryInfoFilter) {
+      qb.andWhere(qb => {
+        const subQuery = qb
+          .subQuery()
+          .select()
+          .from(Inventory, `inventories`)
+          .where(`inventories.id = ivi.inventory_id`)
+          .andWhere(
+            new Brackets(qb => {
+              qb.where('Lower(inventories.pallet_id) LIKE :inventoryInfo', {
+                inventoryInfo: '%' + inventoryInfoFilter.value.toLowerCase() + '%'
+              })
+                .orWhere('Lower(inventories.carton_id) LIKE :inventoryInfo', {
+                  inventoryInfo: '%' + inventoryInfoFilter.value.toLowerCase() + '%'
+                })
+                .orWhere('Lower(ivi.serial_number) LIKE :inventoryInfo', {
+                  inventoryInfo: '%' + inventoryInfoFilter.value.toLowerCase() + '%'
+                })
+            })
+          )
+          .getQuery()
+        return `EXISTS ${subQuery}`
+      })
+    }
+
+    if (sortings?.length !== 0) {
+      const arrChildSortData = ['serial_number']
+      const sort = (sortings || []).reduce(
+        (acc, sort) => ({
+          ...acc,
+          [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'ivi.' + sort.name]: sort.desc
+            ? 'DESC'
+            : 'ASC'
+        }),
+        {}
+      )
+      qb.orderBy(sort)
+    }
+
+    qb.limit(limit)
+    qb.offset(limit * (page - 1))
+
+    let [items, total] = await qb.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() inventoryItem: InventoryItem): Promise<Domain> {
+    return await getRepository(Domain).findOne(inventoryItem.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() inventoryItem: InventoryItem): Promise<User> {
+    return await getRepository(User).findOne(inventoryItem.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() inventoryItem: InventoryItem): Promise<User> {
+    return await getRepository(User).findOne(inventoryItem.creatorId)
+  }
+}

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

@@ -0,0 +1,74 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { InventoryItem } from './inventory-item'
+
+@InputType()
+export class NewInventoryItem {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  serialNumber?: string
+
+  @Field({ nullable: true })
+  status?: string
+
+  @Field({ nullable: true })
+  source?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  product?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  inventory?: ObjectRef
+
+  @Field({ nullable: true })
+  inboundOrderId?: string
+
+  @Field({ nullable: true })
+  outboundOrderId?: string
+}
+
+@InputType()
+export class InventoryItemPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  serialNumber?: string
+
+  @Field({ nullable: true })
+  status?: string
+
+  @Field({ nullable: true })
+  source?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  product?: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  inventory?: ObjectRef
+
+  @Field({ nullable: true })
+  inboundOrderId?: string
+
+  @Field({ nullable: true })
+  outboundOrderId?: string
+
+  @Field({ nullable: true })
+  cuFlag: string
+}
+
+@ObjectType()
+export class InventoryItemList {
+  @Field(type => [InventoryItem])
+  items: InventoryItem[]
+
+  @Field(type => Int)
+  total: number
+}

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

@@ -0,0 +1,99 @@
+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 { Product } from '@things-factory/product-base'
+import { Domain } from '@things-factory/shell'
+
+import { Inventory } from '../inventory/inventory'
+
+@Entity()
+@Index('ix_inventory_item_0', (inventoryItem: InventoryItem) => [inventoryItem.domain, inventoryItem.name], {
+  unique: true
+})
+@ObjectType({ description: 'Entity for InventoryItem' })
+export class InventoryItem {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((inventoryItem: InventoryItem) => inventoryItem.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  serialNumber?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  status?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  source?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  inboundOrderId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  outboundOrderId: string
+
+  @ManyToOne(type => Product)
+  @Field(type => Product, { nullable: true })
+  product?: Product
+
+  @RelationId((inventoryItem: InventoryItem) => inventoryItem.product)
+  productId?: string
+
+  @ManyToOne(type => Inventory)
+  @Field(type => Inventory)
+  inventory?: Inventory
+
+  @RelationId((inventoryItem: InventoryItem) => inventoryItem.inventory)
+  inventoryId?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((inventoryItem: InventoryItem) => inventoryItem.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((inventoryItem: InventoryItem) => inventoryItem.creator)
+  updaterId?: string
+}

package/server/service/inventory-product/index.ts

@@ -0,0 +1,6 @@
+import { InventoryProduct } from './inventory-product'
+import { InventoryProductQuery } from './inventory-product-query'
+import { InventoryProductMutation } from './inventory-product-mutation'
+
+export const entities = [InventoryProduct]
+export const resolvers = [InventoryProductQuery, InventoryProductMutation]

package/server/service/inventory-product/inventory-product-mutation.ts

@@ -0,0 +1,112 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { getRepository, In } from 'typeorm'
+import { InventoryProduct } from './inventory-product'
+import { NewInventoryProduct, InventoryProductPatch } from './inventory-product-type'
+
+@Resolver(InventoryProduct)
+export class InventoryProductMutation {
+  @Directive('@transaction')
+  @Mutation(returns => InventoryProduct, { description: 'To create new InventoryProduct' })
+  async createInventoryProduct(@Arg('inventoryProduct') inventoryProduct: NewInventoryProduct, @Ctx() context: any): Promise<InventoryProduct> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(InventoryProduct).save({
+      ...inventoryProduct,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => InventoryProduct, { description: 'To modify InventoryProduct information' })
+  async updateInventoryProduct(
+    @Arg('id') id: string,
+    @Arg('patch') patch: InventoryProductPatch,
+    @Ctx() context: any
+  ): Promise<InventoryProduct> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(InventoryProduct)
+    const inventoryProduct = await repository.findOne({
+      where: { domain, id }
+    })
+
+    return await repository.save({
+      ...inventoryProduct,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [InventoryProduct], { description: "To modify multiple InventoryProducts' information" })
+  async updateMultipleInventoryProduct(
+    @Arg('patches', type => [InventoryProductPatch]) patches: InventoryProductPatch[],
+    @Ctx() context: any
+  ): Promise<InventoryProduct[]> {
+    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 inventoryProductRepo = tx.getRepository(InventoryProduct)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await inventoryProductRepo.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 inventoryProduct = await inventoryProductRepo.findOne(newRecord.id)
+
+        const result = await inventoryProductRepo.save({
+          ...inventoryProduct,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete InventoryProduct' })
+  async deleteInventoryProduct(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(InventoryProduct).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple inventoryProducts' })
+  async deleteInventoryProducts(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: any
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(InventoryProduct).delete({
+      domain,
+      id: In(ids)
+    })
+
+    return true
+  }
+}