@things-factory/sales-base 8.0.0-beta.0 → 8.0.0-beta.2

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

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

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

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

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

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

@@ -1,149 +0,0 @@
-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 })
-  }
-}