@things-factory/sales-base 4.3.2 → 4.4.0-alpha.0

package/server/service/draft-release-good/draft-release-good.ts

@@ -1,270 +0,0 @@
-import { Field, ID, Float, ObjectType, registerEnumType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  JoinColumn,
-  ManyToOne,
-  OneToMany,
-  OneToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-
-import { Attachment } from '@things-factory/attachment-base'
-import { User } from '@things-factory/auth-base'
-import { Bizplace, ContactPoint } from '@things-factory/biz-base'
-import { config } from '@things-factory/env'
-import { Domain } from '@things-factory/shell'
-
-import { OrderProduct, ReleaseGood, ShippingOrder, ShippingOrderInfo } from '../'
-import { ReleaseOrderType } from '../../constants'
-
-const ORMCONFIG = config.get('ormconfig', {})
-const DATABASE_TYPE = ORMCONFIG.type
-
-// export enum DraftReleaseGoodStatus {
-//   STATUS_A = 'STATUS_A',
-//   STATUS_B = 'STATUS_B'
-// }
-
-// registerEnumType(DraftReleaseGoodStatus, {
-//   name: 'DraftReleaseGoodStatus',
-//   description: 'state enumeration of a draftReleaseGood'
-// })
-
-@Entity()
-@Index(
-  'ix_draft_release_good_0',
-  (draftReleaseGood: DraftReleaseGood) => [draftReleaseGood.domain, draftReleaseGood.name],
-  { unique: true }
-)
-@ObjectType({ description: 'Entity for DraftReleaseGood' })
-export class DraftReleaseGood {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain, { nullable: true })
-  domain: Domain
-
-  @RelationId((draftReleaseGood: DraftReleaseGood) => draftReleaseGood.domain)
-  domainId: string
-
-  @ManyToOne(type => Bizplace)
-  @Field(type => Bizplace, { nullable: true })
-  bizplace: Bizplace
-
-  @RelationId((draftReleaseGood: DraftReleaseGood) => draftReleaseGood.bizplace)
-  bizplaceId: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  name: string
-
-  @OneToOne(type => ReleaseGood)
-  @JoinColumn()
-  @Field(type => ReleaseGood, { nullable: true })
-  releaseGood: ReleaseGood
-
-  @RelationId((draftReleaseGood: DraftReleaseGood) => draftReleaseGood.releaseGood)
-  releaseGoodId: string
-
-  @OneToOne(type => ShippingOrder)
-  @JoinColumn()
-  @Field(type => ShippingOrder, { nullable: true })
-  shippingOrder: ShippingOrder
-
-  @RelationId((releaseGood: ReleaseGood) => releaseGood.shippingOrder)
-  shippingOrderId: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  collectionOrderNo: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  truckNo: string
-
-  @Column({
-    type:
-      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
-        ? 'enum'
-        : DATABASE_TYPE == 'oracle'
-          ? 'varchar2'
-          : 'smallint',
-    enum: ReleaseOrderType,
-    default: ReleaseOrderType.B2B
-  })
-  @Field()
-  type: ReleaseOrderType
-
-  @Column({ default: false })
-  @Field()
-  exportOption: Boolean
-
-  @Column({ default: false })
-  @Field()
-  courierOption: Boolean
-
-  @Column({ default: false })
-  @Field()
-  packingOption: Boolean
-
-  @Column()
-  @Field()
-  ownTransport: Boolean
-
-  @Field(type => ShippingOrderInfo, { nullable: true })
-  shippingOrderInfo?: ShippingOrderInfo
-
-  @OneToMany(type => OrderProduct, orderProduct => orderProduct.draftReleaseGood)
-  @Field(type => [OrderProduct], { nullable: true })
-  orderProducts: OrderProduct[]
-
-  @Column()
-  @Field()
-  status: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  refNo: String
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  refNo2: String
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  refNo3: String
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  releaseDate: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  remark: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  marketplaceOrderStatus: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  billingAddress: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  pickupAddress: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  pickupTime: Date
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  handoverType: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  dropoffAddress: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  deliveryAddress1: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  deliveryAddress2: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  deliveryAddress3: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  deliveryAddress4: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  deliveryAddress5: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  attentionTo: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  attentionCompany: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  city: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  state: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  postalCode: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  country: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  phone1: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  phone2: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  email: string
-
-  @ManyToOne(type => ContactPoint)
-  @Field(type => ContactPoint, { nullable: true })
-  deliverTo: ContactPoint
-
-  @RelationId((draftReleaseGood: DraftReleaseGood) => draftReleaseGood.deliverTo)
-  deliverToId: string
-
-  @Field(type => [Attachment], { nullable: true })
-  attachment?: Attachment[]
-
-  @CreateDateColumn()
-  @Field()
-  createdAt: Date
-
-  @UpdateDateColumn()
-  @Field()
-  updatedAt: Date
-
-  @ManyToOne(type => User)
-  @Field(type => User, { nullable: true })
-  creator: User
-
-  @RelationId((draftReleaseGood: DraftReleaseGood) => draftReleaseGood.creator)
-  creatorId: string
-
-  @ManyToOne(type => User)
-  @Field(type => User, { nullable: true })
-  updater: User
-
-  @RelationId((draftReleaseGood: DraftReleaseGood) => draftReleaseGood.updater)
-  updaterId: string
-
-  @Field()
-  computedStatus: string
-}

package/server/service/draft-release-good/index.ts

@@ -1,9 +0,0 @@
-import { DraftReleaseGood } from './draft-release-good'
-import { DraftReleaseGoodQuery } from './draft-release-good-query'
-import { DraftReleaseGoodMutation } from './draft-release-good-mutation'
-
-export const entities = [DraftReleaseGood]
-export const resolvers = [DraftReleaseGoodQuery, DraftReleaseGoodMutation]
-
-export * from './draft-release-good-mutation'
-export * from './draft-release-good-query'

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,30 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, In } from 'typeorm'
-
-import { Domain } from '@things-factory/shell'
-
-import { OrderTote } from './order-tote'
-
-@Resolver(OrderTote)
-export class OrderToteMutation {
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deleteOrderTote(@Arg('name') id: string, @Ctx() context: any): Promise<Boolean> {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
-
-    await tx.getRepository(OrderTote).delete({ domain, id })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deleteOrderTotes(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<Boolean> {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
-
-    await tx.getRepository(OrderTote).delete({
-      domain,
-      id: In(ids)
-    })
-    return true
-  }
-}

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

@@ -1,114 +0,0 @@
-import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository, In, IsNull } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { ReleaseGood } from '../release-good/release-good'
-import { Tote } from '@things-factory/warehouse-base'
-import { buildQuery, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
-import { Bizplace } from '@things-factory/biz-base'
-
-import { OrderTote } from './order-tote'
-import { OrderToteList } from './order-tote-types'
-import { OrderToteSeal } from '../order-tote-seal/order-tote-seal'
-
-@Resolver(OrderTote)
-export class OrderToteQuery {
-  @Query(returns => OrderToteList)
-  async orderTotes(
-    @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<OrderToteList> {
-    try {
-      const { domain }: { domain: 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: any): Promise<OrderTote> {
-    const { domain }: { domain: Domain } = context.state
-
-    return await getRepository(OrderTote).findOne({
-      where: { domain, id },
-      relations: ['domain', 'releaseGood', 'tote', 'updater']
-    })
-  }
-
-  @Query(returns => Boolean)
-  async checkOrderTote(
-    @Arg('name') name: string,
-    @Arg('orderNo') orderNo: string,
-    @Ctx() context: any
-  ): Promise<Boolean> {
-    const { domain }: { domain: Domain } = context.state
-    let foundOrder = await getRepository(ReleaseGood).findOne({
-      where: { name: orderNo, domain },
-      relations: ['bizplace']
-    })
-    let scannedTote = await getRepository(Tote).findOne({ where: { name, bizplace: foundOrder.bizplace } })
-
-    let foundOrderTote = await getRepository(OrderTote).findOne({
-      where: { domain, releaseGood: foundOrder, 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,62 +0,0 @@
-import { Field, ObjectType } from 'type-graphql'
-import { Column, Entity, Index, ManyToOne, 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 { ReleaseGood } from '../release-good/release-good'
-import { OrderToteSeal } from '../order-tote-seal/order-tote-seal'
-
-@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()
-  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({ nullable: true })
-  updater?: User
-
-  @RelationId((orderTote: OrderTote) => orderTote.updater)
-  updaterId: string
-
-  @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,30 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, In } from 'typeorm'
-
-import { Domain } from '@things-factory/shell'
-
-import { OrderToteItem } from './order-tote-item'
-
-@Resolver(OrderToteItem)
-export class OrderToteItemMutation {
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deleteOrderToteItem(@Arg('name') id: string, @Ctx() context: any): Promise<Boolean> {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
-
-    await tx.getRepository(OrderToteItem).delete({ domain, id })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deleteOrderToteItems(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<Boolean> {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
-
-    await tx.getRepository(OrderToteItem).delete({
-      domain,
-      id: In(ids)
-    })
-    return true
-  }
-}

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

@@ -1,88 +0,0 @@
-import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { OrderProduct } from '../order-product/order-product'
-import { OrderTote } from '../order-tote/order-tote'
-import { buildQuery, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
-import { OrderToteItem } from './order-tote-item'
-import { OrderToteItemList } from './order-tote-item-types'
-import { Tote } from '@things-factory/warehouse-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { ReleaseGood } from '../release-good/release-good'
-import { ProductInput } from '../invoice-product/invoice-product-types'
-
-@Resolver(OrderToteItem)
-export class OrderToteItemQuery {
-  @Query(returns => OrderToteItemList)
-  async orderToteItems(
-    @Ctx() context: any,
-    @Arg('toteNo', type => String) toteNo: String,
-    @Arg('orderNo', type => String) orderNo: String,
-    @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
-  ): Promise<OrderToteItemList> {
-    try {
-      const { domain }: { domain: Domain } = context.state
-
-      const foundOrder: ReleaseGood = await getRepository(ReleaseGood).findOne({
-        where: { name: orderNo, domain }
-      })
-
-      const queryBuilder = getRepository(OrderToteItem).createQueryBuilder()
-      buildQuery(queryBuilder, { sortings }, context)
-
-      queryBuilder
-        .select('OrderToteItem.id', 'id')
-        .addSelect('OrderToteItem.name', 'name')
-        .addSelect('OrderProduct.id', 'orderProductId')
-        .addSelect('OrderProduct.name', 'orderProductName')
-        .addSelect('Domain.id', 'domainId')
-        .addSelect('Domain.name', 'domainName')
-        .addSelect('SUM(OrderToteItem.qty)', 'pickedQty')
-        .addSelect('Product.id', 'productId')
-        .addSelect('Product.sku', 'productSku')
-        .addSelect('Product.packingType', 'packingType')
-        .leftJoin('OrderToteItem.domain', 'Domain')
-        .leftJoin('OrderToteItem.orderProduct', 'OrderProduct')
-        .leftJoin('OrderProduct.product', 'Product')
-        .leftJoin('OrderToteItem.orderTote', 'OrderTote')
-        .where('"OrderTote"."release_good_id" = :foundOrderId', { foundOrderId: foundOrder.id })
-        .andWhere('Domain.id = :domainId', { domainId: domain.id })
-        .andWhere('"OrderTote"."name" = :toteName', { toteName: toteNo })
-        .groupBy('Product.id')
-        .addGroupBy('OrderToteItem.id')
-        .addGroupBy('Domain.id')
-        .addGroupBy('OrderProduct.id')
-
-      const items = await queryBuilder.getRawMany()
-
-      return {
-        items: items.map(itm => {
-          return {
-            ...itm,
-            orderProduct: {
-              id: itm.orderProductId,
-              name: itm.orderProductName,
-              product: { id: itm.productId, sku: itm.productSku, packingType: itm.packingType }
-            },
-            domain: { id: itm.domainId, name: itm.domainName },
-            qty: itm.pickedQty
-          }
-        }),
-        total: items.length
-      }
-    } catch (e) {
-      throw new Error(e)
-    }
-  }
-
-  @Query(returns => OrderToteItem)
-  async orderToteItem(@Arg('id') id: string, @Ctx() context: any): Promise<OrderToteItem> {
-    const { domain }: { domain: Domain } = context.state
-
-    return await getRepository(OrderToteItem).findOne({
-      where: { domain, id },
-      relations: ['domain', 'orderProduct', 'orderInventory', 'orderTote', 'updater']
-    })
-  }
-}