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

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

@@ -0,0 +1,362 @@
+import { Field, Float, ID, 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, ContactPoint } from '@things-factory/biz-base'
+import { Product, ProductBundle, ProductDetail } from '@things-factory/product-base'
+import { Domain, ScalarDate, roundTransformer } from '@things-factory/shell'
+import { Inventory } from '@things-factory/warehouse-base'
+
+import { ArrivalNotice } from '../arrival-notice/arrival-notice'
+import { CollectionOrder } from '../collection-order/collection-order'
+import { DeliveryOrder } from '../delivery-order/delivery-order'
+import { DraftReleaseGood } from '../draft-release-good/draft-release-good'
+import { OrderInventory } from '../order-inventory/order-inventory'
+import { PurchaseOrder } from '../purchase-order/purchase-order'
+import { ReleaseGood } from '../release-good/release-good'
+import { RetailReplenishmentOrder } from '../retail-replenishment-order/retail-replenishment-order'
+
+@Entity()
+@Index('ix_order-product_0', (orderProduct: OrderProduct) => [orderProduct.domain, orderProduct.name], {
+  unique: true
+})
+@Index('ix_order-product_1', (orderProduct: OrderProduct) => [
+  orderProduct.bizplace,
+  orderProduct.arrivalNotice,
+  orderProduct.product,
+  orderProduct.batchId,
+  orderProduct.packingType
+])
+@Index(
+  'ix_order-product_2',
+  (orderProduct: OrderProduct) => [
+    orderProduct.bizplace,
+    orderProduct.retailReplenishmentOrder,
+    orderProduct.product,
+    orderProduct.batchId,
+    orderProduct.packingType
+  ],
+  { unique: true }
+)
+@Index(
+  'ix_order-product_3',
+  (orderProduct: OrderProduct) => [
+    orderProduct.bizplace,
+    orderProduct.purchaseOrder,
+    orderProduct.product,
+    orderProduct.batchId,
+    orderProduct.uom
+  ],
+  { unique: true }
+)
+@Index('ix_order-product_4', (orderProduct: OrderProduct) => [orderProduct.draftReleaseGood], { unique: false })
+@ObjectType()
+export class OrderProduct {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  id: string
+
+  @ManyToOne(type => Domain, { nullable: false })
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((orderProduct: OrderProduct) => orderProduct.domain)
+  domainId: string
+
+  @ManyToOne(type => Bizplace, { nullable: false })
+  @Field(type => Bizplace, { nullable: true })
+  bizplace: Bizplace
+
+  @RelationId((orderProduct: OrderProduct) => orderProduct.bizplace)
+  bizplaceId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  type: string
+
+  @ManyToOne(type => ArrivalNotice)
+  @Field(type => ArrivalNotice, { nullable: true })
+  arrivalNotice: ArrivalNotice
+
+  @RelationId((orderProduct: OrderProduct) => orderProduct.arrivalNotice)
+  arrivalNoticeId: string
+
+  @ManyToOne(type => ReleaseGood)
+  @Field(type => ReleaseGood, { nullable: true })
+  releaseGood: ReleaseGood
+
+  @RelationId((orderProduct: OrderProduct) => orderProduct.releaseGood)
+  releaseGoodId: string
+
+  @ManyToOne(type => DraftReleaseGood)
+  @Field(type => DraftReleaseGood, { nullable: true })
+  draftReleaseGood: DraftReleaseGood
+
+  @RelationId((orderProduct: OrderProduct) => orderProduct.draftReleaseGood)
+  draftReleaseGoodId: string
+
+  @ManyToOne(type => CollectionOrder)
+  @Field(type => CollectionOrder, { nullable: true })
+  collectionOrder: CollectionOrder
+
+  @RelationId((orderProduct: OrderProduct) => orderProduct.collectionOrder)
+  collectionOrderId: string
+
+  @ManyToOne(type => PurchaseOrder)
+  @Field(type => PurchaseOrder, { nullable: true })
+  purchaseOrder: PurchaseOrder
+
+  @RelationId((orderProduct: OrderProduct) => orderProduct.purchaseOrder)
+  purchaseOrderId: string
+
+  @OneToMany(type => OrderInventory, orderInventory => orderInventory.orderProduct)
+  @Field(type => [OrderInventory], { nullable: true })
+  orderInventories: OrderInventory
+
+  @ManyToOne(type => RetailReplenishmentOrder)
+  @Field(type => RetailReplenishmentOrder, { nullable: true })
+  retailReplenishmentOrder: RetailReplenishmentOrder
+
+  @RelationId((orderProduct: OrderProduct) => orderProduct.retailReplenishmentOrder)
+  retailReplenishmentOrderId: string
+
+  @ManyToOne(type => DeliveryOrder)
+  @Field(type => DeliveryOrder, { nullable: true })
+  deliveryOrder: DeliveryOrder
+
+  @RelationId((orderProduct: OrderProduct) => orderProduct.deliveryOrder)
+  deliveryOrderId: string
+
+  @ManyToOne(type => Inventory)
+  @Field(type => Inventory, { nullable: true })
+  fromInventory: Inventory
+
+  @RelationId((orderProduct: OrderProduct) => orderProduct.fromInventory)
+  fromInventoryId: string
+
+  @ManyToOne(type => Inventory)
+  @Field(type => Inventory, { nullable: true })
+  currentInventory: Inventory
+
+  @RelationId((orderProduct: OrderProduct) => orderProduct.currentInventory)
+  currentInventoryId: string
+
+  @ManyToOne(type => Inventory)
+  @Field(type => Inventory, { nullable: true })
+  toInventory: Inventory
+
+  @RelationId((orderProduct: OrderProduct) => orderProduct.toInventory)
+  toInventoryId: string
+
+  @ManyToOne(type => Product, { nullable: true })
+  @Field(type => Product)
+  product: Product
+
+  @RelationId((orderProduct: OrderProduct) => orderProduct.product)
+  productId: string
+
+  @ManyToOne(type => ProductDetail, { nullable: true })
+  @Field(type => ProductDetail)
+  productDetail: ProductDetail
+
+  @RelationId((orderProduct: OrderProduct) => orderProduct.productDetail)
+  productDetailId: string
+
+  @ManyToOne(type => ProductBundle, { nullable: true })
+  @Field(type => ProductBundle)
+  productBundle: ProductBundle
+
+  @RelationId((orderProduct: OrderProduct) => orderProduct.productBundle)
+  productBundleId: string
+
+  @ManyToOne(type => ContactPoint)
+  @Field(type => ContactPoint, { nullable: true })
+  contactPoint?: ContactPoint
+
+  @RelationId((orderProduct: OrderProduct) => orderProduct.contactPoint)
+  contactPointId?: string
+
+  @Column()
+  @Field()
+  batchId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  adjustedBatchId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  batchIdRef: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  adjustedBatchIdRef: string
+
+  @Column()
+  @Field()
+  packingType: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  adjustedPackingType: string
+
+  @Column('float', { nullable: true, default: 1, transformer: roundTransformer })
+  @Field({ nullable: true })
+  packingSize: number
+
+  @Column('int', { nullable: true })
+  @Field({ nullable: true })
+  manufactureYear: number
+
+  @Column('date', { nullable: true })
+  @Field(type => ScalarDate, { nullable: true })
+  manufactureDate: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  uom: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  adjustedUom: string
+
+  @Column('float', { nullable: true, transformer: roundTransformer })
+  @Field({ nullable: true })
+  uomValue: number
+
+  @Column('float', { nullable: true, transformer: roundTransformer })
+  @Field({ nullable: true })
+  adjustedUomValue: number
+
+  @Column('float', { nullable: true, transformer: roundTransformer })
+  @Field({ nullable: true })
+  unpackUomValue: number
+
+  @Column('float', { transformer: roundTransformer })
+  @Field()
+  packQty: number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  adjustedPackQty: number
+
+  @Column('float', { nullable: true, transformer: roundTransformer })
+  @Field({ nullable: true })
+  actualPackQty: number
+
+  @Column('float', { nullable: true, transformer: roundTransformer })
+  @Field({ nullable: true })
+  unpackQty: number
+
+  @Column('float', { nullable: true, transformer: roundTransformer })
+  @Field({ nullable: true })
+  unitPrice: number
+
+  @Column('float', { nullable: true, transformer: roundTransformer })
+  @Field({ nullable: true })
+  adjustedUnitPrice: number
+
+  @Column('float', { nullable: true, transformer: roundTransformer })
+  @Field({ nullable: true })
+  discountAmt: number
+
+  @Column('float', { nullable: true, transformer: roundTransformer })
+  @Field({ nullable: true })
+  taxRate: number
+
+  @Column('float', { nullable: true, transformer: roundTransformer })
+  @Field({ nullable: true })
+  miscAmt: number
+
+  @Column('float', { nullable: true, transformer: roundTransformer })
+  @Field({ nullable: true })
+  palletQty: number
+
+  @Column('float', { nullable: true, transformer: roundTransformer })
+  @Field({ nullable: true })
+  adjustedPalletQty: number
+
+  @Column('float', { nullable: true, transformer: roundTransformer })
+  @Field({ nullable: true })
+  actualPalletQty: number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  totalUomValue: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  adjustedTotalUomValue: string
+
+  @Column({ nullable: true, type: 'float', transformer: roundTransformer })
+  @Field({ nullable: true })
+  releaseQty: number
+
+  @Column({ nullable: true, type: 'float', transformer: roundTransformer })
+  @Field({ nullable: true })
+  releaseUomValue: number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  remark: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  issue: string
+
+  @Column()
+  @Field()
+  status: string
+
+  @CreateDateColumn()
+  @Field()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((orderProduct: OrderProduct) => orderProduct.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((orderProduct: OrderProduct) => orderProduct.updater)
+  updaterId: string
+
+  @Field(type => Float, { nullable: true })
+  remainQty: number
+
+  @Field(type => Float, { nullable: true })
+  remainUomValue: number
+
+  @Field({ nullable: true })
+  remainUomValueWithUom: string
+
+  @Field({ nullable: true })
+  groupType: string
+}

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

@@ -0,0 +1,9 @@
+import { OrderTote } from './order-tote'
+import { OrderToteMutation } from './order-tote-mutation'
+import { OrderToteQuery } from './order-tote-query'
+
+export const entities = [OrderTote]
+export const resolvers = [OrderToteQuery, OrderToteMutation]
+
+export * from './order-tote-mutation'
+export * from './order-tote-query'

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

@@ -0,0 +1,31 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { OrderTote } from './order-tote'
+
+@Resolver(OrderTote)
+export class OrderToteMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteOrderTote(@Arg('name') id: string, @Ctx() context: ResolverContext): Promise<Boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(OrderTote).delete({ domain: { id: domain.id }, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteOrderTotes(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<Boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(OrderTote).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+    return true
+  }
+}

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

@@ -0,0 +1,112 @@
+import { Arg, Ctx, Query, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { buildQuery, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
+import { Tote } from '@things-factory/warehouse-base'
+
+import { OrderToteSeal } from '../order-tote-seal/order-tote-seal'
+import { ReleaseGood } from '../release-good/release-good'
+import { OrderTote } from './order-tote'
+import { OrderToteList } from './order-tote-types'
+
+@Resolver(OrderTote)
+export class OrderToteQuery {
+  @Query(returns => OrderToteList)
+  async orderTotes(
+    @Ctx() context: ResolverContext,
+    @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<OrderToteList> {
+    try {
+      const { domain } = context.state
+
+      const releaseGoodNoParam = filters.find(item => item.name === 'releaseGoodNo')
+
+      const queryBuilder = await getRepository(OrderTote).createQueryBuilder()
+      buildQuery(queryBuilder, { filters, pagination, sortings }, context)
+
+      queryBuilder
+        .leftJoinAndSelect('OrderTote.domain', 'Domain')
+        .leftJoinAndSelect('OrderTote.releaseGood', 'ReleaseGood')
+        .leftJoinAndSelect('OrderTote.tote', 'Tote')
+        .leftJoinAndSelect('OrderTote.updater', 'Updater')
+        .where('Domain.id = :domainId', { domainId: domain.id })
+
+      if (releaseGoodNoParam) {
+        filters.splice(
+          filters.findIndex(item => item.name == 'releaseGoodNo'),
+          1
+        )
+        queryBuilder.andWhere('ReleaseGood.name = :rgName', { rgName: releaseGoodNoParam.value })
+      }
+
+      let [items, total] = await queryBuilder.getManyAndCount()
+
+      let orderToteIds: string[] = items.map(itm => itm.id)
+
+      let orderToteSeals: OrderToteSeal[] = await getRepository(OrderToteSeal).find({
+        where: { orderTote: In(orderToteIds) }
+      })
+
+      items = items.map((itm: OrderTote) => {
+        return {
+          ...itm,
+          orderToteSeals: orderToteSeals.filter(seal => seal.orderToteId == itm.id)
+        }
+      })
+
+      return { items, total }
+    } catch (e) {
+      throw new Error(e)
+    }
+  }
+
+  @Query(returns => OrderTote)
+  async orderTote(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<OrderTote> {
+    const { domain } = context.state
+
+    return await getRepository(OrderTote).findOne({
+      where: { domain: { id: domain.id }, id },
+      relations: ['domain', 'releaseGood', 'tote', 'updater']
+    })
+  }
+
+  @Query(returns => Boolean)
+  async checkOrderTote(
+    @Arg('name') name: string,
+    @Arg('orderNo') orderNo: string,
+    @Ctx() context: ResolverContext
+  ): Promise<Boolean> {
+    const { domain } = context.state
+    let foundOrder = await getRepository(ReleaseGood).findOne({
+      where: { name: orderNo, domain: { id: domain.id } },
+      relations: ['bizplace']
+    })
+    let scannedTote = await getRepository(Tote).findOne({ where: { name, bizplace: { id: foundOrder.bizplace.id } } })
+
+    let foundOrderTote = await getRepository(OrderTote).findOne({
+      where: { domain: { id: domain.id }, releaseGood: { id: foundOrder.id }, name },
+      relations: ['domain', 'releaseGood', 'tote', 'updater']
+    })
+
+    if (!foundOrderTote && scannedTote) {
+      let executingOrderTote = await getRepository(OrderTote).find({
+        where: { tote: scannedTote },
+        relations: ['releaseGood']
+      })
+
+      executingOrderTote = executingOrderTote.filter(itm => itm.releaseGood.status !== 'DONE')
+
+      if (executingOrderTote && executingOrderTote.length > 0) {
+        throw new Error(`Current tote is used in another RO (${executingOrderTote[0].releaseGood.name})`)
+      }
+    }
+
+    if (foundOrderTote?.closedDate) {
+      return true
+    } else {
+      return false
+    }
+  }
+}

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

@@ -0,0 +1,47 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+
+import { ObjectRef } from '@things-factory/shell'
+
+import { OrderTote } from './order-tote'
+
+@ObjectType()
+export class OrderToteList {
+  @Field(type => [OrderTote], { nullable: true })
+  items: OrderTote[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class NewOrderTote {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  releaseGood: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  tote: ObjectRef
+}
+
+@InputType()
+export class OrderTotePatch {
+  @Field({ nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  releaseGood: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  tote: ObjectRef
+}

package/server/service/order-tote/order-tote.ts

@@ -0,0 +1,73 @@
+import { Field, ObjectType } from 'type-graphql'
+import {
+  Column,
+  Entity,
+  Index,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { Tote } from '@things-factory/warehouse-base'
+
+import { OrderToteSeal } from '../order-tote-seal/order-tote-seal'
+import { ReleaseGood } from '../release-good/release-good'
+
+@Entity()
+@Index('ix_order_tote_0', (orderTote: OrderTote) => [orderTote.id], { unique: true })
+@ObjectType()
+export class OrderTote {
+  @PrimaryGeneratedColumn('uuid')
+  @Field()
+  id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain: Domain
+
+  @RelationId((orderTote: OrderTote) => orderTote.domain)
+  domainId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @ManyToOne(type => ReleaseGood)
+  @Field(type => ReleaseGood)
+  releaseGood?: ReleaseGood
+
+  @RelationId((orderTote: OrderTote) => orderTote.releaseGood)
+  releaseGoodId: string
+
+  @ManyToOne(type => Tote)
+  @Field(type => Tote, { nullable: true })
+  tote?: Tote
+
+  @RelationId((orderTote: OrderTote) => orderTote.tote)
+  toteId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  closedDate?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((orderTote: OrderTote) => orderTote.updater)
+  updaterId: string
+
+  @OneToMany(type => OrderToteSeal, orderToteSeal => orderToteSeal.orderTote, { nullable: true })
+  @Field(type => [OrderToteSeal], { nullable: true })
+  orderToteSeals?: OrderToteSeal[]
+}

package/server/service/order-tote-item/index.ts

@@ -0,0 +1,9 @@
+import { OrderToteItem } from './order-tote-item'
+import { OrderToteItemMutation } from './order-tote-item-mutation'
+import { OrderToteItemQuery } from './order-tote-item-query'
+
+export const entities = [OrderToteItem]
+export const resolvers = [OrderToteItemQuery, OrderToteItemMutation]
+
+export * from './order-tote-item-mutation'
+export * from './order-tote-item-query'

package/server/service/order-tote-item/order-tote-item-mutation.ts

@@ -0,0 +1,31 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { OrderToteItem } from './order-tote-item'
+
+@Resolver(OrderToteItem)
+export class OrderToteItemMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteOrderToteItem(@Arg('name') id: string, @Ctx() context: ResolverContext): Promise<Boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(OrderToteItem).delete({ domain: { id: domain.id }, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteOrderToteItems(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<Boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(OrderToteItem).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+    return true
+  }
+}