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

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

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

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

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

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

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

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

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