@things-factory/warehouse-base 4.1.31 → 4.1.35

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

@@ -752,6 +752,120 @@ export class InventoryQuery {
     }
   }
 
+  @Directive('@privilege(category: "inventory", privilege: "query")')
+  @Query(returns => InventoryList)
+  async nonLoadedInventories(
+    @Ctx() context: any,
+    @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
+    @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
+    @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
+  ): Promise<InventoryList> {
+    const { domain, user }: { domain: Domain; user: User } = context.state
+    const { page, limit }: { page: number; limit: number } = pagination
+
+    try {
+      const productFilter = filters.find(x => x.name == 'product_info')
+      const roNoFilter = filters.find(x => x.name == 'ro_no')
+      const binLocationFilter = filters.find(x => x.name == 'bin_location')
+
+      filters = filters.filter(filter => ['product_info', 'ro_no', 'bin_location'].indexOf(filter.name) == -1)
+
+      const params = { filters, pagination }
+      const qb: SelectQueryBuilder<Inventory> = getRepository(Inventory).createQueryBuilder('Inventory')
+      buildQuery(qb, params, context)
+
+      qb.select('Inventory')
+        .addSelect('ReleaseGood.name', 'order_no')
+        .innerJoin('order_inventories', 'OrderInventory', 'Inventory.id = OrderInventory.inventory_id')
+        .innerJoin('OrderInventory.releaseGood', 'ReleaseGood')
+        .innerJoinAndSelect('Inventory.product', 'Product')
+        .leftJoinAndSelect('OrderInventory.binLocation', 'BinLocation')
+        .leftJoinAndSelect('Inventory.creator', 'Creator')
+        .leftJoinAndSelect('Inventory.updater', 'Updater')
+        .andWhere('ReleaseGood.status IN (:...releaseGoodStatus)', {
+          releaseGoodStatus: ['PICKING', 'LOADING']
+        })
+        .andWhere('OrderInventory.status IN (:...orderInventoryStatus)', {
+          orderInventoryStatus: ['PICKED', 'LOADING', 'LOADED']
+        })
+
+      if (productFilter) {
+        let productFilterValue = `%${productFilter.value.toLowerCase()}%`
+        qb.andWhere(qb => {
+          const subQuery = qb
+            .subQuery()
+            .select()
+            .from(Product, `products`)
+            .where(`products.id = Inventory.product_id`)
+            .andWhere(
+              new Brackets(qb => {
+                qb.where('Lower(products.sku) LIKE :productInfo', { productInfo: productFilterValue })
+                  .orWhere('Lower(products.name) LIKE :productInfo', { productInfo: productFilterValue })
+                  .orWhere('Lower(products.description) LIKE :productInfo', { productInfo: productFilterValue })
+                  .orWhere('Lower(products.brand) LIKE :productInfo', { productInfo: productFilterValue })
+              })
+            )
+            .getQuery()
+          return `EXISTS ${subQuery}`
+        })
+      }
+
+      if (roNoFilter) {
+        const roNo: string = `%${roNoFilter.value.toLowerCase()}%`
+        qb.andWhere('ReleaseGood.name LIKE :roNo', { roNo })
+      }
+
+      if (binLocationFilter) {
+        const binLocation: string = `%${binLocationFilter.value.toLowerCase()}%`
+        qb.andWhere('BinLocation.name LIKE :binLocation', { binLocation })
+      }
+
+      if (sortings?.length !== 0) {
+        const sorter = (sortings || []).reduce((acc, sort) => {
+          const order: string = sort.desc ? 'DESC' : 'ASC'
+
+          switch (sort.name) {
+            case 'orderNo':
+              acc = { ...acc, ['ReleaseGood.name']: order }
+              break
+
+            case 'product_sku':
+              acc = { ...acc, ['Product.sku']: order }
+              break
+
+            case 'product_name':
+              acc = { ...acc, ['Product.name']: order }
+              break
+
+            case 'product_brand':
+              acc = { ...acc, ['Product.brand']: order }
+
+            case 'binLocation':
+              acc = { ...acc, ['BinLocation.name']: order }
+              break
+
+            default:
+              acc = { ...acc, [`Inventory.${sort.name}`]: order }
+              break
+          }
+
+          return acc
+        }, {})
+        qb.orderBy(sorter)
+      }
+
+      let items = await qb
+        .offset((page - 1) * limit)
+        .limit(limit)
+        .getRawMany()
+
+      let total = await qb.getCount()
+      return { items: items.map(item => new Inventory(item)), total }
+    } catch (error) {
+      throw error
+    }
+  }
+
   @FieldResolver(type => Domain)
   async domain(@Root() inventory: Inventory): Promise<Domain> {
     return await getRepository(Domain).findOne(inventory.domainId)

package/server/service/inventory/inventory.ts

@@ -255,6 +255,12 @@ export class Inventory {
   @Field({ nullable: true })
   changeCount?: number
 
+  @Field({ nullable: true })
+  binLocation?: string
+
+  @Field({ nullable: true })
+  orderNo?: string
+
   constructor(obj?) {
     if (obj) {
       this.id = obj.Inventory_id
@@ -297,6 +303,8 @@ export class Inventory {
       this.packingSize = obj.Inventory_packing_size
       this.creatorId = obj.Inventory_creator_id
       this.updaterId = obj.Inventory_updater_id
+      this.binLocation = obj.BinLocation_name
+      this.orderNo = obj.order_no
     }
   }
 }

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]