@things-factory/warehouse-base 8.0.3 → 8.0.6

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

@@ -1,242 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { Bizplace } from '@things-factory/biz-base'
-
-import { PalletHistory } from '../pallet-history/pallet-history'
-import { Pallet } from './pallet'
-import { NewPallet, PalletPatch } from './pallet-types'
-
-@Resolver(Pallet)
-export class PalletMutation {
-  @Directive('@transaction')
-  @Mutation(returns => Pallet)
-  async createPallet(@Arg('pallet') pallet: NewPallet, @Ctx() context: ResolverContext): Promise<Pallet> {
-    const { domain, user, tx } = context.state
-
-    return await tx.getRepository(Pallet).save({
-      ...pallet,
-      domain: domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Pallet)
-  async updatePallet(
-    @Arg('name') name: string,
-    @Arg('patch') patch: PalletPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Pallet> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(Pallet)
-    const pallet = await repository.findOne({
-      where: { domain: { id: domain.id }, name }
-    })
-
-    return await repository.save({
-      ...pallet,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [Pallet])
-  async updateMultiplePallet(
-    @Arg('patches', type => [PalletPatch]) patches: PalletPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Pallet[]> {
-    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')
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        if (newRecord.owner && newRecord.owner.id) {
-          newRecord.owner = (await tx.getRepository(Bizplace).findOneBy({ id: newRecord.owner.id })) as any
-        }
-
-        if (newRecord.holder && newRecord.holder.id) {
-          newRecord.holder = (await tx.getRepository(Bizplace).findOneBy({ id: newRecord.holder.id })) as any
-        }
-
-        const result: Pallet = await tx.getRepository(Pallet).save({
-          domain: domain,
-          creator: user,
-          updater: user,
-          ...newRecord
-        })
-
-        await tx.getRepository(PalletHistory).save({
-          ...newRecord,
-          pallet: result,
-          domain: domain,
-          creator: user,
-          updater: user,
-          transactionType: 'NEW'
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const pallet = await tx.getRepository(Pallet).findOne({
-          where: { id: newRecord.id },
-          relations: ['owner', 'holder']
-        })
-        const seq = pallet.seq + 1
-
-        if (newRecord.owner && newRecord.owner.id) {
-          newRecord.owner = (await tx.getRepository(Bizplace).findOneBy({ id: newRecord.owner.id })) as any
-        }
-
-        if (newRecord.holder && newRecord.holder.id) {
-          newRecord.holder = (await tx.getRepository(Bizplace).findOneBy({ id: newRecord.holder.id })) as any
-        }
-
-        const result = await tx.getRepository(Pallet).save({
-          ...pallet,
-          ...newRecord,
-          seq,
-          updater: user,
-          refOrderNo: null
-        })
-
-        let newHistory = {
-          ...pallet,
-          ...newRecord,
-          pallet: result,
-          seq,
-          domain: domain,
-          creator: user,
-          updater: user,
-          transactionType: 'UPDATE'
-        }
-
-        delete newHistory.id
-
-        await tx.getRepository(PalletHistory).save({
-          ...newHistory
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deletePallet(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Pallet).delete({ domain: { id: domain.id }, name })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deletePallets(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<Boolean> {
-    const { domain, user, tx } = context.state
-
-    const pallets = await tx.getRepository(Pallet).find({
-      where: {
-        domain: { id: domain.id },
-        id: In(ids)
-      },
-      relations: ['owner', 'holder']
-    })
-
-    await Promise.all(
-      pallets.map(async (pallet: Pallet) => {
-        let seq = pallet.seq + 1
-        await tx.getRepository(Pallet).save({
-          ...pallet,
-          status: 'TERMINATED',
-          seq,
-          updater: user
-        })
-
-        await tx.getRepository(PalletHistory).save({
-          pallet: pallet,
-          name: pallet.name,
-          owner: pallet.owner,
-          holder: pallet.holder,
-          seq,
-          domain: domain,
-          creator: user,
-          updater: user,
-          status: 'TERMINATED',
-          transactionType: 'UPDATE'
-        })
-      })
-    )
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [Pallet])
-  async palletReturn(
-    @Arg('patches', type => [PalletPatch]) patches: PalletPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Pallet[]> {
-    const { domain, user, tx } = context.state
-
-    let results = []
-    const _updateRecords = patches
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const pallet = await tx.getRepository(Pallet).findOne({
-          where: { id: newRecord.id },
-          relations: ['owner', 'holder']
-        })
-        const seq = pallet.seq + 1
-
-        newRecord.owner = (await tx.getRepository(Bizplace).findOneBy({ id: newRecord.owner.id })) as any
-        newRecord.holder = newRecord.owner
-
-        const result = await tx.getRepository(Pallet).save({
-          ...pallet,
-          ...newRecord,
-          seq,
-          updater: user,
-          refOrderNo: null
-        })
-
-        let newHistory = {
-          ...pallet,
-          ...newRecord,
-          pallet: result,
-          seq,
-          domain: domain,
-          creator: user,
-          updater: user,
-          transactionType: 'RETURN'
-        }
-
-        delete newHistory.id
-
-        await tx.getRepository(PalletHistory).save({
-          ...newHistory
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-}

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

@@ -1,106 +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 { Pallet } from './pallet'
-import { PalletList, PalletValidate } from './pallet-types'
-
-@Resolver(Pallet)
-export class PalletQuery {
-  @Query(returns => PalletList)
-  async pallets(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<PalletList> {
-    const { domain } = context.state
-
-    if (!params.filters.find((filter: any) => filter.name === 'status')) {
-      params.filters.push({
-        name: 'status',
-        operator: 'noteq',
-        value: 'TERMINATED'
-      })
-    }
-
-    const convertedParams = convertListParams(params, { domain, searchables: ['name'] })
-    const [items, total] = await getRepository(Pallet).findAndCount({
-      ...convertedParams,
-      relations: ['owner', 'holder', 'domain', 'creator', 'updater']
-    })
-    return { items, total }
-  }
-
-  @Query(returns => Pallet)
-  async pallet(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Pallet> {
-    const { domain } = context.state
-
-    let records = await getRepository(Pallet).findOne({
-      where: { domain: { id: domain.id }, name },
-      relations: ['owner', 'holder', 'domain', 'creator', 'updater']
-    })
-    return records
-  }
-
-  @Query(returns => PalletValidate)
-  async palletInboundValidate(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<PalletValidate> {
-    try {
-      const { domain } = context.state
-
-      let item = await getRepository(Pallet).findOne({
-        where: { domain: { id: domain.id }, name },
-        relations: ['owner', 'holder', 'domain', 'creator', 'updater']
-      })
-      if (!item || item?.status != 'ACTIVE') return { error: 'Not found' }
-      if (item?.owner?.id === item?.holder?.id) return { error: 'Pallet already in warehouse!' }
-      return { item }
-    } catch (error) {
-      throw error
-    }
-  }
-
-  @Query(returns => PalletValidate)
-  async palletOutboundValidate(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<PalletValidate> {
-    try {
-      const { domain } = context.state
-
-      let item = await getRepository(Pallet).findOne({
-        where: { domain: { id: domain.id }, name },
-        relations: ['owner', 'holder', 'domain', 'creator', 'updater']
-      })
-      if (!item || item?.status != 'ACTIVE') return { error: 'Not found' }
-      if (item?.owner?.id != item?.holder?.id) return { error: 'Pallet not in warehouse!' }
-      return { item }
-    } catch (error) {
-      throw error
-    }
-  }
-
-  @Query(returns => Pallet, { nullable: true })
-  async palletByStatus(
-    @Arg('name') name: string,
-    @Arg('status') status: string,
-    @Ctx() context: ResolverContext
-  ): Promise<Pallet | boolean> {
-    const { domain } = context.state
-
-    let records = await getRepository(Pallet).findOne({
-      where: { domain: { id: domain.id }, name, status },
-      relations: ['owner', 'holder', 'domain', 'creator', 'updater']
-    })
-
-    return records
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() pallet: Pallet) {
-    return await getRepository(Domain).findOneBy({ id: pallet.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() pallet: Pallet) {
-    return await getRepository(User).findOneBy({ id: pallet.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() pallet: Pallet) {
-    return await getRepository(User).findOneBy({ id: pallet.creatorId })
-  }
-}

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

@@ -1,80 +0,0 @@
-import { Field, InputType, Int, ObjectType } from 'type-graphql'
-
-import { ObjectRef } from '@things-factory/shell'
-
-import { Pallet } from './pallet'
-
-@InputType()
-export class NewPallet {
-  @Field()
-  name: string
-
-  @Field(type => Int, { nullable: true })
-  seq?: number
-
-  @Field(type => ObjectRef, { nullable: true })
-  owner?: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  holder?: ObjectRef
-
-  @Field({ nullable: true })
-  status?: string
-
-  @Field({ nullable: true })
-  type?: string
-
-  @Field({ nullable: true })
-  printedAt?: Date
-}
-
-@ObjectType()
-export class PalletList {
-  @Field(type => [Pallet], { nullable: true })
-  items?: Pallet[]
-
-  @Field(type => Int, { nullable: true })
-  total?: number
-}
-
-@InputType()
-export class PalletPatch {
-  @Field({ nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field(type => Int, { nullable: true })
-  seq?: number
-
-  @Field(type => ObjectRef, { nullable: true })
-  owner?: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  holder?: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  inventory?: ObjectRef
-
-  @Field({ nullable: true })
-  status?: string
-
-  @Field({ nullable: true })
-  type?: string
-
-  @Field({ nullable: true })
-  printedAt?: Date
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class PalletValidate {
-  @Field(type => Pallet, { nullable: true })
-  item?: Pallet
-
-  @Field({ nullable: true })
-  error?: string
-}

package/server/service/pallet/pallet.ts

@@ -1,92 +0,0 @@
-import { Field, Int, ObjectType } from 'type-graphql'
-import { Column, CreateDateColumn, Entity, Index, JoinColumn, ManyToOne, OneToOne, 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'
-
-import { Inventory } from '../inventory/inventory'
-
-@Entity()
-@Index('ix_pallet_0', (pallet: Pallet) => [pallet.domain, pallet.name], { unique: true })
-@ObjectType()
-export class Pallet {
-  @PrimaryGeneratedColumn('uuid')
-  @Field()
-  id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain: Domain
-
-  @RelationId((pallet: Pallet) => pallet.domain)
-  domainId: string
-
-  @Column()
-  @Field()
-  name: string
-
-  @Column({ default: 0 })
-  @Field(type => Int)
-  seq: number
-
-  @ManyToOne(type => Bizplace)
-  @Field()
-  owner: Bizplace
-
-  @ManyToOne(type => Bizplace)
-  @Field()
-  holder: Bizplace
-
-  @OneToOne(type => Inventory, { nullable: true })
-  @JoinColumn()
-  @Field(type => Inventory, { nullable: true })
-  inventory: Inventory
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  refOrderNo: string
-
-  @Column()
-  @Field()
-  status: string
-
-  @Column({
-    nullable: true,
-    default: 'NORMAL'
-  })
-  @Field({ nullable: true })
-  type?: string = 'NORMAL'
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  printedAt?: Date
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt: Date
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field({ nullable: true })
-  creator: User
-
-  @RelationId((pallet: Pallet) => pallet.creator)
-  creatorId: string
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field({ nullable: true })
-  updater: User
-
-  @RelationId((pallet: Pallet) => pallet.updater)
-  updaterId: string
-}

package/server/service/pallet-count/index.ts

@@ -1,6 +0,0 @@
-import { PalletCount } from './pallet-count'
-import { PalletCountMutation } from './pallet-count-mutation'
-import { PalletCountQuery } from './pallet-count-query'
-
-export const entities = [PalletCount]
-export const resolvers = [PalletCountQuery, PalletCountMutation]

package/server/service/pallet-count/pallet-count-mutation.ts

@@ -1,151 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In, MoreThan } from 'typeorm'
-import { v4 as uuidv4 } from 'uuid'
-
-import { PalletCount } from './pallet-count'
-import { NewPalletCount, PalletCountPatch } from './pallet-count-types'
-
-@Resolver(PalletCount)
-export class PalletCountMutation {
-  @Directive('@transaction')
-  @Mutation(returns => PalletCount)
-  async createPalletCount(
-    @Arg('palletCount') palletCount: NewPalletCount,
-    @Ctx() context: ResolverContext
-  ): Promise<PalletCount> {
-    const { domain, user, tx } = context.state
-
-    return await tx.getRepository(PalletCount).save({
-      ...palletCount,
-      domain: domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => PalletCount)
-  async updatePalletCount(
-    @Arg('name') name: string,
-    @Arg('patch') patch: PalletCountPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<PalletCount> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(PalletCount)
-    const palletCount = await repository.findOne({
-      where: { domain: { id: domain.id }, name }
-    })
-
-    return await repository.save({
-      ...palletCount,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [PalletCount])
-  async updateMultiplePalletCount(
-    @Arg('patches', type => [PalletCountPatch]) patches: PalletCountPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<PalletCount[]> {
-    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 palletCountRepo = tx.getRepository(PalletCount)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await palletCountRepo.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 palletCount = await palletCountRepo.findOneBy({ id: newRecord.id })
-
-        const result = await palletCountRepo.save({
-          ...palletCount,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deletePalletCount(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(PalletCount).delete({ domain: { id: domain.id }, name })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deletePalletCounts(
-    @Arg('names', type => [String]) names: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<Boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(PalletCount).delete({
-      domain: { id: domain.id },
-      name: In(names)
-    })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => PalletCount)
-  async updatePalletCountSeq(@Arg('printQty') printQty: number, @Ctx() context: ResolverContext): Promise<PalletCount> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(PalletCount)
-    const todayDate = new Date()
-    todayDate.setHours(0, 0, 0, 0)
-    const palletCount = await repository.findOne({
-      where: { domain: { id: domain.id }, createdAt: MoreThan(todayDate) }
-    })
-
-    if (!palletCount) {
-      let newPallet = {
-        name: uuidv4(),
-        seq: 0,
-        domain: domain,
-        creator: user,
-        updater: user
-      }
-
-      return await tx.getRepository(PalletCount).save({
-        ...newPallet,
-        seq: printQty
-      })
-    } else {
-      await tx.getRepository(PalletCount).save({
-        ...palletCount,
-        seq: printQty + palletCount.seq
-      })
-
-      return palletCount
-    }
-  }
-}