@things-factory/sales-base 8.0.2 → 8.0.5

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

@@ -1,308 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In, MoreThan } from 'typeorm'
-
-import { Bizplace } from '@things-factory/biz-base'
-import { getRepository } from '@things-factory/shell'
-import { TransportDriver, TransportVehicle } from '@things-factory/transport-base'
-
-import {
-  ClaimDetail,
-  ClaimDetailPatch,
-  ClaimOrder,
-  ClaimPatch,
-  CollectionOrder,
-  DeliveryOrder,
-  NewClaim,
-  NewClaimDetail
-} from '../'
-import { Claim } from './claim'
-
-@Resolver(Claim)
-export class ClaimMutation {
-  @Directive('@privilege(category: "claim", privilege: "mutation" )')
-  @Directive('@transaction')
-  @Mutation(returns => Claim)
-  async createClaim(@Arg('claim', type => NewClaim) claim: NewClaim, @Ctx() context: ResolverContext): Promise<Claim> {
-    const { tx } = context.state
-
-    let arrClaimOrdersName = claim.claimOrders.map(item => {
-      return item.name
-    })
-
-    let newClaimOrders = []
-    let deliveryOrder = await getRepository(DeliveryOrder).find({
-      where: { name: In(arrClaimOrdersName), domain: { id: context.state.domain.id } }
-    })
-
-    let collectionOrder = await getRepository(CollectionOrder).find({
-      where: { name: In(arrClaimOrdersName), domain: { id: context.state.domain.id } }
-    })
-
-    deliveryOrder.map(order => {
-      newClaimOrders.push({
-        name: order.name,
-        deliveryOrder: order
-      })
-    })
-
-    collectionOrder.map(order => {
-      newClaimOrders.push({
-        name: order.name,
-        collectionOrder: order
-      })
-    })
-
-    let bizplace = await getRepository(Bizplace).findOne({
-      where: {
-        domain: { id: context.state.domain.id },
-        id: claim.bizplace
-      }
-    })
-
-    let transportDriver = await getRepository(TransportDriver).findOne({
-      where: {
-        domain: { id: context.state.domain.id },
-        id: claim.transportDriver
-      }
-    })
-
-    let transportVehicle = await getRepository(TransportVehicle).findOne({
-      where: {
-        domain: { id: context.state.domain.id },
-        id: claim.transportVehicle
-      }
-    })
-
-    // if (newClaimOrders.length > 0) {
-    //   await getRepository(ClaimOrder).findAndCount({
-    //     where: { deliveryOrder: In(), domain: { id: context.state.domain.id } }
-    //   })
-    //   throw new Error('Data Error')
-    // }
-
-    let today = new Date()
-    let year = today.getFullYear()
-    let month = today.getMonth()
-    let date = today.getDate()
-
-    const [items, total] = await getRepository(Claim).findAndCountBy({
-      createdAt: MoreThan(new Date(year, month, date))
-    })
-
-    let claimName =
-      'CLAIM' +
-      year.toString().substr(year.toString().length - 2) +
-      ('0' + month.toString()).substr(('0' + (month + 1).toString()).toString().length - 2) +
-      ('0' + date.toString()).substr(('0' + date.toString()).length - 2) +
-      '/' +
-      ('0000' + (total + 1).toString()).substr(('0000' + (total + 1).toString()).length - 4)
-
-    // //Save All Data//
-    const createdClaim: Claim = await tx.getRepository(Claim).save({
-      ...claim,
-      name: claimName,
-      bizplace: bizplace,
-      transportDriver: transportDriver,
-      transportVehicle: transportVehicle,
-      status: 'PENDING',
-      domain: context.state.domain,
-      creator: context.state.user,
-      updater: context.state.user
-    })
-
-    const claimOrders = await Promise.all(
-      newClaimOrders.map(async (claimOrder: ClaimOrder) => {
-        return {
-          ...claimOrder,
-          claim: createdClaim,
-          domain: context.state.domain,
-          creator: context.state.user,
-          updater: context.state.user
-        }
-      })
-    )
-
-    const claimDetails = await Promise.all(
-      claim.claimDetails.map(async (claimDetail: NewClaimDetail) => {
-        return {
-          ...claimDetail,
-          claim: createdClaim,
-          domain: context.state.domain,
-          creator: context.state.user,
-          updater: context.state.user
-        }
-      })
-    )
-
-    await tx.getRepository(ClaimOrder).save(claimOrders)
-    await tx.getRepository(ClaimDetail).save(claimDetails)
-    //Save All Data//
-
-    return createdClaim
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Claim)
-  async updateClaim(
-    @Arg('id') id: string,
-    @Arg('patch', type => ClaimPatch) patch: ClaimPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<Claim> {
-    try {
-      const { tx } = context.state
-      const targetClaim: Claim = await tx.getRepository(Claim).findOne({
-        where: { domain: { id: context.state.domain.id }, id },
-        relations: ['claimDetails', 'claimOrders', 'bizplace', 'updater']
-      })
-      if (!targetClaim) throw new Error('claim not exists')
-
-      let bizplace = await tx.getRepository(Bizplace).findOne({
-        where: {
-          domain: { id: context.state.domain.id },
-          id: patch.bizplace
-        }
-      })
-
-      tx.query(`
-          DELETE FROM
-            claim_orders
-          WHERE
-            claim_id = '${targetClaim.id}'
-        `)
-      tx.query(`
-          DELETE FROM
-            claim_details
-          WHERE
-            claim_id = '${targetClaim.id}'
-        `)
-
-      let arrClaimOrdersName = patch.claimOrders.map(item => {
-        return item.name
-      })
-
-      let newClaimOrders = []
-      let deliveryOrder = await tx.getRepository(DeliveryOrder).find({
-        where: { name: In(arrClaimOrdersName), domain: { id: context.state.domain.id } }
-      })
-
-      let collectionOrder = await tx.getRepository(CollectionOrder).find({
-        where: { name: In(arrClaimOrdersName), domain: { id: context.state.domain.id } }
-      })
-
-      deliveryOrder.map(order => {
-        newClaimOrders.push({
-          name: order.name,
-          deliveryOrder: order
-        })
-      })
-
-      collectionOrder.map(order => {
-        newClaimOrders.push({
-          name: order.name,
-          collectionOrder: order
-        })
-      })
-
-      debugger
-      await tx.getRepository(Claim).save({
-        ...targetClaim,
-        ...patch,
-        bizplace: bizplace,
-        updater: context.state.user
-      } as any)
-
-      const claimOrders = await Promise.all(
-        newClaimOrders.map(async (ClaimOrder: ClaimOrder) => {
-          return {
-            ...ClaimOrder,
-            claim: targetClaim,
-            domain: context.state.domain,
-            creator: context.state.user,
-            updater: context.state.user
-          }
-        })
-      )
-
-      const claimDetails = await Promise.all(
-        patch.claimDetails.map(async (claimDetail: ClaimDetailPatch) => {
-          return {
-            ...claimDetail,
-            claim: targetClaim,
-            domain: context.state.domain,
-            creator: context.state.user,
-            updater: context.state.user
-          }
-        })
-      )
-
-      await tx.getRepository(ClaimOrder).save(claimOrders)
-      await tx.getRepository(ClaimDetail).save(claimDetails)
-
-      return targetClaim
-    } catch (e) {
-      throw e
-    }
-  }
-
-  @Mutation(returns => [Claim])
-  async updateMultipleClaim(
-    @Arg('patches', type => [ClaimPatch]) patches: ClaimPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Claim[]> {
-    let results: Claim[] = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const claimRepo = getRepository(Claim)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await claimRepo.save({
-          ...newRecord,
-          domain: context.state.domain,
-          creator: context.state.user,
-          updater: context.state.user
-        } as any)
-
-        results.push(result)
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const claim = await claimRepo.findOneBy({ id: newRecord.id })
-
-        const result = await claimRepo.save({
-          ...claim,
-          ...newRecord,
-          updater: context.state.user
-        } as any)
-
-        results.push(result)
-      }
-    }
-
-    return results
-  }
-
-  @Mutation(returns => Boolean)
-  async deleteClaim(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    await getRepository(Claim).delete({ domain: { id: context.state.domain.id }, name })
-    return true
-  }
-
-  @Mutation(returns => Boolean)
-  async deleteClaims(
-    @Arg('names', type => [String]) names: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    await getRepository(Claim).delete({
-      domain: { id: context.state.domain.id },
-      name: In(names)
-    })
-
-    return true
-  }
-}

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

@@ -1,122 +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 { ClaimList } from '../'
-import { Claim } from './claim'
-
-@Resolver(Claim)
-export class ClaimQuery {
-  @Query(returns => Claim)
-  async claim(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Claim> {
-    return await getRepository(Claim).findOne({
-      where: {
-        domain: { id: context.state.domain.id },
-        id
-      },
-      relations: [
-        'domain',
-        'claimDetails',
-        'claimOrders',
-        'transportDriver',
-        'transportVehicle',
-        'bizplace',
-        'creator',
-        'updater'
-      ]
-    })
-  }
-
-  @Query(returns => ClaimList)
-  async claims(
-    @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<ClaimList> {
-    const convertedParams = convertListParams({ filters, pagination, sortings })
-    let [items, total] = await getRepository<Claim>(Claim).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'creator', 'updater', 'bizplace', 'transportVehicle', 'transportDriver', 'claimDetails']
-    })
-
-    return { items, total }
-  }
-
-  @Query(returns => [Claim])
-  async claimOrderList(
-    @Ctx() context: ResolverContext,
-    @Arg('transportDriver', { nullable: true }) transportDriver?: string,
-    @Arg('transportVehicle', { nullable: true }) transportVehicle?: string
-  ): Promise<Claim[]> {
-    let domainId = context.state.domain.id
-    let arrOrders = []
-    if (transportDriver && transportVehicle && transportDriver !== '' && transportVehicle !== '') {
-      arrOrders = await getRepository(Claim).query(`
-        select delOrd.id, delOrd.name AS name from transport_order_details transportOrd
-          inner join delivery_orders delOrd on delOrd.id = transportord.delivery_order_id and delOrd.domain_id = transportOrd.domain_id
-          where delOrd.name NOT IN (SELECT name FROM claim_orders) AND 
-          truck_no IS NULL AND delOrd.domain_id = '${domainId}' AND
-          transport_driver_id = '${transportDriver}' and transport_vehicle_id = '${transportVehicle}'
-          AND status = 'DONE'
-        UNION
-        select colOrd.id, colOrd.name AS name from transport_order_details transportOrd
-          inner join collection_orders colOrd on colOrd.id = transportord.collection_order_id and colOrd.domain_id = transportOrd.domain_id
-          where colOrd.name NOT IN (SELECT name FROM claim_orders) AND 
-          truck_no IS NULL AND colOrd.domain_id = '${domainId}' AND
-          transport_driver_id = '${transportDriver}' and transport_vehicle_id = '${transportVehicle}'  
-          AND status = 'DONE'
-      `)
-    }
-    return arrOrders
-  }
-
-  @Query(returns => Claim)
-  async claimOrderDetail(
-    @Ctx() context: ResolverContext,
-    @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[]
-  ): Promise<Claim> {
-    let claim = new Claim()
-    // let deliveryOrder = await getRepository(DeliveryOrder).findOne({
-    //   where: {
-    //     domain: { id: context.state.domain.id },
-    //     name: params.filters[0].value
-    //   },
-    //   relations: ['domain', 'bizplace', 'transportDriver', 'transportVehicle', 'creator', 'updater']
-    // })
-
-    // let collectionOrder = await getRepository(CollectionOrder).findOne({
-    //   where: {
-    //     domain: { id: context.state.domain.id },
-    //     name: params.filters[0].value
-    //   },
-    //   relations: ['domain', 'bizplace', 'transportDriver', 'transportVehicle', 'creator', 'updater']
-    // })
-    // var x = await getRepository(Claim).findOne({
-    //   where: {
-    //     domain: { id: context.state.domain.id },
-    //     deliveryOrder: 'DO-201992495155390'
-    //   },
-    //   relations: ['deliveryOrder']
-    // })
-
-    // claim.deliveryOrder = deliveryOrder
-    // claim.collectionOrder = collectionOrder
-    return claim
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() claim: Claim): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: claim.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() claim: Claim): Promise<User> {
-    return await getRepository(User).findOneBy({ id: claim.creatorId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() claim: Claim): Promise<User> {
-    return await getRepository(User).findOneBy({ id: claim.updaterId })
-  }
-}

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

@@ -1,130 +0,0 @@
-import { Field, InputType, Int, ObjectType } from 'type-graphql'
-import { ClaimDetailPatch, NewClaimDetail } from '../claim-detail/claim-detail-types'
-import { ClaimOrderPatch, NewClaimOrder } from '../claim-order/claim-order-types'
-import { Claim } from './claim'
-
-@ObjectType()
-export class ClaimList {
-  @Field(type => [Claim], { nullable: true })
-  items: Claim[]
-
-  @Field(type => Int, { nullable: true })
-  total: number
-}
-
-@InputType()
-export class NewClaim {
-  @Field({ nullable: true })
-  name: string
-
-  @Field({ nullable: true })
-  description: string
-
-  @Field({ nullable: true })
-  billingMode: string
-
-  @Field({ nullable: true })
-  charges: number
-
-  @Field({ nullable: true })
-  transportDriver: string
-
-  @Field({ nullable: true })
-  transportVehicle: string
-
-  @Field({ nullable: true })
-  from: string
-
-  @Field({ nullable: true })
-  to: string
-
-  @Field({ nullable: true })
-  remark: string
-
-  @Field({ nullable: true })
-  bizplace: string
-
-  @Field({ nullable: true })
-  drum: number
-
-  @Field({ nullable: true })
-  pallet: number
-
-  @Field({ nullable: true })
-  carton: number
-
-  @Field({ nullable: true })
-  bag: number
-
-  @Field({ nullable: true })
-  other: number
-
-  @Field(type => [NewClaimDetail], { nullable: true })
-  claimDetails: NewClaimDetail[]
-
-  @Field(type => [NewClaimOrder], { nullable: true })
-  claimOrders: NewClaimOrder[]
-}
-
-@InputType()
-export class ClaimPatch {
-  @Field({ nullable: true })
-  id: string
-
-  @Field({ nullable: true })
-  name: string
-
-  @Field({ nullable: true })
-  description: string
-
-  @Field({ nullable: true })
-  cuFlag: string
-
-  @Field({ nullable: true })
-  billingMode: string
-
-  @Field({ nullable: true })
-  charges: number
-
-  @Field({ nullable: true })
-  transportDriver: string
-
-  @Field({ nullable: true })
-  transportVehicle: string
-
-  @Field({ nullable: true })
-  from: string
-
-  @Field({ nullable: true })
-  to: string
-
-  @Field({ nullable: true })
-  remark: string
-
-  @Field({ nullable: true })
-  bizplace: string
-
-  @Field({ nullable: true })
-  status: string
-
-  @Field({ nullable: true })
-  drum: number
-
-  @Field({ nullable: true })
-  pallet: number
-
-  @Field({ nullable: true })
-  carton: number
-
-  @Field({ nullable: true })
-  bag: number
-
-  @Field({ nullable: true })
-  other: number
-
-  @Field(type => [ClaimDetailPatch], { nullable: true })
-  claimDetails: ClaimDetailPatch[]
-
-  @Field(type => [ClaimOrderPatch], { nullable: true })
-  claimOrders: ClaimOrderPatch[]
-}

package/server/service/claim/claim.ts

@@ -1,140 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { TransportDriver, TransportVehicle } from '@things-factory/transport-base'
-import { Field, ID, ObjectType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  JoinColumn,
-  ManyToOne,
-  OneToMany,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-import { ClaimDetail, ClaimOrder } from '../'
-
-@Entity()
-@Index('ix_claim_0', (claim: Claim) => [claim.domain, claim.id], { unique: true })
-@ObjectType()
-export class Claim {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain, { nullable: true })
-  domain: Domain
-
-  @RelationId((claim: Claim) => claim.domain)
-  domainId: string
-
-  @Column()
-  @Field()
-  name: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  billingMode: string
-
-  @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 })
-  charges: number
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  drum: number
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  pallet: number
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  carton: number
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  bag: number
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  other: number
-
-  @Column()
-  @Field()
-  status: string
-
-  @CreateDateColumn()
-  @Field()
-  createdAt: Date
-
-  @UpdateDateColumn()
-  @Field()
-  updatedAt: Date
-
-  @OneToMany(type => ClaimDetail, claimDetail => claimDetail.claim)
-  @Field(type => [ClaimDetail], { nullable: true })
-  claimDetails: ClaimDetail[]
-
-  @OneToMany(type => ClaimOrder, claimOrder => claimOrder.claim)
-  @Field(type => [ClaimOrder], { nullable: true })
-  claimOrders: ClaimOrder[]
-
-  @ManyToOne(type => TransportDriver)
-  @JoinColumn()
-  @Field(type => TransportDriver, { nullable: true })
-  transportDriver: TransportDriver
-
-  @RelationId((claim: Claim) => claim.transportDriver)
-  transportDriverId: string
-
-  @ManyToOne(type => TransportVehicle)
-  @JoinColumn()
-  @Field(type => TransportVehicle, { nullable: true })
-  transportVehicle: TransportVehicle
-
-  @RelationId((claim: Claim) => claim.transportVehicle)
-  transportVehicleId: string
-
-  @ManyToOne(type => Bizplace, { nullable: true })
-  @JoinColumn()
-  @Field(type => Bizplace, { nullable: true })
-  bizplace: Bizplace
-
-  @RelationId((claim: Claim) => claim.bizplace)
-  bizplaceId: string
-
-  @ManyToOne(type => User)
-  @Field(type => User, { nullable: true })
-  creator: User
-
-  @RelationId((claim: Claim) => claim.creator)
-  creatorId: string
-
-  @ManyToOne(type => User)
-  @Field(type => User, { nullable: true })
-  updater: User
-
-  @RelationId((claim: Claim) => claim.updater)
-  updaterId: string
-}

package/server/service/claim/index.ts

@@ -1,9 +0,0 @@
-import { Claim } from './claim'
-import { ClaimMutation } from './claim-mutation'
-import { ClaimQuery } from './claim-query'
-
-export const entities = [Claim]
-export const resolvers = [ClaimQuery, ClaimMutation]
-
-export * from './claim-mutation'
-export * from './claim-query'