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

package/server/service/reverse-kitting-order/reverse-kitting-order-type.ts

@@ -0,0 +1,173 @@
+import {
+  Field,
+  Float,
+  ID,
+  InputType,
+  Int,
+  ObjectType
+} from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Product } from '@things-factory/product-base'
+import {
+  Domain,
+  ObjectRef
+} from '@things-factory/shell'
+import {
+  Inventory,
+  Location,
+  Warehouse
+} from '@things-factory/warehouse-base'
+
+import {
+  NewReverseKittingOrderInventory
+} from '../reverse-kitting-order-inventory/reverse-kitting-order-inventory-type'
+import { ReverseKittingOrder } from './reverse-kitting-order'
+
+@InputType()
+export class NewReverseKittingOrder {
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  customerBizplaceId?: string
+
+  @Field({ nullable: true })
+  status?: string
+
+  @Field(type => [NewReverseKittingOrderInventory], { nullable: true })
+  reverseKittingOrderInventories?: NewReverseKittingOrderInventory[]
+
+  @Field({ nullable: true })
+  remark?: string
+}
+
+@InputType()
+export class LotInfo {
+  @Field()
+  id: string
+
+  @Field()
+  printQty: number
+}
+
+@InputType()
+export class ReverseKittingOrderPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field(type => [ObjectRef], { nullable: true })
+  reverseKittingOrderInventories: ObjectRef[]
+
+  @Field({ nullable: true })
+  status?: string
+
+  @Field({ nullable: true })
+  remark?: string
+
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class ReverseKittingOrderList {
+  @Field(type => [ReverseKittingOrder])
+  items: ReverseKittingOrder[]
+
+  @Field(type => Int)
+  total: number
+}
+
+@ObjectType()
+export class ReverseKittingInventoryDetail {
+  @Field(type => ID)
+  readonly id: string
+
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @Field(type => Bizplace, { nullable: true })
+  bizplace: Bizplace
+
+  @Field(type => Inventory, { nullable: true })
+  refInventory: Inventory
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  palletId: string
+
+  @Field({ nullable: true })
+  cartonId: string
+
+  @Field({ nullable: true })
+  batchId: string
+
+  @Field(type => Product, { nullable: true })
+  product: Product
+
+  @Field(type => Location, { nullable: true })
+  location: Location
+
+  @Field(type => Warehouse, { nullable: true })
+  warehouse: Warehouse
+
+  @Field({ nullable: true })
+  zone: string
+
+  @Field({ nullable: true })
+  packingType: string
+
+  @Field(type => Float, { nullable: true })
+  packingSize: number
+
+  @Field(type => Float, { nullable: true })
+  qty: number
+
+  @Field(type => Float, { nullable: true })
+  remainQty: number
+
+  @Field({ nullable: true })
+  otherRef: string
+
+  @Field(type => Int, { nullable: true })
+  lastSeq: number
+
+  @Field(type => Float, { nullable: true })
+  uomValue: number
+
+  @Field(type => Float, { nullable: true })
+  remainUomValue: number
+
+  @Field({ nullable: true })
+  uom: string
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  remark: string
+
+  @Field({ nullable: true })
+  batchIdRef: string
+
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @Field({ nullable: true })
+  createdAt: string
+
+  @Field({ nullable: true })
+  updatedAt: string
+}

package/server/service/reverse-kitting-order/reverse-kitting-order.ts

@@ -0,0 +1,121 @@
+import { Field, Float, ID, Int, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Bizplace } from '@things-factory/biz-base'
+import { Product } from '@things-factory/product-base'
+import { Domain } from '@things-factory/shell'
+import { Location } from '@things-factory/warehouse-base'
+
+import { ReverseKittingOrderInventory } from '../reverse-kitting-order-inventory/reverse-kitting-order-inventory'
+
+@Entity()
+@Index(
+  'ix_reverse_kitting_order_0',
+  (reverseKittingOrder: ReverseKittingOrder) => [reverseKittingOrder.domain, reverseKittingOrder.name],
+  { unique: true }
+)
+@ObjectType({ description: 'Entity for ReverseKittingOrder' })
+export class ReverseKittingOrder {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain?: Domain
+
+  @RelationId((reverseKittingOrder: ReverseKittingOrder) => reverseKittingOrder.domain)
+  domainId?: string
+
+  @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace, { nullable: true })
+  bizplace: Bizplace
+
+  @RelationId((reverseKittingOrder: ReverseKittingOrder) => reverseKittingOrder.bizplace)
+  bizplaceId?: string
+
+  @OneToMany(
+    type => ReverseKittingOrderInventory,
+    reverseKittingOrderInventory => reverseKittingOrderInventory.reverseKittingOrder
+  )
+  @Field(type => [ReverseKittingOrderInventory], { nullable: true })
+  reverseKittingOrderInventories?: ReverseKittingOrderInventory[]
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  remark?: string
+
+  @Field({ nullable: true })
+  batchId?: string
+
+  @Field({ nullable: true })
+  packingType?: string
+
+  @Field(type => Float, { nullable: true })
+  packingSize?: number
+
+  @Column()
+  @Field({ nullable: true })
+  status?: string
+
+  @Field({ nullable: true })
+  batchIdRef?: string
+
+  @Field({ nullable: true })
+  palletId?: string
+
+  @Field({ nullable: true })
+  cartonId?: string
+
+  @Field(type => Int, { nullable: true })
+  qty?: number
+
+  @Field({ nullable: true })
+  expirationDate?: string
+
+  @Field(type => Location, { nullable: true })
+  location?: Location
+
+  @Field(type => Product, { nullable: true })
+  product?: Product
+
+  @Field({ nullable: true })
+  productDetailId?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((reverseKittingOrder: ReverseKittingOrder) => reverseKittingOrder.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((reverseKittingOrder: ReverseKittingOrder) => reverseKittingOrder.updater)
+  updaterId?: string
+}

package/server/service/reverse-kitting-order-inventory/index.ts

@@ -0,0 +1,9 @@
+import { ReverseKittingOrderInventory } from './reverse-kitting-order-inventory'
+import { ReverseKittingOrderInventoryQuery } from './reverse-kitting-order-inventory-query'
+import { ReverseKittingOrderInventoryMutation } from './reverse-kitting-order-inventory-mutation'
+
+export const entities = [ReverseKittingOrderInventory]
+export const resolvers = [ReverseKittingOrderInventoryQuery, ReverseKittingOrderInventoryMutation]
+
+export * from './reverse-kitting-order-inventory-mutation'
+export * from './reverse-kitting-order-inventory-query'

package/server/service/reverse-kitting-order-inventory/reverse-kitting-order-inventory-mutation.ts

@@ -0,0 +1,129 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+
+import { ReverseKittingOrderInventory } from './reverse-kitting-order-inventory'
+import {
+  NewReverseKittingOrderInventory,
+  ReverseKittingOrderInventoryPatch
+} from './reverse-kitting-order-inventory-type'
+
+@Resolver(ReverseKittingOrderInventory)
+export class ReverseKittingOrderInventoryMutation {
+  @Directive('@transaction')
+  @Mutation(returns => ReverseKittingOrderInventory, { description: 'To create new ReverseKittingOrderInventory' })
+  async createReverseKittingOrderInventory(
+    @Arg('reverseKittingOrderInventory') reverseKittingOrderInventory: NewReverseKittingOrderInventory,
+    @Ctx() context: ResolverContext
+  ): Promise<ReverseKittingOrderInventory> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(ReverseKittingOrderInventory).save({
+      ...reverseKittingOrderInventory,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => ReverseKittingOrderInventory, {
+    description: 'To modify ReverseKittingOrderInventory information'
+  })
+  async updateReverseKittingOrderInventory(
+    @Arg('id') id: string,
+    @Arg('patch') patch: ReverseKittingOrderInventoryPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<ReverseKittingOrderInventory> {
+    const { tx, user, domain } = context.state
+    const reverseKittingOI: ReverseKittingOrderInventory = await tx
+      .getRepository(ReverseKittingOrderInventory)
+      .findOne({
+        where: {
+          domain: { id: domain.id },
+          bizplace: { id: In(await getPermittedBizplaceIds(domain, user)) },
+          id
+        }
+      })
+
+    return await tx.getRepository(ReverseKittingOrderInventory).save({
+      ...reverseKittingOI,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [ReverseKittingOrderInventory], {
+    description: "To modify multiple ReverseKittingOrderInventories' information"
+  })
+  async updateMultipleReverseKittingOrderInventory(
+    @Arg('patches', type => [ReverseKittingOrderInventoryPatch]) patches: ReverseKittingOrderInventoryPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<ReverseKittingOrderInventory[]> {
+    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 reverseKittingOrderInventoryRepo = tx.getRepository(ReverseKittingOrderInventory)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await reverseKittingOrderInventoryRepo.save({
+          ...newRecord,
+          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 reverseKittingOrderInventory = await reverseKittingOrderInventoryRepo.findOneBy({ id: newRecord.id })
+
+        const result = await reverseKittingOrderInventoryRepo.save({
+          ...reverseKittingOrderInventory,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete ReverseKittingOrderInventory' })
+  async deleteReverseKittingOrderInventory(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(ReverseKittingOrderInventory).delete({ domain: { id: domain.id }, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple reverseKittingOrderInventorys' })
+  async deleteReverseKittingOrderInventories(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(ReverseKittingOrderInventory).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    return true
+  }
+}

package/server/service/reverse-kitting-order-inventory/reverse-kitting-order-inventory-query.ts

@@ -0,0 +1,52 @@
+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 { ReverseKittingOrderInventory } from './reverse-kitting-order-inventory'
+import { ReverseKittingOrderInventoryList } from './reverse-kitting-order-inventory-type'
+
+@Resolver(ReverseKittingOrderInventory)
+export class ReverseKittingOrderInventoryQuery {
+  @Query(returns => ReverseKittingOrderInventory, { description: 'To fetch a ReverseKittingOrderInventory' })
+  async reverseKittingOrderInventory(
+    @Arg('id') id: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ReverseKittingOrderInventory> {
+    const { domain } = context.state
+
+    return await getRepository(ReverseKittingOrderInventory).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Query(returns => ReverseKittingOrderInventoryList, {
+    description: 'To fetch multiple ReverseKittingOrderInventories'
+  })
+  async reverseKittingOrderInventories(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<ReverseKittingOrderInventoryList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, { domain })
+    const [items, total] = await getRepository(ReverseKittingOrderInventory).findAndCount(convertedParams)
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() reverseKittingOrderInventory: ReverseKittingOrderInventory): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: reverseKittingOrderInventory.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() reverseKittingOrderInventory: ReverseKittingOrderInventory): Promise<User> {
+    return await getRepository(User).findOneBy({ id: reverseKittingOrderInventory.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() reverseKittingOrderInventory: ReverseKittingOrderInventory): Promise<User> {
+    return await getRepository(User).findOneBy({ id: reverseKittingOrderInventory.creatorId })
+  }
+}

package/server/service/reverse-kitting-order-inventory/reverse-kitting-order-inventory-type.ts

@@ -0,0 +1,95 @@
+import { Field, Float, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { ReverseKittingOrderInventory } from './reverse-kitting-order-inventory'
+
+@InputType()
+export class NewReverseKittingOrderInventory {
+  @Field()
+  name: string
+
+  @Field(type => Int)
+  set: number
+
+  @Field({ nullable: true })
+  batchId?: string
+
+  @Field({ nullable: true })
+  remark?: string
+
+  @Field({ nullable: true })
+  operationGuide?: string
+
+  @Field(type => Int, { nullable: true })
+  qty?: number
+
+  @Field(type => Float, { nullable: true })
+  uomValue?: number
+
+  @Field({ nullable: true })
+  productName?: string
+
+  @Field({ nullable: true })
+  packingType?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  reverseKittingOrder?: ObjectRef
+
+  @Field(type => ObjectRef)
+  inventory?: ObjectRef
+
+  @Field({ nullable: true })
+  status: string
+}
+
+@InputType()
+export class ReverseKittingOrderInventoryPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field(type => Int, { nullable: true })
+  set: number
+
+  @Field({ nullable: true })
+  batchId?: string
+
+  @Field({ nullable: true })
+  remark?: string
+
+  @Field({ nullable: true })
+  operationGuide?: string
+
+  @Field(type => Int, { nullable: true })
+  qty?: number
+
+  @Field(type => Float, { nullable: true })
+  uomValue?: number
+
+  @Field(type => ObjectRef, { nullable: true })
+  reverseKittingOrder: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  inventory: ObjectRef
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field({ nullable: true })
+  cuFlag: string
+
+  @Field({ nullable: true })
+  issue: string
+}
+
+@ObjectType()
+export class ReverseKittingOrderInventoryList {
+  @Field(type => [ReverseKittingOrderInventory])
+  items: ReverseKittingOrderInventory[]
+
+  @Field(type => Int)
+  total: number
+}