@things-factory/sales-base 4.0.0-y.0 → 4.0.4

package/server/{entities → service/order-inventory}/order-inventory.ts

@@ -3,9 +3,26 @@ import { Bizplace } from '@things-factory/biz-base'
 import { Product } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
 import { Inventory, Location } from '@things-factory/warehouse-base'
-import { Column, CreateDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
-import { ArrivalNotice, DeliveryOrder, ReleaseGood, ReturnOrder, TransferOrder, OrderProduct } from '../entities'
-import { InventoryCheck } from './inventory-check'
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+import {
+  ArrivalNotice,
+  DeliveryOrder,
+  InventoryCheck,
+  OrderProduct,
+  ReleaseGood,
+  ReturnOrder,
+  TransferOrder
+} from '../'
 
 @Entity()
 @Index('ix_order-inventory_0', (orderInventory: OrderInventory) => [orderInventory.domain, orderInventory.name], {
@@ -35,149 +52,241 @@ import { InventoryCheck } from './inventory-check'
   ],
   { unique: true }
 )
+@ObjectType()
 export class OrderInventory {
   @PrimaryGeneratedColumn('uuid')
-  id: string
+  @Field(type => ID)
+  readonly id: string
 
   @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
   domain: Domain
 
+  @RelationId((orderInventory: OrderInventory) => orderInventory.domain)
+  domainId: string
+
   @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace, { nullable: true })
   bizplace: Bizplace
 
+  @RelationId((orderInventory: OrderInventory) => orderInventory.bizplace)
+  bizplaceId: string
+
   @Column()
+  @Field()
   name: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   type: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   remark: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   issue: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   description: string
 
   @ManyToOne(type => Inventory, { nullable: true })
+  @Field(type => Inventory, { nullable: true })
   inventory: Inventory
 
+  @RelationId((orderInventory: OrderInventory) => orderInventory.inventory)
+  inventoryId: string
+
   @ManyToOne(type => Product, { nullable: true })
+  @Field(type => Product, { nullable: true })
   product: Product
 
+  @RelationId((orderInventory: OrderInventory) => orderInventory.product)
+  productId: string
+
   @Column({ nullable: true })
+  @Field({ nullable: true })
   batchId: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   batchIdRef: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   packingType: string
 
   @Column('float', { default: 1 })
+  @Field()
   packingSize: number
 
   @ManyToOne(type => ArrivalNotice)
+  @Field(type => ArrivalNotice, { nullable: true })
   arrivalNotice: ArrivalNotice
 
+  @RelationId((orderInventory: OrderInventory) => orderInventory.arrivalNotice)
+  arrivalNoticeId: string
+
   @ManyToOne(type => ReleaseGood)
+  @Field(type => ReleaseGood, { nullable: true })
   releaseGood: ReleaseGood
 
+  @RelationId((orderInventory: OrderInventory) => orderInventory.releaseGood)
+  releaseGoodId: string
+
   @ManyToOne(type => InventoryCheck)
+  @Field(type => InventoryCheck, { nullable: true })
   inventoryCheck: InventoryCheck
 
+  @RelationId((orderInventory: OrderInventory) => orderInventory.inventoryCheck)
+  inventoryCheckId: string
+
   @ManyToOne(type => DeliveryOrder)
+  @Field(type => DeliveryOrder, { nullable: true })
   deliveryOrder: DeliveryOrder
 
+  @RelationId((orderInventory: OrderInventory) => orderInventory.deliveryOrder)
+  deliveryOrderId: string
+
   @ManyToOne(type => TransferOrder)
+  @Field(type => TransferOrder, { nullable: true })
   transferOrder: TransferOrder
 
+  @RelationId((orderInventory: OrderInventory) => orderInventory.transferOrder)
+  transferOrderId: string
+
   @ManyToOne(type => ReturnOrder)
+  @Field(type => ReturnOrder, { nullable: true })
   returnOrder: ReturnOrder
 
+  @RelationId((orderInventory: OrderInventory) => orderInventory.returnOrder)
+  returnOrderId: string
+
   @ManyToOne(type => OrderProduct)
+  @Field(type => OrderProduct, { nullable: true })
   orderProduct: OrderProduct
 
+  @RelationId((orderInventory: OrderInventory) => orderInventory.orderProduct)
+  orderProductId: string
+
   @Column({ type: 'uuid', nullable: true })
+  @Field({ nullable: true })
   refWorksheetId: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   originQty: number
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   inspectedQty: number
 
   @Column({ nullable: true, type: 'float' })
+  @Field({ nullable: true })
   originUomValue: number
 
   @Column({ nullable: true, type: 'float' })
+  @Field({ nullable: true })
   inspectedUomValue: number
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   originBatchNo: string
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   inspectedBatchNo: string
 
   @ManyToOne(type => Location, { nullable: true })
+  @Field(type => Location, { nullable: true })
   originLocation: Location
 
+  @RelationId((orderInventory: OrderInventory) => orderInventory.originLocation)
+  originLocationId: string
+
   @ManyToOne(type => Location, { nullable: true })
+  @Field(type => Location, { nullable: true })
   inspectedLocation: Location
 
+  @RelationId((orderInventory: OrderInventory) => orderInventory.inspectedLocation)
+  inspectedLocationId: string
+
   @ManyToOne(type => Location, { nullable: true })
+  @Field(type => Location, { nullable: true })
   binLocation: Location
 
+  @RelationId((orderInventory: OrderInventory) => orderInventory.binLocation)
+  binLocationId: string
+
   @Column({ nullable: true, type: 'float' })
+  @Field({ nullable: true })
   releaseQty: number
 
   @Column({ nullable: true, type: 'float', default: 0 })
+  @Field({ nullable: true })
   pickedQty: number
 
   @Column({ nullable: true, type: 'float', default: 0 })
+  @Field({ nullable: true })
   packedQty: number
 
   @Column({ nullable: true, type: 'float', default: 0 })
+  @Field({ nullable: true })
   sortedQty: number
 
   @Column({ nullable: true, type: 'float' })
+  @Field({ nullable: true })
   releaseUomValue: number
 
   @Column({ nullable: true, type: 'float' })
+  @Field({ nullable: true })
   returnQty: number
 
   @Column({ nullable: true, type: 'float' })
+  @Field({ nullable: true })
   returnUomValue: number
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   actualPackQty: number
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   palletQty: number
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   actualPalletQty: number
 
   @Column({ nullable: true })
+  @Field({ nullable: true })
   crossDocking: boolean
 
   @Column()
+  @Field()
   status: string
 
   @CreateDateColumn()
+  @Field()
   createdAt: Date
 
   @UpdateDateColumn()
+  @Field()
   updatedAt: Date
 
-  @ManyToOne(type => User, {
-    nullable: true
-  })
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
   creator: User
 
-  @ManyToOne(type => User, {
-    nullable: true
-  })
+  @RelationId((orderInventory: OrderInventory) => orderInventory.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
   updater: User
+
+  @RelationId((orderInventory: OrderInventory) => orderInventory.updater)
+  updaterId: string
 }

package/server/service/order-product/index.ts

@@ -0,0 +1,9 @@
+import { OrderProduct } from './order-product'
+import { OrderProductMutation } from './order-product-mutation'
+import { OrderProductQuery } from './order-product-query'
+
+export const entities = [OrderProduct]
+export const resolvers = [OrderProductQuery, OrderProductMutation]
+
+export * from './order-product-mutation'
+export * from './order-product-query'

package/server/service/order-product/order-product-mutation.ts

@@ -0,0 +1,28 @@
+import { Domain } from '@things-factory/shell'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In } from 'typeorm'
+import { OrderProduct } from './order-product'
+
+@Resolver(OrderProduct)
+export class OrderProductMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteOrderProduct(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
+    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+
+    await tx.getRepository(OrderProduct).delete({ domain, name })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteOrderProducts(@Arg('names', type => [String]) names: string[], @Ctx() context: any): Promise<boolean> {
+    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+
+    await tx.getRepository(OrderProduct).delete({
+      domain,
+      name: In(names)
+    })
+    return true
+  }
+}

package/server/service/order-product/order-product-query.ts

@@ -0,0 +1,52 @@
+import { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository } from 'typeorm'
+import { OrderProductList } from '../'
+import { OrderProduct } from './order-product'
+
+@Resolver(OrderProduct)
+export class OrderProductQuery {
+  @Query(returns => OrderProductList)
+  async orderProducts(
+    @Ctx() context: any,
+    @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<OrderProductList> {
+    const convertedParams = convertListParams({ filters, pagination, sortings })
+    const [items, total] = await getRepository(OrderProduct).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'bizplace', 'bizplace.company', 'arrivalNotice', 'product', 'creator', 'updater']
+    })
+    return { items, total }
+  }
+
+  @Query(returns => OrderProduct)
+  async orderProduct(@Ctx() context: any, @Arg('name') name: string): Promise<OrderProduct> {
+    const { domain }: { domain: Domain } = context.state
+
+    return await getRepository(OrderProduct).findOne({
+      where: {
+        domain,
+        name,
+        relations: ['domain', 'arrivalNotice', 'product', 'creator', 'updater']
+      }
+    })
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() orderProduct: OrderProduct): Promise<Domain> {
+    return await getRepository(Domain).findOne(orderProduct.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() orderProduct: OrderProduct): Promise<User> {
+    return await getRepository(User).findOne(orderProduct.creatorId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() orderProduct: OrderProduct): Promise<User> {
+    return await getRepository(User).findOne(orderProduct.updaterId)
+  }
+}

package/server/service/order-product/order-product-types.ts

@@ -0,0 +1,327 @@
+import { ObjectRef } from '@things-factory/shell'
+import { Field, Float, InputType, Int, ObjectType } from 'type-graphql'
+import { OrderProduct } from './order-product'
+
+@ObjectType()
+export class OrderProductList {
+  @Field(type => [OrderProduct], { nullable: true })
+  items: OrderProduct[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class InboundProduct {
+  @Field({ nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  type: string
+
+  @Field({ nullable: true })
+  packingType: string
+
+  @Field(type => Float, { nullable: true })
+  packingSize: number
+
+  @Field({ nullable: true })
+  sku: string
+
+  @Field({ nullable: true })
+  uom: string
+
+  @Field(type => Float, { nullable: true })
+  uomValue: number
+}
+
+@InputType()
+export class OrderProductPatch {
+  @Field({ nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  type: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  arrivalNotice: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  collectionOrder: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  deliveryOrder: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  releaseGood: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  shippingOrder: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  retailReplenishmentOrder: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  fromInventory: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  currentInventory: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  toInventory: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  product: ObjectRef
+
+  @Field({ nullable: true })
+  batchId: string
+
+  @Field({ nullable: true })
+  adjustedBatchId: string
+
+  @Field({ nullable: true })
+  batchIdRef: string
+
+  @Field({ nullable: true })
+  adjustedBatchIdRef: string
+
+  @Field({ nullable: true })
+  packingType: string
+
+  @Field({ nullable: true })
+  adjustedPackingType: string
+
+  @Field(type => Float, { nullable: true })
+  packingSize: number
+
+  @Field({ nullable: true })
+  uom: string
+
+  @Field({ nullable: true })
+  adjustedUom: string
+
+  @Field(type => Float, { nullable: true })
+  uomValue: number
+
+  @Field(type => Float, { nullable: true })
+  adjustedUomValue: number
+
+  @Field(type => Float, { nullable: true })
+  unpackUomValue: number
+
+  @Field(type => Int, { nullable: true })
+  packQty: number
+
+  @Field(type => Int, { nullable: true })
+  adjustedPackQty: number
+
+  @Field(type => Int, { nullable: true })
+  actualPackQty: number
+
+  @Field(type => Int, { nullable: true })
+  unpackQty: number
+
+  @Field(type => Int, { nullable: true })
+  palletQty: number
+
+  @Field(type => Int, { nullable: true })
+  actualPalletQty: number
+
+  @Field(type => Int, { nullable: true })
+  adjustedPalletQty: number
+
+  @Field({ nullable: true })
+  adjustedTotalUomValue: string
+
+  @Field({ nullable: true })
+  totalUomValue: string
+
+  @Field(type => Int, { nullable: true })
+  releaseQty: number
+
+  @Field(type => Float, { nullable: true })
+  releaseUomValue: number
+
+  @Field(type => Float, { nullable: true })
+  unitPrice: number
+
+  @Field(type => Float, { nullable: true })
+  adjustedUnitPrice: number
+
+  @Field(type => Float, { nullable: true })
+  discountAmt: number
+
+  @Field(type => Float, { nullable: true })
+  miscAmt: number
+
+  @Field(type => Float, { nullable: true })
+  taxRate: number
+
+  @Field({ nullable: true })
+  remark: string
+
+  @Field({ nullable: true })
+  issue: string
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field(type => Int, { nullable: true })
+  manufactureYear: number
+
+  @Field({ nullable: true })
+  cuFlag: string
+}
+
+@InputType()
+export class NewOrderProduct {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  type: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  arrivalNotice: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  collectionOrder: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  deliveryOrder: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  releaseGood: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  shippingOrder: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  retailReplenishmentOrder: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  fromInventory: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  currentInventory: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  toInventory: ObjectRef
+
+  @Field(type => InboundProduct, { nullable: true })
+  product: InboundProduct
+
+  @Field({ nullable: true })
+  productSKU: string
+
+  @Field({ nullable: true })
+  batchId: string
+
+  @Field({ nullable: true })
+  adjustedBatchId: string
+
+  @Field({ nullable: true })
+  batchIdRef: string
+
+  @Field({ nullable: true })
+  adjustedBatchIdRef: string
+
+  @Field({ nullable: true })
+  packingType: string
+
+  @Field({ nullable: true })
+  adjustedPackingType: string
+
+  @Field(type => Float, { nullable: true })
+  packingSize: number
+
+  @Field({ nullable: true })
+  uom: string
+
+  @Field({ nullable: true })
+  adjustedUom: string
+
+  @Field(type => Float, { nullable: true })
+  uomValue: number
+
+  @Field(type => Float, { nullable: true })
+  adjustedUomValue: number
+
+  @Field(type => Float, { nullable: true })
+  unpackUomValue: number
+
+  @Field(type => Int, { nullable: true })
+  packQty: number
+
+  @Field(type => Int, { nullable: true })
+  adjustedPackQty: number
+
+  @Field(type => Int, { nullable: true })
+  actualPackQty: number
+
+  @Field(type => Int, { nullable: true })
+  unpackQty: number
+
+  @Field(type => Int, { nullable: true })
+  palletQty: number
+
+  @Field(type => Int, { nullable: true })
+  actualPalletQty: number
+
+  @Field(type => Int, { nullable: true })
+  adjustedPalletQty: number
+
+  @Field({ nullable: true })
+  adjustedTotalUomValue: string
+
+  @Field({ nullable: true })
+  totalUomValue: string
+
+  @Field(type => Int, { nullable: true })
+  releaseQty: number
+
+  @Field(type => Float, { nullable: true })
+  releaseUomValue: number
+
+  @Field(type => Float, { nullable: true })
+  unitPrice: number
+
+  @Field(type => Float, { nullable: true })
+  adjustedUnitPrice: number
+
+  @Field(type => Float, { nullable: true })
+  discountAmt: number
+
+  @Field(type => Float, { nullable: true })
+  miscAmt: number
+
+  @Field(type => Float, { nullable: true })
+  taxRate: number
+
+  @Field({ nullable: true })
+  remark: string
+
+  @Field({ nullable: true })
+  issue: string
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field(type => Int, { nullable: true })
+  manufactureYear: number
+}