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

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

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

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

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

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

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