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

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

@@ -1,82 +0,0 @@
-import { Arg, Ctx, Query, Resolver } from 'type-graphql'
-
-import { buildQuery, getRepository, Sorting } from '@things-factory/shell'
-
-import { ReleaseGood } from '../release-good/release-good'
-import { OrderToteItem } from './order-tote-item'
-import { OrderToteItemList } from './order-tote-item-types'
-
-@Resolver(OrderToteItem)
-export class OrderToteItemQuery {
-  @Query(returns => OrderToteItemList)
-  async orderToteItems(
-    @Ctx() context: ResolverContext,
-    @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 } = context.state
-
-      const foundOrder: ReleaseGood = await getRepository(ReleaseGood).findOne({
-        where: { domain: { id: domain.id }, name: orderNo }
-      })
-
-      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: ResolverContext): Promise<OrderToteItem> {
-    const { domain } = context.state
-
-    return await getRepository(OrderToteItem).findOne({
-      where: { domain: { id: domain.id }, id },
-      relations: ['domain', 'orderProduct', 'orderInventory', 'orderTote', 'updater']
-    })
-  }
-}

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

@@ -1,56 +0,0 @@
-import { Field, InputType, Int, ObjectType } from 'type-graphql'
-
-import { ObjectRef } from '@things-factory/shell'
-
-import { OrderToteItem } from './order-tote-item'
-
-@ObjectType()
-export class OrderToteItemList {
-  @Field(type => [OrderToteItem], { nullable: true })
-  items: OrderToteItem[]
-
-  @Field(type => Int, { nullable: true })
-  total: number
-}
-
-@InputType()
-export class NewOrderToteItem {
-  @Field({ nullable: true })
-  name: string
-
-  @Field({ nullable: true })
-  description: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  orderProduct: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  orderInventory: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  orderTote: ObjectRef
-
-  @Field(type => Int)
-  qty: number
-}
-
-@InputType()
-export class OrderToteItemPatch {
-  @Field({ nullable: true })
-  id: string
-
-  @Field({ nullable: true })
-  name: string
-
-  @Field({ nullable: true })
-  description: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  orderProduct: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  orderTote: ObjectRef
-
-  @Field(type => Int)
-  qty: number
-}

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

@@ -1,72 +0,0 @@
-import { Field, Int, 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 { OrderTote } from '../order-tote/order-tote'
-import { OrderProduct } from '../order-product/order-product'
-import { OrderInventory } from '../order-inventory/order-inventory'
-
-@Entity()
-@Index('ix_order_tote_item_0', (orderToteItem: OrderToteItem) => [orderToteItem.name], { unique: true })
-@ObjectType()
-export class OrderToteItem {
-  @PrimaryGeneratedColumn('uuid')
-  @Field()
-  id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain: Domain
-
-  @RelationId((orderToteItem: OrderToteItem) => orderToteItem.domain)
-  domainId: string
-
-  @Column()
-  @Field()
-  name: string
-
-  @ManyToOne(type => OrderInventory)
-  @Field(type => OrderInventory)
-  orderInventory?: OrderInventory
-
-  @RelationId((orderToteItem: OrderToteItem) => orderToteItem.orderInventory)
-  orderInventoryId: string
-
-  @ManyToOne(type => OrderProduct)
-  @Field(type => OrderProduct)
-  orderProduct?: OrderProduct
-
-  @RelationId((orderToteItem: OrderToteItem) => orderToteItem.orderProduct)
-  orderProductId: string
-
-  @ManyToOne(type => OrderTote)
-  @Field(type => OrderTote, { nullable: true })
-  orderTote?: OrderTote
-
-  @RelationId((orderToteItem: OrderToteItem) => orderToteItem.orderTote)
-  orderToteId: string
-
-  @Column('int')
-  @Field({ nullable: true })
-  qty?: number
-
-  @Field({ nullable: true })
-  sku?: string
-
-  @Field({ nullable: true })
-  packingType?: string
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt: Date
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field({ nullable: true })
-  updater: User
-
-  @RelationId((orderToteItem: OrderTote) => orderToteItem.updater)
-  updaterId: string
-}

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

@@ -1,9 +0,0 @@
-import { OrderToteSeal } from './order-tote-seal'
-import { OrderToteSealMutation } from './order-tote-seal-mutation'
-import { OrderToteSealQuery } from './order-tote-seal-query'
-
-export const entities = [OrderToteSeal]
-export const resolvers = [OrderToteSealQuery, OrderToteSealMutation]
-
-export * from './order-tote-seal-mutation'
-export * from './order-tote-seal-query'

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

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

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

@@ -1,59 +0,0 @@
-import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-
-import { User } from '@things-factory/auth-base'
-import { buildQuery, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
-
-import { OrderTote } from '../order-tote/order-tote'
-import { OrderToteSeal } from './order-tote-seal'
-import { OrderToteSealList } from './order-tote-seal-types'
-
-@Resolver(OrderToteSeal)
-export class OrderToteSealQuery {
-  @Query(returns => OrderToteSealList)
-  async orderToteSeals(
-    @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<OrderToteSealList> {
-    const { domain } = context.state
-
-    const queryBuilder = getRepository(OrderToteSeal).createQueryBuilder()
-    buildQuery(queryBuilder, { filters, pagination, sortings }, context)
-
-    queryBuilder
-      .leftJoinAndSelect('OrderToteSeal.domain', 'Domain')
-      .leftJoinAndSelect('OrderToteSeal.orderTote', 'OrderTote')
-      .leftJoinAndSelect('OrderToteSeal.updater', 'Updater')
-      .where('Domain.id = :domainId', { domainId: domain.id })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @Query(returns => OrderToteSeal)
-  async orderToteSeal(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<OrderToteSeal> {
-    const { domain } = context.state
-
-    return await getRepository(OrderToteSeal).findOne({
-      where: { domain: { id: domain.id }, name },
-      relations: ['domain', 'orderTote', 'updater']
-    })
-  }
-
-  @FieldResolver()
-  async domain(@Root() orderToteSeal: OrderToteSeal) {
-    return await getRepository(Domain).findOneBy({ id: orderToteSeal.domainId })
-  }
-
-  @FieldResolver()
-  async updater(@Root() orderToteSeal: OrderToteSeal) {
-    return await getRepository(User).findOneBy({ id: orderToteSeal.updaterId })
-  }
-
-  @FieldResolver()
-  async orderTote(@Root() orderToteSeal: OrderToteSeal) {
-    return await getRepository(OrderTote).findOneBy({ id: orderToteSeal.orderToteId })
-  }
-}

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

@@ -1,41 +0,0 @@
-import { Field, InputType, Int, ObjectType } from 'type-graphql'
-
-import { ObjectRef } from '@things-factory/shell'
-
-import { OrderToteSeal } from './order-tote-seal'
-
-@ObjectType()
-export class OrderToteSealList {
-  @Field(type => [OrderToteSeal], { nullable: true })
-  items: OrderToteSeal[]
-
-  @Field(type => Int, { nullable: true })
-  total: number
-}
-
-@InputType()
-export class NewOrderToteSeal {
-  @Field({ nullable: true })
-  name: string
-
-  @Field({ nullable: true })
-  description: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  orderTote: ObjectRef
-}
-
-@InputType()
-export class OrderToteSealPatch {
-  @Field({ nullable: true })
-  id: string
-
-  @Field({ nullable: true })
-  name: string
-
-  @Field({ nullable: true })
-  description: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  orderTote: ObjectRef
-}

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

@@ -1,46 +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 { OrderTote } from '../order-tote/order-tote'
-
-@Entity()
-@Index('ix_order_tote_seal_0', (orderToteSeal: OrderToteSeal) => [orderToteSeal.name], { unique: true })
-@ObjectType()
-export class OrderToteSeal {
-  @PrimaryGeneratedColumn('uuid')
-  @Field()
-  id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain: Domain
-
-  @RelationId((orderToteSeal: OrderToteSeal) => orderToteSeal.domain)
-  domainId: string
-
-  @Column()
-  @Field()
-  name: string
-
-  @ManyToOne(type => OrderTote)
-  @Field(type => OrderTote, { nullable: true })
-  orderTote?: OrderTote
-
-  @RelationId((orderToteSeal: OrderToteSeal) => orderToteSeal.orderTote)
-  orderToteId: string
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt: Date
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field({ nullable: true })
-  updater: User
-
-  @RelationId((orderToteSeal: OrderToteSeal) => orderToteSeal.updater)
-  updaterId: string
-}

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

@@ -1,9 +0,0 @@
-import { OrderVas } from './order-vas'
-import { OrderVasQuery } from './order-vas-query'
-import { OrderVasMutation } from './order-vas-mutation'
-
-export const entities = [OrderVas]
-export const resolvers = [OrderVasQuery, OrderVasMutation]
-
-export * from './order-vas-mutation'
-export * from './order-vas-query'

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

@@ -1,20 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-
-import { OrderVasPatch } from '../'
-import { OrderVas } from './order-vas'
-
-@Resolver(OrderVas)
-export class OrderVasMutation {
-  @Directive('@transaction')
-  @Mutation(returns => OrderVas)
-  async updateOrderVas(
-    @Arg('id') id: string,
-    @Arg('patch', type => OrderVasPatch) patch: OrderVasPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<OrderVas> {
-    const { tx, domain } = context.state
-
-    let orderVas = await tx.getRepository(OrderVas).findOneBy({ id })
-    return await tx.getRepository(OrderVas).save({ orderVas, ...patch })
-  }
-}

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

@@ -1,72 +0,0 @@
-import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-
-import { User } from '@things-factory/auth-base'
-import { convertListParams, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
-
-import { OrderVasList } from '../'
-import { OrderVas } from './order-vas'
-
-@Resolver(OrderVas)
-export class OrderVasQuery {
-  @Query(returns => OrderVasList)
-  async orderVass(
-    @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<OrderVasList> {
-    const convertedParams = convertListParams({ filters, pagination, sortings })
-    const [items, total] = await getRepository(OrderVas).findAndCount({
-      ...convertedParams,
-      relations: [
-        'domain',
-        'arrivalNotice',
-        'releaseGood',
-        'vasOrder',
-        'shippingOrder',
-        'vas',
-        'inventory',
-        'creator',
-        'updater'
-      ]
-    })
-    return { items, total }
-  }
-
-  @Query(returns => OrderVas)
-  async orderVas(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<OrderVas> {
-    const { domain } = context.state
-
-    return await getRepository(OrderVas).findOne({
-      where: {
-        domain: { id: domain.id },
-        name
-      },
-      relations: [
-        'domain',
-        'arrivalNotice',
-        'releaseGood',
-        'vasOrder',
-        'shippingOrder',
-        'vas',
-        'inventory',
-        'creator',
-        'updater'
-      ]
-    })
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() orderVas: OrderVas): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: orderVas.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() orderVas: OrderVas): Promise<User> {
-    return await getRepository(User).findOneBy({ id: orderVas.creatorId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() orderVas: OrderVas): Promise<User> {
-    return await getRepository(User).findOneBy({ id: orderVas.updaterId })
-  }
-}

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

@@ -1,159 +0,0 @@
-import { ObjectRef } from '@things-factory/shell'
-import { Field, Float, InputType, Int, ObjectType } from 'type-graphql'
-import { OrderVas } from './order-vas'
-
-@ObjectType()
-export class OrderVasList {
-  @Field(type => [OrderVas], { nullable: true })
-  items: OrderVas[]
-
-  @Field(type => Int, { nullable: true })
-  total: number
-}
-
-@InputType()
-export class NewOrderVas {
-  @Field({ nullable: true })
-  name: string
-
-  @Field(type => Int, { nullable: true })
-  set: number
-
-  @Field({ nullable: true })
-  targetType: string
-
-  @Field({ nullable: true })
-  targetBatchId: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  targetProduct: ObjectRef
-
-  @Field({ nullable: true })
-  otherTarget: string
-
-  @Field(type => Int, { nullable: true })
-  qty: number
-
-  @Field(type => Float, { nullable: true })
-  uomValue: number
-
-  @Field({ nullable: true })
-  batchId: string
-
-  @Field({ nullable: true })
-  productName: string
-
-  @Field({ nullable: true })
-  packingType: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  arrivalNotice: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  releaseGood: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  shippingOrder: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  transferOrder: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  retailReplenishmentOrder: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  inventory: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  vas: ObjectRef
-
-  @Field({ nullable: true })
-  type: string
-
-  @Field({ nullable: true })
-  operationGuide: string
-
-  @Field({ nullable: true })
-  remark: string
-
-  @Field({ nullable: true })
-  description: string
-
-  @Field({ nullable: true })
-  status: string
-}
-
-@InputType()
-export class OrderVasPatch {
-  @Field({ nullable: true })
-  id: string
-
-  @Field({ nullable: true })
-  name: string
-
-  @Field(type => Int, { nullable: true })
-  set: number
-
-  @Field({ nullable: true })
-  targetType: string
-
-  @Field({ nullable: true })
-  targetBatchId: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  targetProduct: ObjectRef
-
-  @Field({ nullable: true })
-  otherTarget: string
-
-  @Field(type => Int, { nullable: true })
-  qty: number
-
-  @Field(type => Float, { nullable: true })
-  uomValue: number
-
-  @Field({ nullable: true })
-  batchId: string
-
-  @Field({ nullable: true })
-  productName: string
-
-  @Field({ nullable: true })
-  packingType: string
-
-  @Field(type => ObjectRef, { nullable: true })
-  arrivalNotice: 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 })
-  transferOrder: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  inventory: ObjectRef
-
-  @Field(type => ObjectRef, { nullable: true })
-  vas: ObjectRef
-
-  @Field({ nullable: true })
-  operationGuide: string
-
-  @Field({ nullable: true })
-  remark: string
-
-  @Field({ nullable: true })
-  description: string
-
-  @Field({ nullable: true })
-  status: string
-
-  @Field({ nullable: true })
-  cuFlag: string
-}