@things-factory/sales-base 8.0.0-beta.0 → 8.0.0-beta.2

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

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

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

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

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

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

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

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

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