@things-factory/warehouse-base 3.7.13 → 3.8.1

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

@@ -0,0 +1,105 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, 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() params: ListParam, @Ctx() context: any): Promise<PalletList> {
+    if (!params.filters.find((filter: any) => filter.name === 'status')) {
+      params.filters.push({
+        name: 'status',
+        operator: 'noteq',
+        value: 'TERMINATED'
+      })
+    }
+
+    const convertedParams = convertListParams(params, context.state.domain.id)
+    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: any): Promise<Pallet> {
+    const { domain }: { domain: Domain } = context.state
+
+    let records = await getRepository(Pallet).findOne({
+      where: { domain: domain, name },
+      relations: ['owner', 'holder', 'domain', 'creator', 'updater']
+    })
+    return records
+  }
+
+  @Query(returns => PalletValidate)
+  async palletInboundValidate(@Arg('name') name: string, @Ctx() context: any): Promise<PalletValidate> {
+    try {
+      const { domain }: { domain: Domain } = context.state
+
+      let item = await getRepository(Pallet).findOne({
+        where: { domain: domain, 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: any): Promise<PalletValidate> {
+    try {
+      const { domain }: { domain: Domain } = context.state
+
+      let item = await getRepository(Pallet).findOne({
+        where: { domain: domain, 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: any
+  ): Promise<Pallet | boolean> {
+    const { domain }: { domain: Domain } = context.state
+
+    let records = await getRepository(Pallet).findOne({
+      where: { domain: domain, name, status },
+      relations: ['owner', 'holder', 'domain', 'creator', 'updater']
+    })
+
+    return records
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() pallet: Pallet) {
+    return await getRepository(Domain).findOne(pallet.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() pallet: Pallet) {
+    return await getRepository(User).findOne(pallet.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() pallet: Pallet) {
+    return await getRepository(User).findOne(pallet.creatorId)
+  }
+}

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

@@ -0,0 +1,68 @@
+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
+}
+
+@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 })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class PalletValidate {
+  @Field(type => Pallet, { nullable: true })
+  item?: Pallet
+
+  @Field({ nullable: true })
+  error?: string
+}

package/server/{entities → service/pallet}/pallet.ts

@@ -1,6 +1,4 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
+import { Field, Int, ObjectType } from 'type-graphql'
 import {
   Column,
   CreateDateColumn,
@@ -10,56 +8,85 @@ import {
   ManyToOne,
   OneToOne,
   PrimaryGeneratedColumn,
+  RelationId,
   UpdateDateColumn
 } from 'typeorm'
-import { Inventory } from '.'
+
+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()
   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
 
   @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,148 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In, MoreThan } from 'typeorm'
+import uuid from 'uuid/v4'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+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: any): Promise<PalletCount> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = 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: any
+  ): Promise<PalletCount> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    const repository = tx.getRepository(PalletCount)
+    const palletCount = await repository.findOne({
+      where: { domain: domain, name }
+    })
+
+    return await repository.save({
+      ...palletCount,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [PalletCount])
+  async updateMultiplePalletCount(
+    @Arg('patches', type => [PalletCountPatch]) patches: PalletCountPatch[],
+    @Ctx() context: any
+  ): Promise<PalletCount[]> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = 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.findOne(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: any): Promise<Boolean> {
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+
+    await tx.getRepository(PalletCount).delete({ domain: domain, name })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deletePalletCounts(@Arg('names', type => [String]) names: string[], @Ctx() context: any): Promise<Boolean> {
+    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+
+    await tx.getRepository(PalletCount).delete({
+      domain: domain,
+      name: In(names)
+    })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => PalletCount)
+  async updatePalletCountSeq(@Arg('printQty') printQty: number, @Ctx() context: any): Promise<PalletCount> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    const repository = tx.getRepository(PalletCount)
+    const todayDate = new Date()
+    todayDate.setHours(0, 0, 0, 0)
+    const palletCount = await repository.findOne({
+      where: { domain: domain, createdAt: MoreThan(todayDate) }
+    })
+
+    if (!palletCount) {
+      let newPallet = {
+        name: uuid(),
+        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
+    }
+  }
+}

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

@@ -0,0 +1,46 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, ListParam } from '@things-factory/shell'
+
+import { PalletCount } from './pallet-count'
+import { PalletCountList } from './pallet-count-types'
+
+@Resolver(PalletCount)
+export class PalletCountQuery {
+  @Query(returns => PalletCountList)
+  async palletCounts(@Args() params: ListParam): Promise<PalletCountList> {
+    const convertedParams = convertListParams(params)
+    const [items, total] = await getRepository(PalletCount).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'creator', 'updater']
+    })
+    return { items, total }
+  }
+
+  @Query(returns => PalletCount)
+  async palletCount(@Arg('name') name: string, @Ctx() context: any): Promise<PalletCount> {
+    const { domain }: { domain: Domain } = context.state
+
+    return await getRepository(PalletCount).findOne({
+      where: { domain: domain, name },
+      relations: ['domain', 'creator', 'updater']
+    })
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() palletCount: PalletCount) {
+    return await getRepository(Domain).findOne(palletCount.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() palletCount: PalletCount) {
+    return await getRepository(User).findOne(palletCount.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() palletCount: PalletCount) {
+    return await getRepository(User).findOne(palletCount.creatorId)
+  }
+}

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

@@ -0,0 +1,36 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { PalletCount } from './pallet-count'
+
+@InputType()
+export class NewPalletCount {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+}
+
+@ObjectType()
+export class PalletCountList {
+  @Field(type => [PalletCount], { nullable: true })
+  items?: PalletCount[]
+
+  @Field(type => Int, { nullable: true })
+  total?: number
+}
+
+@InputType()
+export class PalletCountPatch {
+  @Field({ nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}

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

@@ -0,0 +1,70 @@
+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'
+
+@Entity()
+@Index('ix_pallet-count_0', (palletCount: PalletCount) => [palletCount.domain, palletCount.name], { unique: true })
+@ObjectType()
+export class PalletCount {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  id: string
+
+  @ManyToOne(type => Domain)
+  @Field()
+  domain: Domain
+
+  @RelationId((palletCount: PalletCount) => palletCount.domain)
+  domainId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ default: 0 })
+  @Field()
+  seq: number
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  description: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator: User
+
+  @RelationId((palletCount: PalletCount) => palletCount.creator)
+  creatorId: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater: User
+
+  @RelationId((palletCount: PalletCount) => palletCount.updater)
+  updaterId: string
+}

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

@@ -0,0 +1,6 @@
+import { PalletHistory } from './pallet-history'
+import { PalletHistoryMutation } from './pallet-history-mutation'
+import { PalletHistoryQuery } from './pallet-history-query'
+
+export const entities = [PalletHistory]
+export const resolvers = [PalletHistoryQuery, PalletHistoryMutation]

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

@@ -0,0 +1,114 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { PalletHistory } from './pallet-history'
+import { NewPalletHistory, PalletHistoryPatch } from './pallet-history-types'
+
+@Resolver(PalletHistory)
+export class PalletHistoryMutation {
+  @Directive('@transaction')
+  @Mutation(returns => PalletHistory)
+  async createPalletHistory(
+    @Arg('palletHistory') palletHistory: NewPalletHistory,
+    @Ctx() context: any
+  ): Promise<PalletHistory> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    return await tx.getRepository(PalletHistory).save({
+      ...palletHistory,
+      domain: domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => PalletHistory)
+  async updatePalletHistory(
+    @Arg('name') name: string,
+    @Arg('patch') patch: PalletHistoryPatch,
+    @Ctx() context: any
+  ): Promise<PalletHistory> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    const repository = tx.getRepository(PalletHistory)
+    const palletHistory = await repository.findOne({
+      where: { domain: domain, name }
+    })
+
+    return await repository.save({
+      ...palletHistory,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [PalletHistory])
+  async updateMultiplePalletHistory(
+    @Arg('patches', type => [PalletHistoryPatch]) patches: PalletHistoryPatch[],
+    @Ctx() context: any
+  ): Promise<PalletHistory[]> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const palletHistoryRepo = tx.getRepository(PalletHistory)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await palletHistoryRepo.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 palletHistory = await palletHistoryRepo.findOne(newRecord.id)
+
+        const result = await palletHistoryRepo.save({
+          ...palletHistory,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deletePalletHistory(@Arg('name') name: string, @Ctx() context: any): Promise<Boolean> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    await tx.getRepository(PalletHistory).delete({ domain: domain, name })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deletePalletHistories(@Arg('names', type => [String]) names: string[], @Ctx() context: any): Promise<Boolean> {
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    await tx.getRepository(PalletHistory).delete({
+      domain: domain,
+      name: In(names)
+    })
+    return true
+  }
+}