@things-factory/warehouse-base 8.0.0-beta.9 → 8.0.0

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

@@ -0,0 +1,93 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { Brackets, SelectQueryBuilder } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { buildQuery, Domain, getRepository, ListParam, getQueryBuilderFromListParams } from '@things-factory/shell'
+
+import { InventoryChange } from './inventory-change'
+import { InventoryChangeList } from './inventory-change-types'
+
+@Resolver(InventoryChange)
+export class InventoryChangeQuery {
+  @Query(returns => InventoryChange)
+  async inventoryChange(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<InventoryChange> {
+    const { domain } = context.state
+
+    return await getRepository(InventoryChange).findOne({
+      where: { domain: { id: domain.id }, name },
+      relations: ['domain', 'creator', 'updater']
+    })
+  }
+
+  @Query(returns => InventoryChangeList)
+  async inventoryChanges(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<InventoryChangeList> {
+    const { domain, user, tx } = context.state
+
+    let bizplaces: any[]
+    if (!params.filters.find(filter => filter.name === 'bizplace')) {
+      bizplaces = await getPermittedBizplaceIds(domain, user)
+    } else {
+      bizplaces = [params.filters.find(filter => filter.name === 'bizplace').value]
+      params.filters = [...params.filters.filter(filter => filter.name != 'bizplace')]
+    }
+
+    const qb: SelectQueryBuilder<InventoryChange> = getQueryBuilderFromListParams({
+      repository: getRepository(InventoryChange),
+      params,
+      domain,
+      alias: 'ic',
+      searchables: ['palletId']
+    })
+
+    qb.innerJoinAndSelect('ic.domain', 'dm')
+      .leftJoinAndSelect('ic.bizplace', 'biz')
+      .leftJoinAndSelect('ic.inventory', 'iv')
+      .leftJoinAndSelect('iv.bizplace', 'ivBiz')
+      .leftJoinAndSelect('iv.product', 'ivPrd')
+      .leftJoinAndSelect('iv.location', 'ivLoc')
+      .leftJoinAndSelect('ic.product', 'product')
+      .leftJoinAndSelect('ic.location', 'location')
+      .leftJoinAndSelect('ic.lastInventoryHistory', 'livh')
+      .leftJoinAndSelect('ic.inventoryItemChange', 'itc')
+      .leftJoinAndSelect('livh.product', 'livhProduct')
+      .leftJoinAndSelect('livh.warehouse', 'livhWarehouse')
+      .leftJoinAndSelect('livh.location', 'livhLocation')
+      .leftJoinAndSelect('livh.bizplace', 'livhBiz')
+      .innerJoinAndSelect('ic.creator', 'creator')
+      .innerJoinAndSelect('ic.updater', 'updater')
+
+    qb.andWhere(
+      new Brackets(qb => {
+        qb.where('"iv"."bizplace_id" IN (:...bizplaces)')
+        qb.orWhere('"ic"."bizplace_id" IN (:...bizplaces)')
+      })
+    )
+
+    qb.setParameters({
+      bizplaces: bizplaces
+    })
+
+    let [items, total] = await qb.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => InventoryChange)
+  async domain(@Root() inventoryChange: InventoryChange) {
+    return await getRepository(Domain).findOneBy({ id: inventoryChange.domainId })
+  }
+
+  @FieldResolver(type => InventoryChange)
+  async updater(@Root() inventoryChange: InventoryChange) {
+    return await getRepository(User).findOneBy({ id: inventoryChange.updaterId })
+  }
+
+  @FieldResolver(type => InventoryChange)
+  async creator(@Root() inventoryChange: InventoryChange) {
+    return await getRepository(User).findOneBy({ id: inventoryChange.creatorId })
+  }
+}

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

@@ -0,0 +1,36 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { InventoryChange } from './inventory-change'
+
+@ObjectType()
+export class InventoryChangeList {
+  @Field(type => [InventoryChange], { nullable: true })
+  items?: InventoryChange[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+}
+
+@InputType()
+export class InventoryChangePatch {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@InputType()
+export class NewInventoryChange {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+}

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

@@ -0,0 +1,164 @@
+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 { Bizplace } from '@things-factory/biz-base'
+import { Product, ProductDetail } from '@things-factory/product-base'
+import { Domain, ScalarDate, roundTransformer } from '@things-factory/shell'
+
+import { InventoryHistory } from '../inventory-history/inventory-history'
+import { InventoryItemChange } from '../inventory-item-change/inventory-item-change'
+import { Inventory } from '../inventory/inventory'
+import { Location } from '../location/location'
+
+@Entity()
+@Index('ix_inventory-change_0', (inventoryChange: InventoryChange) => [inventoryChange.domain, inventoryChange.id], {
+  unique: true
+})
+@Index('ix_inventory-change_1', (inventoryChange: InventoryChange) => [
+  inventoryChange.domain,
+  inventoryChange.inventory
+])
+@ObjectType()
+export class InventoryChange {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  palletId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  cartonId: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain: Domain
+
+  @RelationId((inventoryChange: InventoryChange) => inventoryChange.domain)
+  domainId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  batchId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  batchIdRef: string
+
+  @ManyToOne(type => Bizplace, { nullable: true })
+  @Field({ nullable: true })
+  bizplace: Bizplace
+
+  @ManyToOne(type => Inventory, { nullable: true })
+  @Field(type => Inventory, { nullable: true })
+  inventory: Inventory
+
+  @ManyToOne(type => Product, { nullable: true })
+  @Field(type => Product, { nullable: true })
+  product: Product
+
+  @ManyToOne(type => InventoryItemChange, { nullable: true })
+  @Field(type => InventoryItemChange, { nullable: true })
+  inventoryItemChange: InventoryItemChange
+
+  /**
+   * To be updated to remove nullable. once all process that links to inventory has been updated to use product detail instead of product
+   */
+  @ManyToOne(type => ProductDetail, { nullable: true })
+  @Field(type => ProductDetail, { nullable: true })
+  productDetail: ProductDetail
+
+  @ManyToOne(type => Location, { nullable: true })
+  @Field(type => Location, { nullable: true })
+  location: Location
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  packingType: string
+
+  @Column('float', { nullable: true, transformer: roundTransformer })
+  @Field({ nullable: true })
+  packingSize: number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  uom: string
+
+  @Column('float', { nullable: true, transformer: roundTransformer })
+  @Field({ nullable: true })
+  weight: number
+
+  @Column('float', { nullable: true, transformer: roundTransformer })
+  @Field({ nullable: true })
+  uomValue: number
+
+  @Column('float', { nullable: true, transformer: roundTransformer })
+  @Field({ nullable: true })
+  qty: number
+
+  @Column('float', { nullable: true, transformer: roundTransformer })
+  @Field({ nullable: true })
+  unitCost: number
+
+  @Column()
+  @Field()
+  status: string
+
+  @ManyToOne(type => InventoryHistory, { nullable: true })
+  @Field({ nullable: true })
+  lastInventoryHistory: InventoryHistory
+
+  @Column('date', { nullable: true })
+  @Field(type => ScalarDate, { nullable: true })
+  expirationDate: Date
+
+  @Column('int', { nullable: true })
+  @Field({ nullable: true })
+  manufactureYear: number
+
+  @Column('date', { nullable: true })
+  @Field(type => ScalarDate, { nullable: true })
+  manufactureDate: Date
+
+  @Column()
+  @Field()
+  transactionType: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  creator: User
+
+  @RelationId((inventoryChange: InventoryChange) => inventoryChange.creator)
+  creatorId: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field({ nullable: true })
+  updater: User
+
+  @RelationId((inventoryChange: InventoryChange) => inventoryChange.updater)
+  updaterId: string
+}

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

@@ -0,0 +1,6 @@
+import { InventoryHistory } from './inventory-history'
+import { InventoryHistoryMutation } from './inventory-history-mutation'
+import { InventoryHistoryQuery } from './inventory-history-query'
+
+export const entities = [InventoryHistory]
+export const resolvers = [InventoryHistoryQuery, InventoryHistoryMutation]

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

@@ -0,0 +1,116 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { InventoryHistory } from './inventory-history'
+import { InventoryHistoryPatch, NewInventoryHistory } from './inventory-history-types'
+
+@Resolver(InventoryHistory)
+export class InventoryHistoryMutation {
+  @Directive('@transaction')
+  @Mutation(returns => InventoryHistory)
+  async createInventoryHistory(
+    @Arg('inventoryHistory') inventoryHistory: NewInventoryHistory,
+    @Ctx() context: ResolverContext
+  ): Promise<InventoryHistory> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(InventoryHistory).save({
+      ...inventoryHistory,
+      domain: domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => InventoryHistory)
+  async updateInventoryHistory(
+    @Arg('name') name: string,
+    @Arg('patch') patch: InventoryHistoryPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<InventoryHistory> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(InventoryHistory)
+    const inventoryHistory = await repository.findOne({
+      where: { domain: { id: domain.id }, name }
+    })
+
+    return await repository.save({
+      ...inventoryHistory,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [InventoryHistory])
+  async updateMultipleInventoryHistory(
+    @Arg('patches', type => [InventoryHistoryPatch]) patches: InventoryHistoryPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<InventoryHistory[]> {
+    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 inventoryHistoryRepo = tx.getRepository(InventoryHistory)
+
+    if (_createRecords.length > 0) {
+      let newRecord: NewInventoryHistory = new InventoryHistory()
+      for (let i = 0; i < _createRecords.length; i++) {
+        newRecord = _createRecords[i]
+      }
+
+      const result = await inventoryHistoryRepo.save({
+        ...newRecord,
+        domain: 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 inventoryHistory = await inventoryHistoryRepo.findOneBy({ id: newRecord.id })
+
+        const result = await inventoryHistoryRepo.save({
+          ...inventoryHistory,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteInventoryHistory(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(InventoryHistory).delete({ domain: { id: domain.id }, name })
+    return true
+  }
+
+  @Directive('transaction')
+  @Mutation(returns => Boolean)
+  async deleteInventoryHistories(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<Boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(InventoryHistory).delete({
+      domain: { id: domain.id },
+      name: In(names)
+    })
+    return true
+  }
+}