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

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

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

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

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

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

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

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