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

package/server/service/job-sheet/job-sheet-query.ts

@@ -0,0 +1,112 @@
+import { Arg, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { SelectQueryBuilder } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+import { buildQuery, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
+
+import { ArrivalNotice, JobSheetList } from '../'
+import { JobSheet } from './job-sheet'
+
+@Resolver(JobSheet)
+export class JobSheetQuery {
+  @Directive('@transaction')
+  @Query(returns => JobSheetList)
+  async jobSheets(
+    @Ctx() context: ResolverContext,
+    @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<JobSheetList> {
+    const { domain, user, tx } = context.state
+
+    const bizplaceFilter = filters.find(param => param.name === 'bizplaceId')
+    const containerNoFilter = filters.find(param => param.name === 'containerNo')
+    const jobSheetNoFilter = filters.find(param => param.name === 'name')
+    const fromDateFilter = filters.find(param => param.name === 'fromDate')
+    const toDateFilter = filters.find(param => param.name === 'toDate')
+
+    if (!bizplaceFilter) {
+      filters.push({
+        name: 'bizplaceId',
+        operator: 'in',
+        value: await getPermittedBizplaceIds(domain, user),
+        relation: false
+      })
+    }
+
+    let fromDateValue: Date = new Date(fromDateFilter.value)
+    let toDateValue: Date = new Date(toDateFilter.value)
+    toDateValue.setDate(toDateValue.getDate() + 1)
+
+    const qb: SelectQueryBuilder<JobSheet> = tx.getRepository(JobSheet).createQueryBuilder('js')
+    buildQuery(qb, { filters, pagination, sortings }, context)
+    qb.innerJoinAndSelect('js.domain', 'domain')
+    qb.innerJoinAndSelect('js.bizplace', 'bizplace')
+    qb.innerJoinAndSelect('js.creator', 'creator')
+    qb.innerJoinAndSelect('js.updater', 'updater')
+    qb.where('js.domain_id = :domainId', { domainId: domain.id })
+
+    if (fromDateFilter && toDateFilter) {
+      qb.andWhere('js.updatedAt >= :fromDate', { fromDate: fromDateValue.toISOString() })
+      qb.andWhere('js.updatedAt <= :toDate', { toDate: toDateValue.toISOString() })
+    }
+
+    if (containerNoFilter) {
+      qb.andWhere('js.container_no ILIKE :containerNo', { containerNo: containerNoFilter.value })
+    }
+
+    if (jobSheetNoFilter) {
+      qb.andWhere('js.name ILIKE :name', { name: jobSheetNoFilter.value })
+    }
+
+    if (bizplaceFilter) {
+      qb.andWhere('js.bizplace_id = :bizplaceId', { bizplaceId: bizplaceFilter.value })
+    }
+
+    const [items, total] = await qb.getManyAndCount()
+    return { items, total }
+  }
+
+  @Directive('transaction')
+  @Query(returns => JobSheet)
+  async jobSheet(
+    @Arg('arrivalNoticeRefNo') arrivalNoticeRefNo: string,
+    @Ctx() context: ResolverContext
+  ): Promise<JobSheet> {
+    const { domain, tx } = context.state
+
+    const jobSheet: JobSheet = await tx.getRepository(JobSheet).findOne({
+      where: { domain: { id: domain.id }, arrivalNoticeRefNo },
+      relations: ['domain', 'bizplace', 'creator', 'updater']
+    })
+
+    if (!jobSheet) throw new Error('No job sheet is found')
+
+    const arrivalNotice: ArrivalNotice = await tx.getRepository(ArrivalNotice).findOne({
+      where: { name: jobSheet.arrivalNoticeRefNo, bizplace: { id: jobSheet.bizplace.id } }
+    })
+
+    return {
+      ...jobSheet,
+      looseItem: arrivalNotice?.looseItem,
+      etaDate: arrivalNotice?.etaDate,
+      ata: arrivalNotice?.ata
+    }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() jobSheet: JobSheet): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: jobSheet.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() jobSheet: JobSheet): Promise<User> {
+    return await getRepository(User).findOneBy({ id: jobSheet.creatorId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() jobSheet: JobSheet): Promise<User> {
+    return await getRepository(User).findOneBy({ id: jobSheet.updaterId })
+  }
+}

package/server/service/job-sheet/job-sheet-types.ts

@@ -0,0 +1,78 @@
+import {
+  Field,
+  Float,
+  InputType,
+  Int,
+  ObjectType
+} from 'type-graphql'
+
+import { JobSheet } from './job-sheet'
+
+@ObjectType()
+export class JobSheetList {
+  @Field(type => [JobSheet], { nullable: true })
+  items: JobSheet[]
+
+  @Field(type => Int, { nullable: true })
+  total: number
+}
+
+@InputType()
+export class NewJobSheet {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  containerMtDate: string
+
+  @Field({ nullable: true })
+  containerSize: string
+
+  @Field({ nullable: true })
+  adviseMtDate: string
+
+  @Field(type => Float, { nullable: true })
+  sumPackQty: number
+
+  @Field(type => Int, { nullable: true })
+  sumPalletQty: number
+
+  @Field({ nullable: true })
+  containerNo: string
+
+  @Field({ nullable: true })
+  arrivalNoticeRefNo: string
+}
+
+@InputType()
+export class JobSheetPatch {
+  @Field({ nullable: true })
+  name: string
+
+  @Field({ nullable: true })
+  ata: string
+
+  @Field({ nullable: true })
+  description: string
+
+  @Field({ nullable: true })
+  adviseMtDate: string
+
+  @Field({ nullable: true })
+  containerMtDate: string
+
+  @Field(type => Float, { nullable: true })
+  sumPackQty: number
+
+  @Field(type => Int, { nullable: true })
+  sumPalletQty: number
+
+  @Field({ nullable: true })
+  arrivalNoticeRefNo: string
+
+  @Field({ nullable: true })
+  containerNo: string
+}

package/server/service/job-sheet/job-sheet.ts

@@ -0,0 +1,102 @@
+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,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+@Entity()
+@Index('ix_job-sheet_0', (jobSheet: JobSheet) => [jobSheet.domain, jobSheet.name, jobSheet.arrivalNoticeRefNo], {
+  unique: true
+})
+@ObjectType()
+export class JobSheet {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain: Domain
+
+  @RelationId((jobSheet: JobSheet) => jobSheet.domain)
+  domainId: string
+
+  @ManyToOne(type => Bizplace)
+  @Field(type => Bizplace, { nullable: true })
+  bizplace: Bizplace
+
+  @RelationId((jobSheet: JobSheet) => jobSheet.bizplace)
+  bizplaceId: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  containerMtDate: String
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  adviseMtDate: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  containerNo: String
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  containerSize: String
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  sumPalletQty: number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  arrivalNoticeRefNo: string
+
+  @CreateDateColumn()
+  @Field()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  @Field()
+  updatedAt: Date
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  creator: User
+
+  @RelationId((jobSheet: JobSheet) => jobSheet.creator)
+  creatorId: string
+
+  @ManyToOne(type => User)
+  @Field(type => User, { nullable: true })
+  updater: User
+
+  @RelationId((jobSheet: JobSheet) => jobSheet.updater)
+  updaterId: string
+
+  @Field({ nullable: true })
+  looseItem: boolean
+
+  @Field({ nullable: true })
+  etaDate: string
+
+  @Field({ nullable: true })
+  ata: Date
+}

package/server/service/manifest/index.ts

@@ -0,0 +1,6 @@
+import { Manifest } from './manifest'
+import { ManifestQuery } from './manifest-query'
+import { ManifestMutation } from './manifest-mutation'
+
+export const entities = [Manifest]
+export const resolvers = [ManifestQuery, ManifestMutation]

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

@@ -0,0 +1,190 @@
+import i18next from 'i18next'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In, Not } from 'typeorm'
+
+import { DISPATCHMENT_STATUS, MANIFEST_STATUS } from '../../constants'
+import { OrderNoGenerator } from '../../utils'
+import { ReleaseGood } from '../release-good/release-good'
+import { Manifest, ManifestStatus } from './manifest'
+import { ManifestPatch, NewManifest } from './manifest-type'
+
+@Resolver(Manifest)
+export class ManifestMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To update Manifest' })
+  async updateManifest(
+    @Arg('manifestId', { nullable: true }) manifestId: string,
+    @Arg('status', { nullable: true }) status: string,
+    @Arg('shippingProvider', { nullable: true }) shippingProvider: string,
+    @Arg('removeOrders', type => [String], { nullable: true }) removeOrders: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+    const ManifestRepo = tx.getRepository(Manifest)
+    //update status
+    if (status) {
+      if (status == MANIFEST_STATUS.OPEN) {
+        //check if there is only one manifest is open, if yes update it to in queue and update current to open
+
+        let foundOpenOrder = await ManifestRepo.find({
+          where: { domain: { id: domain.id }, shippingProvider, status: MANIFEST_STATUS.OPEN as any }
+        })
+
+        if (foundOpenOrder.length == 1) {
+          await ManifestRepo.update({ id: foundOpenOrder[0].id }, { status: MANIFEST_STATUS.IN_QUEUE as any })
+        } else if (foundOpenOrder.length > 1) {
+          let manifestNames = foundOpenOrder.map(itm => itm.name)
+          throw new Error(i18next.t('error.Manifest(s) (x) already in open status', { x: manifestNames.toString() }))
+        }
+      }
+
+      await ManifestRepo.update({ id: manifestId }, { status: status as any })
+    }
+
+    //remove orders from manifest
+    if (removeOrders?.length > 0) {
+      //check if user removing all tracking no, if yes then delete
+      let totalTrackingNo = await tx.getRepository(ReleaseGood).count({ where: { manifest: { id: manifestId } } })
+      await tx
+        .getRepository(ReleaseGood)
+        .update(
+          { domain: { id: domain.id }, refNo: In(removeOrders) },
+          { manifest: null, manifestedBy: null, manifestedAt: null }
+        )
+      if (removeOrders.length == totalTrackingNo) {
+        await tx.getRepository(Manifest).delete(manifestId)
+        return false
+      }
+    }
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete Manifest' })
+  async deleteManifest(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Manifest).delete({ domain: { id: domain.id }, name })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To generate new Manifest' })
+  async generateManifest(@Arg('manifest') manifest: NewManifest, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, user, tx } = context.state
+    const manifestItems: any[] = manifest.manifestItems
+
+    // regroup array of object by transporter
+    let shippingProviderGrouping: any = manifestItems.reduce((a, b) => {
+      a[b.transporter] = [...(a[b.transporter] || []), b]
+      return a
+    }, {})
+
+    for (const transporter in shippingProviderGrouping) {
+      const items: any[] = shippingProviderGrouping[transporter]
+
+      const openManifest: Manifest = await tx
+        .getRepository(Manifest)
+        .findOneBy({ domain: { id: domain.id }, shippingProvider: transporter, status: ManifestStatus.OPEN })
+
+      let manifest: Manifest
+
+      if (openManifest) {
+        manifest = openManifest
+      } else {
+        manifest = new Manifest()
+        manifest.domain = domain
+        manifest.shippingProvider = transporter
+        manifest.name = OrderNoGenerator.manifest()
+        manifest.creator = user
+        manifest = await tx.getRepository(Manifest).save(manifest)
+      }
+
+      await Promise.all(
+        items.map(async item => {
+          let releaseOrder: ReleaseGood = await tx
+            .getRepository(ReleaseGood)
+            .findOneBy({ domain: { id: domain.id }, refNo: item.refNo, trackingNo: item.trackingNo })
+          releaseOrder.manifest = manifest
+          releaseOrder.updater = user
+          releaseOrder.manifestedBy = user
+          releaseOrder.manifestedAt = new Date()
+          await tx.getRepository(ReleaseGood).save(releaseOrder)
+        })
+      )
+    }
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To add tracking no into manifest' })
+  async addTrackingNo(
+    @Arg('manifestId', { nullable: true }) manifestId: string,
+    @Arg('trackingNo', { nullable: true }) trackingNo: string,
+    @Arg('shippingProvider', { nullable: true }) shippingProvider: string,
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, user, tx } = context.state
+    const releaseGoodRepo = tx.getRepository(ReleaseGood)
+    //check if order belongs to same shipping provider
+    let foundReleaseOrder = await releaseGoodRepo.findOne({ where: { trackingNo }, relations: ['manifest'] })
+
+    if (!foundReleaseOrder) {
+      throw new Error(i18next.t('error.release_order_not_found'))
+    }
+
+    if (foundReleaseOrder.manifest) {
+      throw new Error(i18next.t('error.tracking_no_already_scanned_before'))
+    }
+
+    if (foundReleaseOrder.transporter !== shippingProvider) {
+      throw new Error(i18next.t('error.tracking_no_belongs_to_x', { x: foundReleaseOrder.transporter }))
+    }
+
+    await releaseGoodRepo.update(
+      { id: foundReleaseOrder.id },
+      { manifest: { id: manifestId }, manifestedAt: new Date(), manifestedBy: user }
+    )
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Manifest, { description: 'To dispatch Manifest when courier service collect packages' })
+  async dispatchManifest(
+    @Arg('name') name: string,
+    @Arg('patch') patch: ManifestPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Manifest> {
+    const { domain, user, tx } = context.state
+
+    const manifest: Manifest = await tx.getRepository(Manifest).findOne({
+      where: { domain: { id: domain.id }, name, status: Not(MANIFEST_STATUS.CLOSED) as any }
+    })
+    if (!manifest) throw new Error(`Unable to find ${name}`)
+
+    let releaseGoods: any[] = await tx
+      .getRepository(ReleaseGood)
+      .find({ where: { domain: { id: domain.id }, manifest: { id: manifest.id } } })
+
+    releaseGoods = await Promise.all(
+      releaseGoods.map((releaseGood: ReleaseGood) => {
+        return {
+          ...releaseGood,
+          dispatchmentStatus: DISPATCHMENT_STATUS.DISPATCHED,
+          updater: user
+        }
+      })
+    )
+    await tx.getRepository(ReleaseGood).save(releaseGoods)
+
+    return await tx.getRepository(Manifest).save({
+      ...manifest,
+      ...patch,
+      status: ManifestStatus.CLOSED,
+      dispatchedAt: new Date(),
+      updater: user
+    })
+  }
+}

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

@@ -0,0 +1,149 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { SelectQueryBuilder } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { buildQuery, convertListParams, Domain, getRepository, ListParam, Sorting } from '@things-factory/shell'
+
+import { ReleaseGood } from '../release-good/release-good'
+import { Manifest } from './manifest'
+import { ManifestList } from './manifest-type'
+
+@Resolver(Manifest)
+export class ManifestQuery {
+  @Query(returns => Manifest, { description: 'To fetch a Manifest' })
+  async manifest(
+    @Arg('name') name: string,
+    @Ctx() context: ResolverContext,
+    @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
+  ): Promise<Manifest> {
+    const phoneSort = sortings.findIndex(sort => sort.name === 'phone')
+    if (phoneSort >= 0) {
+      sortings[phoneSort].name = 'phone1'
+    }
+
+    const deliveryAddressSort = sortings.findIndex(sort => sort.name === 'deliveryAddress')
+    if (deliveryAddressSort >= 0) {
+      sortings[deliveryAddressSort].name = 'deliveryAddress1'
+    }
+
+    const orderRemarkSort = sortings.findIndex(sort => sort.name === 'orderRemark')
+    if (orderRemarkSort >= 0) {
+      sortings[orderRemarkSort].name = 'remark'
+    }
+
+    const orderStatusSort = sortings.findIndex(sort => sort.name === 'orderStatus')
+    if (orderStatusSort >= 0) {
+      sortings[orderStatusSort].name = 'status'
+    }
+    const convertedParams = convertListParams({ sortings })
+    const { domain, tx } = context.state
+    const manifest: Manifest = await getRepository(Manifest).findOne({ where: { domain: { id: domain.id }, name } })
+
+    const releaseGoods: ReleaseGood[] = await getRepository(ReleaseGood).find({
+      ...convertedParams,
+      where: { manifest: { id: manifest.id } }
+    })
+
+    const trackingNos: any[] = releaseGoods.map(releaseGood => {
+      return {
+        trackingNo: releaseGood.trackingNo,
+        refNo: releaseGood.refNo,
+        deliveryAddress: releaseGood.deliveryAddress1,
+        attentionTo: releaseGood.attentionTo,
+        postalCode: releaseGood.postalCode,
+        city: releaseGood.city,
+        phone: releaseGood.phone1,
+        dispatchmentStatus: releaseGood.dispatchmentStatus,
+        orderStatus: releaseGood.status,
+        orderRemark: releaseGood.remark
+      }
+    })
+
+    return {
+      ...manifest,
+      trackingNos
+    }
+  }
+
+  @Query(returns => ManifestList, { description: 'To fetch multiple Manifests' })
+  async manifests(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<ManifestList> {
+    const { domain } = context.state
+
+    let orderInfoFilter
+    const orderInfoParamIdx = params.filters.findIndex(param => param.name === 'orderInfo')
+    if (orderInfoParamIdx >= 0) {
+      orderInfoFilter = params.filters[orderInfoParamIdx].value.toLowerCase().split(',').join('|')
+
+      params.filters.splice(orderInfoParamIdx, 1)
+    }
+
+    let trackingNoFilter
+    const trackingNoParamIdx = params.filters.findIndex(param => param.name === 'trackingNo')
+    if (trackingNoParamIdx >= 0) {
+      trackingNoFilter = params.filters[trackingNoParamIdx].value
+
+      params.filters.splice(trackingNoParamIdx, 1)
+    }
+
+    const fromDateParamIdx = params.filters.findIndex(param => param.name === 'fromDate')
+    if (fromDateParamIdx >= 0) {
+      let fromDateVal = new Date(params.filters[fromDateParamIdx].value)
+      params.filters.splice(fromDateParamIdx, 1)
+
+      params.filters.push({
+        name: 'createdAt',
+        operator: 'gte',
+        value: fromDateVal.toISOString(),
+        relation: false
+      })
+    }
+
+    const toDateParamIdx = params.filters.findIndex(param => param.name === 'toDate')
+    if (toDateParamIdx >= 0) {
+      let toDateVal = new Date(params.filters[toDateParamIdx].value)
+      params.filters.splice(toDateParamIdx, 1)
+
+      params.filters.push({
+        name: 'createdAt',
+        operator: 'lt',
+        value: new Date(toDateVal.setDate(toDateVal.getDate() + 1)).toISOString(),
+        relation: false
+      })
+    }
+
+    const qb: SelectQueryBuilder<Manifest> = getRepository(Manifest).createQueryBuilder('mf')
+    buildQuery(qb, params, context)
+    qb.innerJoin('release_goods', 'rg', 'rg.manifest_id = mf.id')
+    orderInfoFilter
+      ? qb.andWhere(
+          '(rg.name ~* :orderInfoFilter or rg.ref_no ~* :orderInfoFilter or rg.ref_no_2 ~* :orderInfoFilter or rg.ref_no_3 ~* :orderInfoFilter)',
+          { orderInfoFilter }
+        )
+      : ''
+    trackingNoFilter ? qb.andWhere('rg.tracking_no ilike :trackingNo', { trackingNo: trackingNoFilter }) : ''
+
+    const [items, total] = await qb.getManyAndCount()
+
+    await Promise.all(
+      items.map(async item => {
+        item.totalTrackingNo = await getRepository(ReleaseGood).count({ where: { manifest: { id: item.id } } })
+      })
+    )
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() manifest: Manifest): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: manifest.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() manifest: Manifest): Promise<User> {
+    return await getRepository(User).findOneBy({ id: manifest.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() manifest: Manifest): Promise<User> {
+    return await getRepository(User).findOneBy({ id: manifest.creatorId })
+  }
+}