@things-factory/warehouse-base 8.0.3 → 8.0.5

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

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

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

@@ -1,164 +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 { 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

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

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