@things-factory/warehouse-base 8.0.3 → 8.0.6

package/server/service/tote/tote-mutation.ts

@@ -1,201 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { Bizplace } from '@things-factory/biz-base'
-
-import { Tote } from './tote'
-import { NewTote, TotePatch } from './tote-types'
-
-@Resolver(Tote)
-export class ToteMutation {
-  @Directive('@transaction')
-  @Mutation(returns => Tote)
-  async createTote(@Arg('pallet') tote: NewTote, @Ctx() context: ResolverContext): Promise<Tote> {
-    const { domain, user, tx } = context.state
-
-    const existingTote: string[] = (await tx.getRepository(Tote).find({ relations: ['user'] })).map(tote => tote.name)
-    if (existingTote.includes(tote.name)) throw new Error('tote box already exists')
-
-    return await tx.getRepository(Tote).save({
-      ...tote,
-      domain: domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Tote)
-  async updateTote(
-    @Arg('name') name: string,
-    @Arg('patch') patch: TotePatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Tote> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(Tote)
-    const tote = await repository.findOne({
-      where: { domain: { id: domain.id }, name }
-    })
-
-    return await repository.save({
-      ...tote,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [Tote])
-  async updateMultipleTote(
-    @Arg('patches', type => [TotePatch]) patches: TotePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Tote[]> {
-    const { domain, user, tx } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        if (newRecord.bizplace && newRecord.bizplace.id) {
-          newRecord.bizplace = (await tx.getRepository(Bizplace).findOneBy({ id: newRecord.bizplace.id })) as any
-        }
-
-        let foundTote = await tx.getRepository(Tote).findOne({
-          where: { domain: { id: domain.id }, name: newRecord.name, bizplace: { id: newRecord.bizplace.id } }
-        })
-
-        if (foundTote) {
-          throw new Error('Duplicated tote found')
-        }
-
-        const result: Tote = await tx.getRepository(Tote).save({
-          domain: domain,
-          creator: user,
-          updater: user,
-          ...newRecord
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const tote = await tx.getRepository(Tote).findOne({
-          where: { id: newRecord.id },
-          relations: ['bizplace']
-        })
-
-        if (newRecord.bizplace && newRecord.bizplace.id) {
-          newRecord.bizplace = (await tx.getRepository(Bizplace).findOneBy({ id: newRecord.bizplace.id })) as any
-        }
-
-        let foundTote = await tx.getRepository(Tote).findOne({
-          where: { domain: { id: domain.id }, name: newRecord.name, bizplace: { id: newRecord.bizplace.id } }
-        })
-
-        if (foundTote) {
-          throw new Error('Duplicated tote found')
-        }
-
-        const result = await tx.getRepository(Tote).save({
-          ...tote,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deleteTote(@Arg('name') id: string, @Ctx() context: ResolverContext): Promise<Boolean> {
-    const { domain, user, tx } = context.state
-
-    const foundTote = await tx.getRepository(Tote).find({ where: { id } })
-
-    await tx.getRepository(Tote).save({
-      ...foundTote,
-      deletedAt: new Date(),
-      updater: user
-    })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deleteTotes(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<Boolean> {
-    const { domain, user, tx } = context.state
-
-    const totes = await tx.getRepository(Tote).find({
-      where: {
-        domain: { id: domain.id },
-        id: In(ids)
-      },
-      relations: ['bizplace']
-    })
-
-    await Promise.all(
-      totes.map(async (tote: Tote) => {
-        await tx.getRepository(Tote).save({
-          ...tote,
-          deletedAt: new Date(),
-          updater: user
-        })
-      })
-    )
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async undeleteTotes(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<Boolean> {
-    const { tx, user } = context.state
-    const toteRepo = tx.getRepository(Tote)
-
-    await toteRepo.update(
-      {
-        id: In(ids)
-      },
-      {
-        deletedAt: null,
-        updater: user
-      }
-    )
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async bulkUpdateToteStatus(
-    @Arg('ids', type => [String]) ids: string[],
-    @Arg('status', type => String) status: string,
-    @Ctx() context: ResolverContext
-  ): Promise<Boolean> {
-    const { tx, user } = context.state
-    const toteRepo = tx.getRepository(Tote)
-
-    await toteRepo.update(
-      {
-        id: In(ids)
-      },
-      {
-        status,
-        updater: user
-      }
-    )
-
-    return true
-  }
-}

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

@@ -1,106 +0,0 @@
-import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { IsNull } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { buildQuery, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
-
-import { Tote } from './tote'
-import { ToteList } from './tote-types'
-
-@Resolver(Tote)
-export class ToteQuery {
-  @Query(returns => ToteList)
-  async totes(
-    @Ctx() context: ResolverContext,
-    @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<ToteList> {
-    const { domain } = context.state
-
-    const deletedFilter: any = filters.find((filter: any) => filter.name === 'deleted' && filter.value === true)
-
-    const queryBuilder = getRepository(Tote).createQueryBuilder()
-    buildQuery(queryBuilder, { filters, pagination, sortings }, context)
-
-    queryBuilder
-      .leftJoinAndSelect('Tote.domain', 'Domain')
-      .leftJoinAndSelect('Tote.bizplace', 'Bizplace')
-      .leftJoinAndSelect('Tote.creator', 'Creator')
-      .leftJoinAndSelect('Tote.updater', 'Updater')
-      .where('Domain.id = :domainId', { domainId: domain.id })
-
-    if (deletedFilter) {
-      queryBuilder.andWhere('Tote.deletedAt IS NOT NULL')
-    } else {
-      queryBuilder.andWhere('Tote.deletedAt IS NULL')
-    }
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @Query(returns => Tote)
-  async tote(
-    @Arg('name') name: string,
-    @Arg('bizplace') bizplace: string,
-    @Ctx() context: ResolverContext
-  ): Promise<Tote> {
-    const { domain } = context.state
-    let foundBizplace = (await getRepository(Bizplace).findOne({ where: { name: bizplace } })) as Bizplace
-
-    let foundTote = await getRepository(Tote).findOne({
-      where: { domain: { id: domain.id }, bizplace: { id: foundBizplace.id }, name, deletedAt: IsNull() },
-      relations: ['domain', 'bizplace', 'creator', 'updater']
-    })
-
-    if (!foundTote) {
-      throw new Error('Tote not found')
-    } else {
-      return foundTote
-    }
-  }
-
-  @Query(returns => String)
-  async checkToteStatus(
-    @Arg('name') name: string,
-    @Arg('bizplace') bizplace: string,
-    @Ctx() context: ResolverContext
-  ): Promise<String> {
-    const { domain } = context.state
-    let foundBizplace = (await getRepository(Bizplace).findOne({ where: { name: bizplace } })) as Bizplace
-
-    let foundTote = await getRepository(Tote).findOne({
-      where: { domain: { id: domain.id }, bizplace: { id: foundBizplace.id }, name, deletedAt: IsNull() },
-      relations: ['domain', 'bizplace', 'creator', 'updater']
-    })
-
-    if (!foundTote) {
-      return ''
-    } else {
-      return foundTote.status
-    }
-  }
-
-  @FieldResolver()
-  async domain(@Root() tote: Tote) {
-    return await getRepository(Domain).findOneBy({ id: tote.domainId })
-  }
-
-  @FieldResolver()
-  async bizplace(@Root() tote: Tote) {
-    return await getRepository(Bizplace).findOneBy({ id: tote.bizplaceId })
-  }
-
-  @FieldResolver()
-  async updater(@Root() tote: Tote) {
-    return await getRepository(User).findOneBy({ id: tote.updaterId })
-  }
-
-  @FieldResolver()
-  async creator(@Root() tote: Tote) {
-    return await getRepository(User).findOneBy({ id: tote.creatorId })
-  }
-}

package/server/service/tote/tote-types.ts

@@ -1,44 +0,0 @@
-import { Field, InputType, Int, ObjectType } from 'type-graphql'
-
-import { ObjectRef } from '@things-factory/shell'
-
-import { Tote } from './tote'
-
-@InputType()
-export class NewTote {
-  @Field()
-  name: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  bizplace?: ObjectRef
-
-  @Field({ nullable: true })
-  status?: string
-}
-
-@ObjectType()
-export class ToteList {
-  @Field(type => [Tote], { nullable: true })
-  items?: Tote[]
-
-  @Field(type => Int, { nullable: true })
-  total?: number
-}
-
-@InputType()
-export class TotePatch {
-  @Field({ nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  bizplace?: ObjectRef
-
-  @Field({ nullable: true })
-  status?: string
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}

package/server/service/tote/tote.ts

@@ -1,77 +0,0 @@
-import { Field, 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 { Domain } from '@things-factory/shell'
-
-@Entity()
-@Index('ix_tote_0', (tote: Tote) => [tote.bizplace, tote.name], { unique: true })
-@ObjectType()
-export class Tote {
-  @PrimaryGeneratedColumn('uuid')
-  @Field()
-  id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain: Domain
-
-  @RelationId((tote: Tote) => tote.domain)
-  domainId: string
-
-  @Column()
-  @Field()
-  name: string
-
-  @ManyToOne(type => Bizplace)
-  @ManyToOne(type => Bizplace)
-  @Field(type => Bizplace)
-  bizplace: Bizplace
-
-  @RelationId((tote: Tote) => tote.bizplace)
-  bizplaceId: string
-
-  @Column()
-  @Field()
-  status: string
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt: Date
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field({ nullable: true })
-  creator: User
-
-  @RelationId((tote: Tote) => tote.creator)
-  creatorId: string
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field({ nullable: true })
-  updater: User
-
-  @RelationId((tote: Tote) => tote.updater)
-  updaterId: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  deletedAt: Date
-}

package/server/service/warehouse/index.ts

@@ -1,6 +0,0 @@
-import { Warehouse } from './warehouse'
-import { WarehouseMutation } from './warehouse-mutation'
-import { WarehouseQuery } from './warehouse-query'
-
-export const entities = [Warehouse]
-export const resolvers = [WarehouseQuery, WarehouseMutation]

package/server/service/warehouse/warehouse-mutation.ts

@@ -1,152 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { Repository, In, Equal } from 'typeorm'
-
-import { Warehouse } from './warehouse'
-import { NewWarehouse, WarehousePatch } from './warehouse-types'
-import { Product } from '@things-factory/product-base'
-
-@Resolver(Warehouse)
-export class WarehouseMutation {
-  @Directive('@privilege(category: "warehouse", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => Warehouse)
-  async createWarehouse(
-    @Arg('warehouse') warehouse: NewWarehouse,
-    @Ctx() context: ResolverContext
-  ): Promise<Warehouse> {
-    return await createWarehouse(warehouse, context)
-  }
-
-  @Directive('@privilege(category: "warehouse", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => Warehouse)
-  async updateWarehouse(
-    @Arg('id') id: string,
-    @Arg('patch') patch: WarehousePatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Warehouse> {
-    return await updateWarehouse(id, patch, context)
-  }
-
-  @Directive('@privilege(category: "warehouse", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => [Warehouse])
-  async updateMultipleWarehouse(
-    @Arg('patches', type => [WarehousePatch]) patches: WarehousePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Warehouse[]> {
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const patch = _createRecords[i]
-        const result = await createWarehouse(patch as NewWarehouse, context)
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const patch: WarehousePatch = _updateRecords[i]
-        const result = await updateWarehouse(patch.id, patch, context)
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@privilege(category: "warehouse", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deleteWarehouse(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Boolean> {
-    const { domain, user, tx } = context.state
-    const product = await tx.getRepository(Product).findOne({
-      where: {
-        domain: { id: domain.id },
-        warehouseId: Equal(id)
-      }
-    })
-
-    if (product?.id) {
-      await tx.getRepository(Product).save({
-        ...product,
-        warehouseId: null
-      })
-    }
-
-    return await deleteWarehouse(id, context)
-  }
-
-  @Directive('@privilege(category: "warehouse", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deleteWarehouses(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<Boolean> {
-    const { domain, user, tx } = context.state
-    const products = await tx.getRepository(Product).find({
-      where: {
-        domain: { id: domain.id },
-        warehouseId: In(ids)
-      }
-    })
-
-    if (products?.length) {
-      await tx.getRepository(Product).save(
-        products.map(i => {
-          return {
-            ...i,
-            warehouseId: null
-          }
-        })
-      )
-    }
-
-    return await deleteWarehouses(ids, context)
-  }
-}
-
-export async function createWarehouse(warehouse: NewWarehouse, context: ResolverContext): Promise<Warehouse> {
-  const { domain, user, tx } = context.state
-
-  const repository: Repository<Warehouse> = tx.getRepository(Warehouse)
-  return await repository.save({
-    ...warehouse,
-    domain,
-    creator: user,
-    updater: user
-  })
-}
-
-export async function updateWarehouse(id: string, patch: WarehousePatch, context: ResolverContext): Promise<Warehouse> {
-  const { domain, user, tx } = context.state
-
-  const repository: Repository<Warehouse> = tx.getRepository(Warehouse)
-  const warehouse = await repository.findOneBy({ id })
-
-  return await repository.save({
-    ...warehouse,
-    ...patch,
-    updater: user
-  })
-}
-
-export async function deleteWarehouse(id: string, context: ResolverContext) {
-  const { tx } = context.state
-
-  const repository: Repository<Warehouse> = tx.getRepository(Warehouse)
-  await repository.delete(id)
-  return true
-}
-
-export async function deleteWarehouses(ids: string[], context: ResolverContext) {
-  const { tx } = context.state
-
-  const repository: Repository<Warehouse> = tx.getRepository(Warehouse)
-  await repository.delete(ids)
-  return true
-}

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

@@ -1,58 +0,0 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-
-import { User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-
-import { Warehouse } from './warehouse'
-import { WarehouseList } from './warehouse-types'
-
-@Resolver(Warehouse)
-export class WarehouseQuery {
-  @Query(returns => Warehouse)
-  async warehouse(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Warehouse> {
-    const { domain } = context.state
-
-    return await getRepository(Warehouse).findOne({
-      where: {
-        domain: { id: domain.id },
-        id
-        /* name */
-      },
-      relations: ['domain', 'locations', 'creator', 'updater']
-    })
-  }
-
-  @Query(returns => WarehouseList)
-  async warehouses(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<WarehouseList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: getRepository(Warehouse),
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() warehouse: Warehouse) {
-    return await getRepository(Domain).findOneBy({ id: warehouse.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() warehouse: Warehouse) {
-    return await getRepository(User).findOneBy({ id: warehouse.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() warehouse: Warehouse) {
-    return await getRepository(User).findOneBy({ id: warehouse.creatorId })
-  }
-}

package/server/service/warehouse/warehouse-types.ts

@@ -1,50 +0,0 @@
-import { Field, InputType, Int, ObjectType } from 'type-graphql'
-
-import { ObjectRef } from '@things-factory/shell'
-
-import { Warehouse } from './warehouse'
-
-@InputType()
-export class NewWarehouse {
-  @Field({ nullable: true })
-  id?: string
-
-  @Field()
-  name: string
-
-  @Field(type => [ObjectRef], { nullable: true })
-  locations?: ObjectRef[]
-
-  @Field({ nullable: true })
-  description?: string
-}
-
-@ObjectType()
-export class WarehouseList {
-  @Field(type => [Warehouse], { nullable: true })
-  items?: Warehouse[]
-
-  @Field(type => Int, { nullable: true })
-  total?: number
-}
-
-@InputType()
-export class WarehousePatch {
-  @Field({ nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  type?: string
-
-  @Field(type => [ObjectRef], { nullable: true })
-  locations?: ObjectRef[]
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}