@things-factory/sales-base 4.0.0-y.0 → 4.0.4

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

@@ -0,0 +1,97 @@
+import { ObjectRef } from '@things-factory/shell'
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+import { NewOrderInventory } from '../order-inventory/order-inventory-types'
+import { TransferOrder } from './transfer-order'
+
+@ObjectType()
+export class TransferOrderList {
+  @Field(type => [TransferOrder], { nullable: true })
+  items: TransferOrder[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class NewTransferOrder {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field({ nullable: true })
+  remark: string
+
+  @Field({ nullable: true })
+  ownTransport: Boolean
+
+  @Field({ nullable: true })
+  type: string
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field(type => [ObjectRef], { nullable: true })
+  orderVas: [ObjectRef]
+
+  @Field(type => [NewOrderInventory], { nullable: true })
+  orderInventories: [NewOrderInventory]
+
+  @Field(type => ObjectRef, { nullable: true })
+  deliveryOrder: ObjectRef
+
+  @Field({ nullable: true })
+  issuedDate: string
+
+  @Field({ nullable: true })
+  warehouseId: string // outletID
+}
+
+@InputType()
+export class TransferOrderPatch {
+  @Field({ nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  warehouseId: string // outletID
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field({ nullable: true })
+  remark: string
+
+  @Field({ nullable: true })
+  ownTransport: Boolean
+
+  @Field({ nullable: true })
+  type: string
+
+  @Field({ nullable: true })
+  status: string
+
+  @Field(type => [ObjectRef], { nullable: true })
+  orderVas: [ObjectRef]
+
+  @Field(type => [NewOrderInventory], { nullable: true })
+  orderInventories: [NewOrderInventory]
+
+  @Field(type => [ObjectRef], { nullable: true })
+  deliveryOrder: [ObjectRef]
+
+  @Field({ nullable: true })
+  issuedDate: string
+
+  @Field({ nullable: true })
+  cuFlag: string
+}

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

@@ -0,0 +1,117 @@
+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,
+  JoinColumn,
+  ManyToOne,
+  OneToMany,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+import { DeliveryOrder, OrderInventory, OrderVas, RetailReplenishmentOrder } from '../'
+
+@Entity()
+@Index('ix_transfer_order_0', (transferOrder: TransferOrder) => [transferOrder.domain, transferOrder.name], {
+  unique: true
+})
+@ObjectType()
+export class TransferOrder {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((transferOrder: TransferOrder) => transferOrder.domain)
+  domainId: string
+
+  @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace, { nullable: true })
+  bizplace: Bizplace
+
+  @RelationId((transferOrder: TransferOrder) => transferOrder.bizplace)
+  bizplaceId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  refNo: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  remark: string
+
+  @Column()
+  @Field()
+  ownTransport: Boolean
+
+  @Column()
+  @Field()
+  type: string
+
+  @Column()
+  @Field()
+  status: string
+
+  @OneToMany(type => OrderVas, orderVas => orderVas.transferOrder)
+  @Field(type => [OrderVas], { nullable: true })
+  orderVass: OrderVas[]
+
+  @OneToMany(type => OrderInventory, orderInventory => orderInventory.transferOrder)
+  @Field(type => [OrderInventory], { nullable: true })
+  orderInventories: OrderInventory[]
+
+  @OneToMany(type => DeliveryOrder, deliveryOrder => deliveryOrder.transferOrder)
+  @Field(type => [DeliveryOrder], { nullable: true })
+  deliveryOrders: DeliveryOrder[]
+
+  @OneToOne(type => RetailReplenishmentOrder)
+  @JoinColumn()
+  @Field(type => RetailReplenishmentOrder, { nullable: true })
+  retailReplenishmentOrder: RetailReplenishmentOrder
+
+  @RelationId((transferOrder: TransferOrder) => transferOrder.retailReplenishmentOrder)
+  retailReplenishmentOrderId: string
+
+  @Column({ type: 'date' })
+  @Field()
+  issuedDate: Date
+
+  @CreateDateColumn()
+  @Field()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((transferOrder: TransferOrder) => transferOrder.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((transferOrder: TransferOrder) => transferOrder.updater)
+  updaterId: string
+}

package/server/service/vas/index.ts

@@ -0,0 +1,9 @@
+import { Vas } from './vas'
+import { VasMutation } from './vas-mutation'
+import { VasQuery } from './vas-query'
+
+export const entities = [Vas]
+export const resolvers = [VasQuery, VasMutation]
+
+export * from './vas-mutation'
+export * from './vas-query'

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

@@ -0,0 +1,108 @@
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager } from 'typeorm'
+import { NewVas, VasPatch } from '../'
+import { Vas } from './vas'
+
+@Resolver(Vas)
+export class VasMutation {
+  @Directive('@privilege(category: "vas", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Vas)
+  async createVas(@Arg('vas', type => NewVas) vas: NewVas, @Ctx() context: any): Promise<Vas> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    return await tx.getRepository(Vas).save({
+      ...vas,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@privilege(category: "vas", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Vas)
+  async updateVas(
+    @Arg('name') name: string,
+    @Arg('patch', type => VasPatch) patch: VasPatch,
+    @Ctx() context: any
+  ): Promise<Vas> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    const vas = await tx.getRepository(Vas).findOne({ domain, name })
+
+    return await tx.getRepository(Vas).save({
+      ...vas,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@privilege(category: "vas", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => [Vas])
+  async updateMultipleVas(
+    @Arg('patches', type => [VasPatch]) patches: VasPatch[],
+    @Ctx() context: any
+  ): Promise<Vas[]> {
+    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+
+    let results: Vas[] = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const vasRepo = tx.getRepository(Vas)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await vasRepo.save({
+          ...newRecord,
+          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 vas = await vasRepo.findOne(newRecord.id)
+
+        const result = await vasRepo.save({
+          ...vas,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@privilege(category: "vas", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteVas(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { tx }: { tx: EntityManager } = context.state
+
+    await tx.getRepository(Vas).delete(id)
+    return true
+  }
+
+  @Directive('@privilege(category: "vas", privilege: "mutation")')
+  @Directive('@transaction')
+  @Mutation(returns => Boolean)
+  async deleteVass(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+    const { tx }: { tx: EntityManager } = context.state
+    await tx.getRepository(Vas).delete(ids)
+    return true
+  }
+}

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

@@ -0,0 +1,58 @@
+import { User } from '@things-factory/auth-base'
+import { buildQuery, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
+import { Arg, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository, SelectQueryBuilder } from 'typeorm'
+import { VasList } from '../'
+import { Vas } from './vas'
+
+@Resolver(Vas)
+export class VasQuery {
+  @Directive('@privilege(category: "vas", privilege: "query")')
+  @Query(returns => VasList)
+  async vass(
+    @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<VasList> {
+    const qb: SelectQueryBuilder<Vas> = getRepository(Vas).createQueryBuilder()
+    buildQuery(qb, { filters, pagination, sortings }, context)
+
+    const [items, total] = await qb
+      .leftJoinAndSelect('Vas.domain', 'Domain')
+      .leftJoinAndSelect('Vas.creator', 'Creator')
+      .leftJoinAndSelect('Vas.updater', 'Updater')
+      .getManyAndCount()
+
+    return { items, total }
+  }
+
+  @Directive('@privilege(category: "vas", privilege: "query") ')
+  @Query(returns => Vas)
+  async vas(@Arg('name') name: string, @Ctx() context: any): Promise<Vas> {
+    const { domain }: { domain: Domain } = context.state
+
+    return await getRepository(Vas).findOne({
+      where: {
+        domain,
+        name
+      },
+      relations: ['domain', 'creator', 'updater']
+    })
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() vas: Vas): Promise<Domain> {
+    return await getRepository(Domain).findOne(vas.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() vas: Vas): Promise<User> {
+    return await getRepository(User).findOne(vas.creatorId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() vas: Vas): Promise<User> {
+    return await getRepository(User).findOne(vas.updaterId)
+  }
+}

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

@@ -0,0 +1,71 @@
+import { Field, Float, InputType, Int, ObjectType } from 'type-graphql'
+import { Vas } from './vas'
+
+@ObjectType()
+export class VasList {
+  @Field(type => [Vas], { nullable: true })
+  items: Vas[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class NewVas {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field(type => Float)
+  defaultPrice: number
+
+  @Field({ nullable: true })
+  currency: string
+
+  @Field({ nullable: true })
+  uom: string
+
+  @Field({ nullable: true })
+  type: string
+
+  @Field({ nullable: true })
+  operationGuideType: string
+
+  @Field({ nullable: true })
+  operationGuide: string
+}
+
+@InputType()
+export class VasPatch {
+  @Field({ nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  uom: string
+
+  @Field({ nullable: true })
+  type: string
+
+  @Field({ nullable: true })
+  currency: string
+
+  @Field(type => Float, { nullable: true })
+  defaultPrice: number
+
+  @Field({ nullable: true })
+  operationGuideType: string
+
+  @Field({ nullable: true })
+  operationGuide: string
+
+  @Field({ nullable: true })
+  cuFlag: string
+}

package/server/service/vas/vas.ts

@@ -0,0 +1,86 @@
+import { User } from '@things-factory/auth-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('vass')
+@Index('ix_vas_0', (vas: Vas) => [vas.domain, vas.name], { unique: true })
+@ObjectType()
+export class Vas {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((vas: Vas) => vas.domain)
+  domainId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description: string
+
+  @Column()
+  @Field()
+  currency: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  uom: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  type: string
+
+  @Column('float')
+  @Field()
+  defaultPrice: number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  operationGuideType: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  operationGuide: string
+
+  @CreateDateColumn()
+  @Field()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((vas: Vas) => vas.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((vas: Vas) => vas.updater)
+  updaterId: string
+
+  @Field({ nullable: true })
+  cuFlag: string
+}

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

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