@things-factory/sales-base 8.0.3 → 8.0.6

package/server/service/reverse-kitting-order-inventory/reverse-kitting-order-inventory.ts

@@ -1,143 +0,0 @@
-import { Field, ID, ObjectType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { Product } from '@things-factory/product-base'
-import { Domain, roundTransformer } from '@things-factory/shell'
-import { Inventory } from '@things-factory/warehouse-base'
-
-import { ReverseKittingOrder } from '../reverse-kitting-order/reverse-kitting-order'
-import { Vas } from '../vas/vas'
-
-@Entity()
-@Index(
-  'ix_reverse_kitting_order_inventory_0',
-  (reverseKittingOrderInventory: ReverseKittingOrderInventory) => [
-    reverseKittingOrderInventory.domain,
-    reverseKittingOrderInventory.name
-  ],
-  { unique: true }
-)
-@ObjectType({ description: 'Entity for ReverseKittingOrderInventory' })
-export class ReverseKittingOrderInventory {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain?: Domain
-
-  @RelationId((reverseKittingOrderInventory: ReverseKittingOrderInventory) => reverseKittingOrderInventory.domain)
-  domainId?: string
-
-  @ManyToOne(type => Bizplace, { nullable: true })
-  bizplace: Bizplace
-
-  @RelationId((reverseKittingOrderInventory: ReverseKittingOrderInventory) => reverseKittingOrderInventory.bizplace)
-  bizplaceId?: string
-
-  @Column()
-  @Field()
-  name: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  batchId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  set?: number
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  qty?: number
-
-  @Column('float', { nullable: true, transformer: roundTransformer })
-  @Field({ nullable: true })
-  uomValue?: number
-
-  @ManyToOne(type => ReverseKittingOrder)
-  @Field(type => ReverseKittingOrder)
-  reverseKittingOrder: ReverseKittingOrder
-
-  @RelationId(
-    (reverseKittingOrderInventory: ReverseKittingOrderInventory) => reverseKittingOrderInventory.reverseKittingOrder
-  )
-  reverseKittingOrderId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  operationGuide?: string
-
-  @ManyToOne(type => Inventory)
-  @Field(type => Inventory)
-  inventory?: Inventory
-
-  @RelationId((reverseKittingOrderInventory: ReverseKittingOrderInventory) => reverseKittingOrderInventory.inventory)
-  inventoryId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  remark?: string
-
-  @Column()
-  @Field()
-  status: string
-
-  @Field({ nullable: true })
-  targetType?: string
-
-  @Field({ nullable: true })
-  targetBatchId?: string
-
-  @ManyToOne(type => Product, { nullable: true })
-  @Field(type => Product, { nullable: true })
-  targetProduct?: Product
-
-  @ManyToOne(type => Vas, { nullable: true })
-  @Field(type => Vas, { nullable: true })
-  vas?: Vas
-
-  @Field({ nullable: true })
-  otherTarget?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  issue?: string
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((reverseKittingOrderInventory: ReverseKittingOrderInventory) => reverseKittingOrderInventory.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((reverseKittingOrderInventory: ReverseKittingOrderInventory) => reverseKittingOrderInventory.updater)
-  updaterId?: string
-}

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

@@ -1,9 +0,0 @@
-import { ShippingOrder } from './shipping-order'
-import { ShippingOrderMutation } from './shipping-order-mutation'
-import { ShippingOrderQuery } from './shipping-order-query'
-
-export const entities = [ShippingOrder]
-export const resolvers = [ShippingOrderQuery, ShippingOrderMutation]
-
-export * from './shipping-order-mutation'
-export * from './shipping-order-query'

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

@@ -1,61 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-import { v4 as uuidv4 } from 'uuid'
-
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-
-import { NewShippingOrder, ShippingOrderPatch } from '../'
-import { ShippingOrder } from './shipping-order'
-
-@Resolver(ShippingOrder)
-export class ShippingOrderMutation {
-  @Directive('@transaction')
-  @Mutation(returns => ShippingOrder)
-  async createShippingOrder(
-    @Arg('shippingOrder', type => NewShippingOrder) shippingOrder: NewShippingOrder,
-    @Ctx() context: ResolverContext
-  ): Promise<ShippingOrder> {
-    const { tx } = context.state
-
-    const repository = tx.getRepository(ShippingOrder)
-    const newShippingOrder = {
-      id: uuidv4(),
-      ...shippingOrder
-    }
-
-    return await repository.save(newShippingOrder)
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => ShippingOrder)
-  async updateShippingOrder(
-    @Arg('name') name: string,
-    @Arg('patch', type => ShippingOrderPatch) patch: ShippingOrderPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<ShippingOrder> {
-    const { tx, domain, user } = context.state
-
-    const shippingOrder = await tx.getRepository(ShippingOrder).findOne({
-      where: {
-        domain: { id: domain.id },
-        name,
-        bizplace: { id: In(await getPermittedBizplaceIds(domain, user)) }
-      }
-    })
-
-    return await tx.getRepository(ShippingOrder).save({
-      ...shippingOrder,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deleteShippingOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { tx, domain } = context.state
-
-    await tx.getRepository(ShippingOrder).delete({ domain: { id: domain.id }, name })
-    return true
-  }
-}

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

@@ -1,61 +0,0 @@
-import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { convertListParams, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
-
-import { ShippingOrderList } from '../'
-import { ShippingOrder } from './shipping-order'
-
-@Resolver(ShippingOrder)
-export class ShippingOrderQuery {
-  @Query(returns => ShippingOrderList)
-  async shippingOrders(
-    @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<ShippingOrderList> {
-    const { domain, user } = context.state
-
-    const convertedParams = convertListParams({ filters, pagination, sortings })
-    convertedParams.where.bizplace = In(await getPermittedBizplaceIds(domain, user))
-
-    const [items, total] = await getRepository(ShippingOrder).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'bizplace', 'creator', 'updater']
-    })
-
-    return { items, total }
-  }
-
-  @Query(returns => ShippingOrder)
-  async shippingOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ShippingOrder> {
-    const { domain, user } = context.state
-
-    return await getRepository(ShippingOrder).findOne({
-      where: {
-        domain: { id: domain.id },
-        name,
-        bizplace: { id: In(await getPermittedBizplaceIds(domain, user)) }
-      },
-      relations: ['domain', 'bizplace', 'creator', 'updater']
-    })
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() shippingOrder: ShippingOrder): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: shippingOrder.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() shippingOrder: ShippingOrder): Promise<User> {
-    return await getRepository(User).findOneBy({ id: shippingOrder.creatorId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() shippingOrder: ShippingOrder): Promise<User> {
-    return await getRepository(User).findOneBy({ id: shippingOrder.updaterId })
-  }
-}

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

@@ -1,89 +0,0 @@
-import { Field, InputType, Int, ObjectType } from 'type-graphql'
-import { ShippingOrder } from './shipping-order'
-
-@ObjectType()
-export class ShippingOrderList {
-  @Field(type => [ShippingOrder], { nullable: true })
-  items: ShippingOrder[]
-
-  @Field(type => Int, { nullable: true })
-  total: number
-}
-
-@InputType()
-export class NewShippingOrder {
-  @Field({ nullable: true })
-  name: string
-
-  @Field()
-  shipName: string
-
-  @Field()
-  containerNo: string
-
-  @Field({ nullable: true })
-  containerArrivalDate: string
-
-  @Field({ nullable: true })
-  containerLeavingDate: string
-
-  @Field({ nullable: true })
-  containerArrivalDateTime: string
-
-  @Field({ nullable: true })
-  containerLeavingDateTime: string
-
-  @Field()
-  status: string
-
-  @Field({ nullable: true })
-  description: string
-}
-
-@InputType()
-export class ShippingOrderPatch {
-  @Field({ nullable: true })
-  name: string
-
-  @Field({ nullable: true })
-  description: string
-
-  @Field({ nullable: true })
-  shipName: string
-
-  @Field({ nullable: true })
-  containerNo: string
-
-  @Field({ nullable: true })
-  containerSize: string
-
-  @Field({ nullable: true })
-  containerArrivalDate: string
-
-  @Field({ nullable: true })
-  containerLeavingDate: string
-
-  @Field({ nullable: true })
-  containerClosureDate: string
-
-  @Field({ nullable: true })
-  containerArrivalDateTime: string
-
-  @Field({ nullable: true })
-  containerLeavingDateTime: Date
-
-  @Field({ nullable: true })
-  containerClosureDateTime: Date
-
-  @Field({ nullable: true })
-  remark: string
-
-  @Field({ nullable: true })
-  exportRemark: string
-
-  @Field({ nullable: true })
-  status: string
-
-  @Field({ nullable: true })
-  remindContainerDeparture: boolean
-}

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

@@ -1,129 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { Field, ID, ObjectType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-
-@Entity()
-@Index('ix_shipping-order_0', (shippingOrder: ShippingOrder) => [shippingOrder.domain, shippingOrder.name], {
-  unique: true
-})
-@ObjectType()
-export class ShippingOrder {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain, { nullable: true })
-  domain: Domain
-
-  @RelationId((shippingOrder: ShippingOrder) => shippingOrder.domain)
-  domainId: string
-
-  @ManyToOne(type => Bizplace)
-  @Field(type => Bizplace, { nullable: true })
-  bizplace: Bizplace
-
-  @RelationId((shippingOrder: ShippingOrder) => shippingOrder.bizplace)
-  bizplaceId: string
-
-  @Column()
-  @Field()
-  name: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  shipName: string
-
-  @Column()
-  @Field()
-  containerNo: string
-
-  @Column({ nullable: true })
-  @Field()
-  containerSize: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  containerArrivalDate: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  containerArrivalDateTime: Date
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  containerLeavingDate: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  containerLeavingDateTime: Date
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  containerClosureDate: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  containerClosureDateTime: Date
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  remindContainerDeparture: boolean
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  from: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  to: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  remark: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  loadType: string
-
-  @Column()
-  @Field()
-  status: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description: string
-
-  @CreateDateColumn()
-  @Field()
-  createdAt: Date
-
-  @UpdateDateColumn()
-  @Field()
-  updatedAt: Date
-
-  @ManyToOne(type => User)
-  @Field(type => User, { nullable: true })
-  creator: User
-
-  @RelationId((shippingOrder: ShippingOrder) => shippingOrder.creator)
-  creatorId: string
-
-  @ManyToOne(type => User)
-  @Field(type => User, { nullable: true })
-  updater: User
-
-  @RelationId((shippingOrder: ShippingOrder) => shippingOrder.updater)
-  updaterId: string
-}

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

@@ -1,9 +0,0 @@
-import { TransferOrder } from './transfer-order'
-import { TransferOrderMutation } from './transfer-order-mutation'
-import { TransferOrderQuery } from './transfer-order-query'
-
-export const entities = [TransferOrder]
-export const resolvers = [TransferOrderQuery, TransferOrderMutation]
-
-export * from './transfer-order-mutation'
-export * from './transfer-order-query'