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

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

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

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

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

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

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

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

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

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