@things-factory/warehouse-base 8.0.2 → 8.0.5

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

@@ -1,217 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { Product } from '@things-factory/product-base'
-
-import { INVENTORY_ITEM_SOURCE, 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: ResolverContext
-  ): 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: ResolverContext
-  ): Promise<InventoryItem> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(InventoryItem)
-    const inventoryItem = await repository.findOne({
-      where: { domain: { id: domain.id }, 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: ResolverContext
-  ): Promise<boolean> {
-    try {
-      const { domain, user, tx } = context.state
-
-      const repository = tx.getRepository(InventoryItem)
-
-      const inventoryItem = await repository.findOne({
-        where: { domain: { id: domain.id }, id },
-        relations: ['product']
-      })
-
-      const product: Product = inventoryItem.product
-      const duplicatedSerialNumberCnt: number = await repository.countBy({
-        domain: { id: domain.id },
-        product: { id: product.id },
-        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: ResolverContext
-  ): 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.findOneBy({ id: 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: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(InventoryItem).delete({ domain: { id: domain.id }, id })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple inventoryItems' })
-  async deleteInventoryItems(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(InventoryItem).delete({
-      domain: { id: domain.id },
-      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: ResolverContext
-  ): Promise<InventoryItem> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(InventoryItem)
-    const foundSerialNumber = await repository.findOne({
-      where: { domain: { id: domain.id }, serialNumber: newSerialNumber }
-    })
-
-    if ((selectedSerialNumber.source = INVENTORY_ITEM_SOURCE.OUTBOUND)) {
-      await tx.getRepository(InventoryItem).delete(selectedSerialNumber.id)
-    } else {
-      await repository.update(
-        {
-          domain: { id: domain.id },
-          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 as any
-      inventoryItem.inventory = selectedSerialNumber.inventory as any
-      inventoryItem.domain = domain
-
-      return await repository.save(inventoryItem)
-    }
-  }
-}

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

@@ -1,226 +0,0 @@
-import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { Brackets, EntityManager, In, Not, OrderByCondition, SelectQueryBuilder } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Product } from '@things-factory/product-base'
-import { convertListParams, Domain, getRepository, 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: ResolverContext): Promise<InventoryItem> {
-    const { domain } = context.state
-
-    return await getRepository(InventoryItem).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => InventoryItemList, { description: 'To fetch multiple InventoryItems' })
-  async inventoryItems(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<InventoryItemList> {
-    const { domain } = context.state
-
-    const convertedParams = convertListParams(params, { domain })
-    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(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<InventoryItemList> {
-    const { domain, tx } = 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(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): 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 })
-    qb.andWhere('inventory.domain_id=:domainId', { domainId: domain.id })
-
-    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: OrderByCondition = (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).findOneBy({ id: inventoryItem.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() inventoryItem: InventoryItem): Promise<User> {
-    return await getRepository(User).findOneBy({ id: inventoryItem.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() inventoryItem: InventoryItem): Promise<User> {
-    return await getRepository(User).findOneBy({ id: inventoryItem.creatorId })
-  }
-}
-
-export async function checkExistingSerialNumber(
-  serialNumber: string,
-  product: Product,
-  context: any,
-  inventory?: Inventory,
-  tx?: EntityManager
-) {
-  const { domain } = context.state
-
-  let countCondition: any = {
-    domain: { id: domain.id },
-    product: { id: product.id },
-    serialNumber,
-    status: Not(In([INVENTORY_STATUS.DELETED, INVENTORY_STATUS.TERMINATED]))
-  }
-
-  if (inventory) {
-    countCondition = { ...countCondition, inventory: { id: inventory.id } }
-  }
-
-  const duplicatedSerialNumberCnt: number = await tx.getRepository(InventoryItem).countBy(countCondition)
-
-  if (duplicatedSerialNumberCnt) {
-    return true
-  }
-}

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

@@ -1,74 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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(type => Domain)
-  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(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((inventoryItem: InventoryItem) => inventoryItem.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((inventoryItem: InventoryItem) => inventoryItem.updater)
-  updaterId?: string
-
-  @Field({ nullable: true })
-  type?: string
-
-  @Field({ nullable: true })
-  transactionType?: string
-}

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

@@ -1,6 +0,0 @@
-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]