@things-factory/sales-base 4.3.239 → 4.3.244

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

@@ -4,6 +4,7 @@ import {
   CreateDateColumn,
   Entity,
   Index,
+  OneToMany,
   ManyToOne,
   PrimaryGeneratedColumn,
   RelationId,
@@ -17,6 +18,7 @@ import { Domain } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
 
 import { ArrivalNotice } from '../arrival-notice/arrival-notice'
+import { OrderInventory } from '../order-inventory/order-inventory'
 import { ReleaseGood } from '../release-good/release-good'
 import { RetailReplenishmentOrder } from '../retail-replenishment-order/retail-replenishment-order'
 import { ReturnOrder } from '../return-order/return-order'
@@ -24,9 +26,12 @@ import { ShippingOrder } from '../shipping-order/shipping-order'
 import { TransferOrder } from '../transfer-order/transfer-order'
 import { VasOrder } from '../vas-order/vas-order'
 import { Vas } from '../vas/vas'
+import { OrderVasItem } from '../order-vas-item/order-vas-item'
 
 @Entity('order_vass')
-@Index('ix_order-vas_0', (orderVas: OrderVas) => [orderVas.domain, orderVas.name], { unique: true })
+@Index('ix_order-vas_0', (orderVas: OrderVas) => [orderVas.domain, orderVas.name, orderVas.releaseGood], {
+  unique: true
+})
 @ObjectType()
 export class OrderVas {
   @PrimaryGeneratedColumn('uuid')
@@ -55,14 +60,17 @@ export class OrderVas {
   @Field({ nullable: true })
   batchId: string
 
+  // not used for restrructure VAS anymore
   @Column({ nullable: true })
   @Field({ nullable: true })
   set: number
 
+  // not used for restrructure VAS anymore
   @Column({ nullable: true })
   @Field({ nullable: true })
   targetType: string
 
+  // not used for restrructure VAS anymore
   @Column({ nullable: true })
   @Field({ nullable: true })
   targetBatchId: string
@@ -74,6 +82,45 @@ export class OrderVas {
   @RelationId((orderVas: OrderVas) => orderVas.targetProduct)
   targetProductId: string
 
+  @ManyToOne(type => Product)
+  @Field(type => Product, { nullable: true })
+  product: Product
+
+  @RelationId((orderVas: OrderVas) => orderVas.product)
+  productId: string
+
+  // moved to order vas item
+  // used to be productDetail
+  @ManyToOne(type => ProductDetail, { nullable: true })
+  @Field({ nullable: true })
+  productDetail: ProductDetail
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  outputQty: number
+
+  @ManyToOne(type => OrderInventory)
+  @Field(type => OrderInventory, { nullable: true })
+  orderInventory: OrderInventory
+
+  @RelationId((orderVas: OrderVas) => orderVas.orderInventory)
+  orderInventoryId: string
+
+  @ManyToOne(type => Product)
+  @Field(type => Product, { nullable: true })
+  newProduct: Product
+
+  @RelationId((orderVas: OrderVas) => orderVas.newProduct)
+  newProductId: string
+
+  @ManyToOne(type => ProductDetail, { nullable: true })
+  @Field({ nullable: true })
+  newProductDetail: ProductDetail
+
+  @RelationId((orderVas: OrderVas) => orderVas.newProductDetail)
+  newProductDetailId: string
+
+  // not used for restrructure VAS anymore
   @Column({ nullable: true })
   @Field({ nullable: true })
   otherTarget: string
@@ -82,18 +129,26 @@ export class OrderVas {
   @Field({ nullable: true })
   qty: number
 
+  // not used for restrructure VAS anymore
   @Column({ nullable: true })
   @Field({ nullable: true })
   actualQty: number
 
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  uom: string
+
+  // use order vas item
   @Column('float', { nullable: true })
   @Field({ nullable: true })
   uomValue: number
 
+  // not used for restrructure VAS anymore
   @Column('float', { nullable: true })
   @Field({ nullable: true })
   actualUomValue: number
 
+  // can try use from target product instead
   @Column({ nullable: true })
   @Field({ nullable: true })
   productName: string
@@ -116,45 +171,57 @@ export class OrderVas {
   @RelationId((orderVas: OrderVas) => orderVas.releaseGood)
   releaseGoodId: string
 
+  // not used for restrructure VAS anymore
   @ManyToOne(type => ShippingOrder)
   @Field(type => ShippingOrder, { nullable: true })
   shippingOrder: ShippingOrder
 
+  // not used for restrructure VAS anymore
   @RelationId((orderVas: OrderVas) => orderVas.shippingOrder)
   shippingOrderId: string
 
+  // not used for restrructure VAS anymore
   @ManyToOne(type => TransferOrder)
   @Field(type => TransferOrder, { nullable: true })
   transferOrder: TransferOrder
 
+  // not used for restrructure VAS anymore
   @RelationId((orderVas: OrderVas) => orderVas.transferOrder)
   transferOrderId: string
 
+  // not used for restrructure VAS anymore
   @ManyToOne(type => ReturnOrder)
   @Field(type => ReturnOrder, { nullable: true })
   returnOrder: ReturnOrder
 
+  // not used for restrructure VAS anymore
   @RelationId((orderVas: OrderVas) => orderVas.returnOrder)
   returnOrderId: string
 
+  // not used for restrructure VAS anymore
   @ManyToOne(type => RetailReplenishmentOrder)
   @Field(type => RetailReplenishmentOrder, { nullable: true })
   retailReplenishmentOrder: RetailReplenishmentOrder
 
+  // not used for restrructure VAS anymore
   @RelationId((orderVas: OrderVas) => orderVas.retailReplenishmentOrder)
   retailReplenishmentOrderId: string
 
+  // remove
   @ManyToOne(type => OrderVas)
   @Field(type => OrderVas, { nullable: true })
   orderVas: OrderVas
 
+  // remove
   @RelationId((orderVas: OrderVas) => orderVas.orderVas)
   orderVasId: string
 
+  // not used for restrructure VAS anymore
   @ManyToOne(type => VasOrder)
   @Field(type => VasOrder, { nullable: true })
   vasOrder: VasOrder
 
+  // not used for restrructure VAS anymore
   @RelationId((orderVas: OrderVas) => orderVas.vasOrder)
   vasOrderId: string
 
@@ -165,6 +232,7 @@ export class OrderVas {
   @RelationId((orderVas: OrderVas) => orderVas.vas)
   vasId: string
 
+  // not used for restrructure VAS anymore
   @Column({ nullable: true })
   @Field({ nullable: true })
   operationGuide: string
@@ -184,6 +252,22 @@ export class OrderVas {
   @Field({ nullable: true })
   remark: string
 
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  newPackingType: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  newUom: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  newUomValue: number
+
+  @OneToMany(type => OrderVasItem, orderVasItem => orderVasItem.orderVas)
+  @Field(type => [OrderVasItem])
+  orderVasItems: OrderVasItem[]
+
   @Column({ nullable: true })
   @Field({ nullable: true })
   description: string
@@ -196,14 +280,6 @@ export class OrderVas {
   @Field()
   createdAt: Date
 
-  @UpdateDateColumn()
-  @Field()
-  updatedAt: Date
-
-  @ManyToOne(type => ProductDetail, { nullable: true })
-  @Field({ nullable: true })
-  productDetail: ProductDetail
-
   @ManyToOne(type => User)
   @Field(type => User, { nullable: true })
   creator: User
@@ -211,11 +287,14 @@ export class OrderVas {
   @RelationId((orderVas: OrderVas) => orderVas.creator)
   creatorId: string
 
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
   @ManyToOne(type => User)
   @Field(type => User, { nullable: true })
   updater: User
 
   @RelationId((orderVas: OrderVas) => orderVas.updater)
   updaterId: string
-
 }

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

@@ -0,0 +1,6 @@
+import { OrderVasItem } from './order-vas-item'
+import { OrderVasItemQuery } from './order-vas-item-query'
+import { OrderVasItemMutation } from './order-vas-item-mutation'
+
+export const entities = [OrderVasItem]
+export const resolvers = [OrderVasItemQuery, OrderVasItemMutation]

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

@@ -0,0 +1,112 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { getRepository, In } from 'typeorm'
+import { OrderVasItem } from './order-vas-item'
+import { NewOrderVasItem, OrderVasItemPatch } from './order-vas-item-type'
+
+@Resolver(OrderVasItem)
+export class OrderVasItemMutation {
+  @Directive('@transaction')
+  @Mutation(returns => OrderVasItem, { description: 'To create new OrderVasItem' })
+  async createOrderVasItem(
+    @Arg('orderVasItem') orderVasItem: NewOrderVasItem,
+    @Ctx() context: any
+  ): Promise<OrderVasItem> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(OrderVasItem).save({
+      ...orderVasItem,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => OrderVasItem, { description: 'To modify OrderVasItem information' })
+  async updateOrderVasItem(
+    @Arg('id') id: string,
+    @Arg('patch') patch: OrderVasItemPatch,
+    @Ctx() context: any
+  ): Promise<OrderVasItem> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(OrderVasItem)
+    const orderVasItem = await repository.findOne({
+      where: { domain, id }
+    })
+
+    return await repository.save({
+      ...orderVasItem,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [OrderVasItem], { description: "To modify multiple OrderVasItems' information" })
+  async updateMultipleOrderVasItem(
+    @Arg('patches', type => [OrderVasItemPatch]) patches: OrderVasItemPatch[],
+    @Ctx() context: any
+  ): Promise<OrderVasItem[]> {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const orderVasItemRepo = tx.getRepository(OrderVasItem)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+        const result = await orderVasItemRepo.save({
+          ...newRecord,
+          executedAt: null,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const orderVasItem = await orderVasItemRepo.findOne(newRecord.id)
+
+        const result = await orderVasItemRepo.save({
+          ...orderVasItem,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete OrderVasItem' })
+  async deleteOrderVasItem(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(OrderVasItem).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple orderVasItems' })
+  async deleteOrderVasItems(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(OrderVasItem).delete({
+      domain,
+      id: In(ids)
+    })
+
+    return true
+  }
+}

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

@@ -0,0 +1,58 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { getRepository } from 'typeorm'
+import { Domain, ListParam, convertListParams } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { OrderVasItem } from './order-vas-item'
+import { OrderVasItemList } from './order-vas-item-type'
+
+@Resolver(OrderVasItem)
+export class OrderVasItemQuery {
+  @Query(returns => OrderVasItem, { description: 'To fetch a OrderVasItem' })
+  async orderVasItem(@Arg('id') id: string, @Ctx() context: any): Promise<OrderVasItem> {
+    const { domain } = context.state
+
+    return await getRepository(OrderVasItem).findOne({
+      where: { domain, id }
+    })
+  }
+
+  @Query(returns => OrderVasItemList, { description: 'To fetch multiple OrderVasItems' })
+  async orderVasItems(@Args() params: ListParam, @Ctx() context: any): Promise<OrderVasItemList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, domain.id)
+    const [items, total] = await getRepository(OrderVasItem).findAndCount({
+      ...convertedParams,
+      relations: [
+        'domain',
+        'bizplace',
+        'orderVas',
+        'vas',
+        'product',
+        'productDetail',
+        'newProduct',
+        'newProductDetail',
+        'orderInventory',
+        'creator',
+        'updater'
+      ]
+    })
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() orderVasItem: OrderVasItem): Promise<Domain> {
+    return await getRepository(Domain).findOne(orderVasItem.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() orderVasItem: OrderVasItem): Promise<User> {
+    return await getRepository(User).findOne(orderVasItem.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() orderVasItem: OrderVasItem): Promise<User> {
+    return await getRepository(User).findOne(orderVasItem.creatorId)
+  }
+}

package/server/service/order-vas-item/order-vas-item-type.ts

@@ -0,0 +1,71 @@
+import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
+
+import { OrderVasItem, OrderVasItemStatus } from './order-vas-item'
+
+import { ObjectRef } from '@things-factory/shell'
+
+@InputType()
+export class NewOrderVasItem {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => OrderVasItemStatus, { nullable: true })
+  state?: OrderVasItemStatus
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  params?: string
+}
+
+@InputType()
+export class OrderVasItemPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  orderVas?: ObjectRef
+
+  @Field({ nullable: true })
+  orderVasId?: string
+
+  @Field({ nullable: true })
+  vas?: ObjectRef
+
+  @Field({ nullable: true })
+  vasId?: string
+
+  @Field({ nullable: true })
+  vasQty?: number
+
+  @Field({ nullable: true })
+  executedAt?: Date
+
+  @Field(type => OrderVasItemStatus, { nullable: true })
+  state?: OrderVasItemStatus
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class OrderVasItemList {
+  @Field(type => [OrderVasItem])
+  items: OrderVasItem[]
+
+  @Field(type => Int)
+  total: number
+}

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

@@ -0,0 +1,128 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  PrimaryGeneratedColumn
+} from 'typeorm'
+import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
+
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+
+export enum OrderVasItemStatus {
+  STATUS_A = 'STATUS_A',
+  STATUS_B = 'STATUS_B'
+}
+
+import { OrderInventory } from '../order-inventory/order-inventory'
+import { Product, ProductDetail } from '@things-factory/product-base'
+import { OrderVas } from '../order-vas/order-vas'
+import { Bizplace } from '@things-factory/biz-base'
+import { Vas } from '../vas/vas'
+
+registerEnumType(OrderVasItemStatus, {
+  name: 'OrderVasItemStatus',
+  description: 'state enumeration of a orderVasItem'
+})
+
+@Entity()
+@Index(
+  'ix_order_vas_item_0',
+  (orderVasItem: OrderVasItem) => [orderVasItem.domain, orderVasItem.orderVas, orderVasItem.vas],
+  {
+    unique: true
+  }
+)
+@ObjectType({ description: 'Entity for OrderVasItem' })
+export class OrderVasItem {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((orderVasItem: OrderVasItem) => orderVasItem.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  description?: string
+
+  @ManyToOne(type => Vas)
+  @Field(type => Vas, { nullable: true })
+  vas: Vas
+
+  @RelationId((orderVasItem: OrderVasItem) => orderVasItem.vas)
+  vasId: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  vasQty: number
+
+  @ManyToOne(type => OrderVas)
+  @Field(type => OrderVas, { nullable: true })
+  orderVas: OrderVas
+
+  @RelationId((orderVasItem: OrderVasItem) => orderVasItem.orderVas)
+  orderVasId: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  state?: OrderVasItemStatus
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  params?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  executedAt?: Date
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((orderVasItem: OrderVasItem) => orderVasItem.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((orderVasItem: OrderVasItem) => orderVasItem.creator)
+  updaterId?: string
+}