@things-factory/sales-base 8.0.2 → 8.0.5

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

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

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

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

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

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

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

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

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

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

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