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

package/server/service/claim-detail/claim-detail-mutation.ts

@@ -0,0 +1,102 @@
+import { Arg, Ctx, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
+import { ClaimDetailPatch, NewClaimDetail } from '../'
+import { ClaimDetail } from './claim-detail'
+
+@Resolver(ClaimDetail)
+export class ClaimDetailMutation {
+  @Mutation(returns => ClaimDetail)
+  async createClaimDetail(
+    @Arg('claimDetail', type => NewClaimDetail) claimDetail: NewClaimDetail,
+    @Ctx() context: ResolverContext
+  ): Promise<ClaimDetail> {
+    return await getRepository(ClaimDetail).save({
+      ...claimDetail,
+      domain: context.state.domain,
+      creator: context.state.user,
+      updater: context.state.user
+    })
+  }
+
+  @Mutation(returns => ClaimDetail)
+  async updateClaimDetail(
+    @Arg('name') name: string,
+    @Arg('patch', type => ClaimDetailPatch) patch: ClaimDetailPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<ClaimDetail> {
+    const repository = getRepository(ClaimDetail)
+    const claimDetail = await repository.findOne({
+      where: { domain: { id: context.state.domain.id }, name }
+    })
+
+    return await repository.save({
+      ...claimDetail,
+      ...patch,
+      updater: context.state.user
+    })
+  }
+
+  @Mutation(returns => [ClaimDetail])
+  async updateMultipleClaimDetail(
+    @Arg('patches', type => [ClaimDetailPatch]) patches: ClaimDetailPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<ClaimDetail[]> {
+    let results: ClaimDetail[] = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const claimDetailRepo = getRepository(ClaimDetail)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await claimDetailRepo.save({
+          ...newRecord,
+          domain: context.state.domain,
+          creator: context.state.user,
+          updater: context.state.user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const claimDetail = await claimDetailRepo.findOneBy({ id: newRecord.id })
+
+        const result = await claimDetailRepo.save({
+          ...claimDetail,
+          ...newRecord,
+          updater: context.state.user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Mutation(returns => Boolean)
+  async deleteClaimDetail(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    await getRepository(ClaimDetail).delete({ domain: { id: context.state.domain.id }, name })
+    return true
+  }
+
+  @Mutation(returns => Boolean)
+  async deleteClaimDetails(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    await getRepository(ClaimDetail).delete({
+      domain: { id: context.state.domain.id },
+      name: In(names)
+    })
+    return true
+  }
+}

package/server/service/claim-detail/claim-detail-query.ts

@@ -0,0 +1,55 @@
+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 { ClaimDetailList } from '../'
+import { ClaimDetail } from './claim-detail'
+
+@Resolver(ClaimDetail)
+export class ClaimDetailQuery {
+  @Query(returns => ClaimDetail)
+  async claimDetail(
+    @Ctx() context: ResolverContext,
+    @Arg('name', { nullable: true }) name?: string
+  ): Promise<ClaimDetail> {
+    return await getRepository(ClaimDetail).findOne({
+      where: { domain: { id: context.state.domain.id }, name },
+      relations: ['domain', 'creator', 'updater']
+    })
+  }
+
+  @Query(returns => ClaimDetailList)
+  async claimDetails(
+    @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<ClaimDetailList> {
+    const convertedParams = convertListParams({
+      filters,
+      pagination,
+      sortings
+    })
+    const [items, total] = await getRepository<ClaimDetail>(ClaimDetail).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'creator', 'updater']
+    })
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() claimDetail: ClaimDetail): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: claimDetail.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() claimDetail: ClaimDetail): Promise<User> {
+    return await getRepository(User).findOneBy({ id: claimDetail.creatorId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() claimDetail: ClaimDetail): Promise<User> {
+    return await getRepository(User).findOneBy({ id: claimDetail.updaterId })
+  }
+}

package/server/service/claim-detail/claim-detail-types.ts

@@ -0,0 +1,47 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+import { ClaimDetail } from './claim-detail'
+
+@ObjectType()
+export class ClaimDetailList {
+  @Field(type => [ClaimDetail], { nullable: true })
+  items: ClaimDetail[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class NewClaimDetail {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field({ nullable: true })
+  amount: number
+}
+
+@InputType()
+export class ClaimDetailPatch {
+  @Field({ nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  refNo: string
+
+  @Field({ nullable: true })
+  amount: number
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  cuFlag: string
+}

package/server/service/claim-detail/claim-detail.ts

@@ -0,0 +1,69 @@
+import { User } from '@things-factory/auth-base'
+import { Domain, roundTransformer } from '@things-factory/shell'
+import { Field, ID, ObjectType } from 'type-graphql'
+import { Column, CreateDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId, UpdateDateColumn } from 'typeorm'
+import { Claim } from '../'
+
+@Entity()
+@ObjectType()
+@Index('ix_claim-detail_0', (claimDetail: ClaimDetail) => [claimDetail.domain, claimDetail.id], { unique: true })
+export class ClaimDetail {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((claimDetail: ClaimDetail) => claimDetail.domain)
+  domainId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  refNo: String
+
+  @Column('float', { transformer: roundTransformer })
+  @Field()
+  amount: number
+
+  @CreateDateColumn()
+  @Field()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
+  @ManyToOne(type => Claim)
+  @Field(type => Claim, { nullable: true })
+  claim: Claim
+
+  @RelationId((claimDetail: ClaimDetail) => claimDetail.claim)
+  claimId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((claimDetail: ClaimDetail) => claimDetail.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((claimDetail: ClaimDetail) => claimDetail.updater)
+  updaterId: string
+
+  @Field({ nullable: true })
+  cuFlag: string
+}

package/server/service/claim-detail/index.ts

@@ -0,0 +1,9 @@
+import { ClaimDetail } from './claim-detail'
+import { ClaimDetailMutation } from './claim-detail-mutation'
+import { ClaimDetailQuery } from './claim-detail-query'
+
+export const entities = [ClaimDetail]
+export const resolvers = [ClaimDetailQuery, ClaimDetailMutation]
+
+export * from './claim-detail-mutation'
+export * from './claim-detail-query'

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

@@ -0,0 +1,101 @@
+import { Arg, Ctx, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
+import { ClaimOrderPatch, NewClaimOrder } from '../'
+import { ClaimOrder } from './claim-order'
+
+@Resolver(ClaimOrder)
+export class ClaimOrderMutation {
+  @Mutation(returns => ClaimOrder)
+  async createClaimOrder(
+    @Arg('claimOrder', type => NewClaimOrder) claimOrder: NewClaimOrder,
+    @Ctx() context: ResolverContext
+  ): Promise<ClaimOrder> {
+    return await getRepository(ClaimOrder).save({
+      ...claimOrder,
+      domain: context.state.domain,
+      creator: context.state.user,
+      updater: context.state.user
+    })
+  }
+
+  @Mutation(returns => ClaimOrder)
+  async updateClaimOrder(
+    @Arg('name') name: string,
+    @Arg('patch', type => ClaimOrderPatch) patch: ClaimOrderPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<ClaimOrder> {
+    const repository = getRepository(ClaimOrder)
+    const claimOrder = await repository.findOne({
+      where: { domain: { id: context.state.domain.id }, name }
+    })
+
+    return await repository.save({
+      ...claimOrder,
+      ...patch,
+      updater: context.state.user
+    })
+  }
+
+  @Mutation(returns => [ClaimOrder])
+  async updateMultipleClaimOrder(
+    @Arg('patches', type => [ClaimOrderPatch]) patches: ClaimOrderPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<ClaimOrder[]> {
+    let results: ClaimOrder[] = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const claimOrderRepo = getRepository(ClaimOrder)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+        const result = await claimOrderRepo.save({
+          ...newRecord,
+          domain: context.state.domain,
+          creator: context.state.user,
+          updater: context.state.user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const claimOrder = await claimOrderRepo.findOneBy({ id: newRecord.id })
+
+        const result = await claimOrderRepo.save({
+          ...claimOrder,
+          ...newRecord,
+          updater: context.state.user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Mutation(returns => Boolean)
+  async deleteClaimOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    await getRepository(ClaimOrder).delete({ domain: { id: context.state.domain.id }, name })
+    return true
+  }
+
+  @Mutation(returns => Boolean)
+  async deleteClaimOrders(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    await getRepository(ClaimOrder).delete({
+      domain: { id: context.state.domain.id },
+      name: In(names)
+    })
+    return true
+  }
+}

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

@@ -0,0 +1,47 @@
+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 { ClaimOrderList } from '../'
+import { ClaimOrder } from './claim-order'
+
+@Resolver(ClaimOrder)
+export class ClaimOrderQuery {
+  @Query(returns => ClaimOrderList)
+  async claimOrders(
+    @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<ClaimOrderList> {
+    const convertedParams = convertListParams({ filters, pagination, sortings })
+    const [items, total] = await getRepository<ClaimOrder>(ClaimOrder).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'creator', 'updater']
+    })
+    return { items, total }
+  }
+
+  @Query(returns => ClaimOrder)
+  async claimOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ClaimOrder> {
+    return await getRepository(ClaimOrder).findOne({
+      where: { domain: { id: context.state.domain.id }, name },
+      relations: ['domain', 'creator', 'updater']
+    })
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() claimOrder: ClaimOrder): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: claimOrder.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() claimOrder: ClaimOrder): Promise<User> {
+    return await getRepository(User).findOneBy({ id: claimOrder.creatorId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() claimOrder: ClaimOrder): Promise<User> {
+    return await getRepository(User).findOneBy({ id: claimOrder.updaterId })
+  }
+}

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

@@ -0,0 +1,35 @@
+import { Field, InputType, Int, ObjectType } from 'type-graphql'
+import { ClaimOrder } from './claim-order'
+
+@ObjectType()
+export class ClaimOrderList {
+  @Field(type => ClaimOrder, { nullable: true })
+  items: ClaimOrder[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class NewClaimOrder {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+}
+
+@InputType()
+export class ClaimOrderPatch {
+  @Field({ nullable: true })
+  id: string
+
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  cuFlag: string
+}

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

@@ -0,0 +1,81 @@
+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,
+  JoinColumn,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+import { Claim, CollectionOrder, DeliveryOrder } from '../'
+
+@Entity()
+@ObjectType()
+@Index('ix_claim-order_0', (claimOrder: ClaimOrder) => [claimOrder.domain, claimOrder.id], { unique: true })
+export class ClaimOrder {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((claimOrder: ClaimOrder) => claimOrder.domain)
+  domainId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description: string
+
+  @CreateDateColumn()
+  @Field()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
+  @ManyToOne(type => Claim)
+  @Field(type => Claim, { nullable: true })
+  claim: Claim
+
+  @RelationId((claimOrder: ClaimOrder) => claimOrder.claim)
+  claimId: string
+
+  @ManyToOne(type => CollectionOrder)
+  @JoinColumn()
+  @Field(type => CollectionOrder, { nullable: true })
+  collectionOrder: CollectionOrder
+
+  @ManyToOne(type => DeliveryOrder)
+  @JoinColumn()
+  @Field(type => DeliveryOrder, { nullable: true })
+  deliveryOrder: DeliveryOrder
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((claimOrder: ClaimOrder) => claimOrder.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((claimOrder: ClaimOrder) => claimOrder.updater)
+  updaterId: string
+
+  @Field({ nullable: true })
+  cuFlag: string
+}

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

@@ -0,0 +1,9 @@
+import { ClaimOrder } from './claim-order'
+import { ClaimOrderMutation } from './claim-order-mutation'
+import { ClaimOrderQuery } from './claim-order-query'
+
+export const entities = [ClaimOrder]
+export const resolvers = [ClaimOrderQuery, ClaimOrderMutation]
+
+export * from './claim-order-mutation'
+export * from './claim-order-query'