@things-factory/warehouse-base 8.0.3 → 8.0.6

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

@@ -1,119 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { InventoryNoGenerator } from '../../utils'
-import { InventoryItemChange } from './inventory-item-change'
-import { InventoryItemChangePatch, NewInventoryItemChange } from './inventory-item-change-type'
-
-@Resolver(InventoryItemChange)
-export class InventoryItemChangeMutation {
-  @Directive('@transaction')
-  @Mutation(returns => InventoryItemChange, { description: 'To create new InventoryItemChange' })
-  async createInventoryItemChange(
-    @Arg('inventoryItemChange') inventoryItemChange: NewInventoryItemChange,
-    @Ctx() context: ResolverContext
-  ): Promise<InventoryItemChange> {
-    const { domain, user, tx } = context.state
-
-    return await tx.getRepository(InventoryItemChange).save({
-      ...inventoryItemChange,
-      name: InventoryNoGenerator.inventoryName(),
-      status: 'PENDING_SUBMISSION',
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => InventoryItemChange, { description: 'To modify InventoryItemChange information' })
-  async updateInventoryItemChange(
-    @Arg('id') id: string,
-    @Arg('patch') patch: InventoryItemChangePatch,
-    @Ctx() context: ResolverContext
-  ): Promise<InventoryItemChange> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(InventoryItemChange)
-    const inventoryItemChange = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    return await repository.save({
-      ...inventoryItemChange,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [InventoryItemChange], { description: "To modify multiple InventoryItemChanges' information" })
-  async updateMultipleInventoryItemChange(
-    @Arg('patches', type => [InventoryItemChangePatch]) patches: InventoryItemChangePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<InventoryItemChange[]> {
-    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 inventoryItemChangeRepo = tx.getRepository(InventoryItemChange)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await inventoryItemChangeRepo.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 inventoryItemChange = await inventoryItemChangeRepo.findOneBy({ id: newRecord.id })
-
-        const result = await inventoryItemChangeRepo.save({
-          ...inventoryItemChange,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete InventoryItemChange' })
-  async deleteInventoryItemChange(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(InventoryItemChange).delete({ domain: { id: domain.id }, id })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple inventoryItemChanges' })
-  async deleteInventoryItemChanges(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(InventoryItemChange).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    return true
-  }
-}

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

@@ -1,47 +0,0 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-
-import { User } from '@things-factory/auth-base'
-import { convertListParams, Domain, getRepository, ListParam } from '@things-factory/shell'
-
-import { InventoryItemChange } from './inventory-item-change'
-import { InventoryItemChangeList } from './inventory-item-change-type'
-
-@Resolver(InventoryItemChange)
-export class InventoryItemChangeQuery {
-  @Query(returns => InventoryItemChange, { description: 'To fetch a InventoryItemChange' })
-  async inventoryItemChange(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<InventoryItemChange> {
-    const { domain } = context.state
-
-    return await getRepository(InventoryItemChange).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => InventoryItemChangeList, { description: 'To fetch multiple InventoryItemChanges' })
-  async inventoryItemChanges(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<InventoryItemChangeList> {
-    const { domain } = context.state
-
-    const convertedParams = convertListParams(params, { domain })
-    const [items, total] = await getRepository(InventoryItemChange).findAndCount(convertedParams)
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() inventoryItemChange: InventoryItemChange): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: inventoryItemChange.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() inventoryItemChange: InventoryItemChange): Promise<User> {
-    return await getRepository(User).findOneBy({ id: inventoryItemChange.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() inventoryItemChange: InventoryItemChange): Promise<User> {
-    return await getRepository(User).findOneBy({ id: inventoryItemChange.creatorId })
-  }
-}

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

@@ -1,68 +0,0 @@
-import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
-
-import { ObjectRef } from '@things-factory/shell'
-
-import { InventoryItemChange } from './inventory-item-change'
-
-@InputType()
-export class NewInventoryItemChange {
-  @Field({ nullable: true })
-  name: string
-
-  @Field({ nullable: true })
-  serialNumber?: string
-
-  @Field({ nullable: true })
-  type?: string
-
-  @Field({ nullable: true })
-  status?: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  inventory?: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  inventoryItem?: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  inventoryChange?: ObjectRef
-}
-
-@InputType()
-export class InventoryItemChangePatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  serialNumber?: string
-
-  @Field({ nullable: true })
-  type?: string
-
-  @Field({ nullable: true })
-  status?: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  inventory?: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  inventoryItem?: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  inventoryChange?: ObjectRef
-
-  @Field({ nullable: true })
-  cuFlag: string
-}
-
-@ObjectType()
-export class InventoryItemChangeList {
-  @Field(type => [InventoryItemChange])
-  items: InventoryItemChange[]
-
-  @Field(type => Int)
-  total: number
-}

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

@@ -1,92 +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 { Domain } from '@things-factory/shell'
-
-import { InventoryChange } from '../inventory-change/inventory-change'
-import { InventoryItem } from '../inventory-item/inventory-item'
-import { Inventory } from '../inventory/inventory'
-
-@Entity()
-@Index(
-  'ix_inventory_item_change_0',
-  (inventoryItemChange: InventoryItemChange) => [inventoryItemChange.domain, inventoryItemChange.name],
-  { unique: true }
-)
-@ObjectType({ description: 'Entity for InventoryItemChange' })
-export class InventoryItemChange {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain?: Domain
-
-  @RelationId((inventoryItemChange: InventoryItemChange) => inventoryItemChange.domain)
-  domainId?: string
-
-  @ManyToOne(type => InventoryItem, { nullable: true })
-  @Field(type => InventoryItem, { nullable: true })
-  inventoryItem: InventoryItem
-
-  @ManyToOne(type => Inventory, { nullable: true })
-  @Field(type => Inventory, { nullable: true })
-  inventory: Inventory
-
-  @ManyToOne(type => InventoryChange, { nullable: true })
-  @Field(type => InventoryChange, { nullable: true })
-  inventoryChange: InventoryChange
-
-  @Column()
-  @Field()
-  name: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  serialNumber?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  type?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  status?: 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((inventoryItemChange: InventoryItemChange) => inventoryItemChange.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((inventoryItemChange: InventoryItemChange) => inventoryItemChange.updater)
-  updaterId?: string
-}

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

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

@@ -1,116 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { InventoryProduct } from './inventory-product'
-import { InventoryProductPatch, NewInventoryProduct } 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: ResolverContext
-  ): 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: ResolverContext
-  ): Promise<InventoryProduct> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(InventoryProduct)
-    const inventoryProduct = await repository.findOne({
-      where: { domain: { id: domain.id }, 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: ResolverContext
-  ): 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.findOneBy({ id: 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: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(InventoryProduct).delete({ domain: { id: domain.id }, id })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple inventoryProducts' })
-  async deleteInventoryProducts(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(InventoryProduct).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    return true
-  }
-}

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

@@ -1,47 +0,0 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-
-import { User } from '@things-factory/auth-base'
-import { convertListParams, Domain, getRepository, ListParam } from '@things-factory/shell'
-
-import { InventoryProduct } from './inventory-product'
-import { InventoryProductList } from './inventory-product-type'
-
-@Resolver(InventoryProduct)
-export class InventoryProductQuery {
-  @Query(returns => InventoryProduct, { description: 'To fetch a InventoryProduct' })
-  async inventoryProduct(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<InventoryProduct> {
-    const { domain } = context.state
-
-    return await getRepository(InventoryProduct).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => InventoryProductList, { description: 'To fetch multiple InventoryProducts' })
-  async inventoryProducts(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<InventoryProductList> {
-    const { domain } = context.state
-
-    const convertedParams = convertListParams(params, { domain })
-    const [items, total] = await getRepository(InventoryProduct).findAndCount(convertedParams)
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() inventoryProduct: InventoryProduct): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: inventoryProduct.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() inventoryProduct: InventoryProduct): Promise<User> {
-    return await getRepository(User).findOneBy({ id: inventoryProduct.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() inventoryProduct: InventoryProduct): Promise<User> {
-    return await getRepository(User).findOneBy({ id: inventoryProduct.creatorId })
-  }
-}

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

@@ -1,59 +0,0 @@
-import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
-
-import { ObjectRef } from '@things-factory/shell'
-
-import { InventoryProduct } from './inventory-product'
-
-@InputType()
-export class NewInventoryProduct {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  serialNumber?: string
-
-  @Field({ nullable: true })
-  status?: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  product?: ObjectRef
-
-  @Field({ nullable: true })
-  arrivalNoticeId?: string
-
-  @Field({ nullable: true })
-  releaseGoodId?: string
-}
-
-@InputType()
-export class InventoryProductPatch {
-  @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 })
-  arrivalNoticeId?: string
-
-  @Field({ nullable: true })
-  releaseGoodId?: string
-
-  @Field()
-  cuFlag: string
-}
-
-@ObjectType()
-export class InventoryProductList {
-  @Field(type => [InventoryProduct])
-  items: InventoryProduct[]
-
-  @Field(type => Int)
-  total: number
-}

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

@@ -1,88 +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'
-
-@Entity()
-@Index(
-  'ix_inventory_product_0',
-  (inventoryProduct: InventoryProduct) => [inventoryProduct.domain, inventoryProduct.name],
-  { unique: true }
-)
-@ObjectType({ description: 'Entity for InventoryProduct' })
-export class InventoryProduct {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain?: Domain
-
-  @RelationId((inventoryProduct: InventoryProduct) => inventoryProduct.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 })
-  arrivalNoticeId: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  releaseGoodId: string
-
-  @ManyToOne(type => Product)
-  @Field({ nullable: true })
-  product?: Product
-
-  @RelationId((inventoryProduct: InventoryProduct) => inventoryProduct.product)
-  productId?: 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((inventoryProduct: InventoryProduct) => inventoryProduct.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((inventoryProduct: InventoryProduct) => inventoryProduct.updater)
-  updaterId?: string
-}

package/server/service/location/index.ts

@@ -1,6 +0,0 @@
-import { Location } from './location'
-import { LocationMutation } from './location-mutation'
-import { LocationQuery } from './location-query'
-
-export const entities = [Location]
-export const resolvers = [LocationQuery, LocationMutation]