@things-factory/integration-lmd 8.0.0-beta.9 → 8.0.0

package/server/engine/task/lmd-api.ts

@@ -0,0 +1,64 @@
+import { ConnectionManager, TaskRegistry } from '@things-factory/integration-base'
+import { getRepository } from '@things-factory/shell'
+import { access } from '@things-factory/utils'
+
+import { LastMileAPI as API } from '../../controllers/lmd-api'
+import { LastMileDelivery } from '../../entities'
+
+async function LastMileAPI(step, { logger, data, domain }) {
+  var {
+    connection,
+    params: { account: name, api, accessor }
+  } = step
+
+  var client = ConnectionManager.getConnectionInstanceByName(domain, connection) || {}
+  if (!client) {
+    throw new Error(`no connection : ${connection}`)
+  }
+
+  if (!api) {
+    throw new Error(`no api defined`)
+  }
+
+  const repository = getRepository(LastMileDelivery)
+  const lastMile: LastMileDelivery = await repository.findOne({
+    where: { domain: { id: domain.id }, name }
+  })
+
+  if (!lastMile) {
+    throw new Error(`no last mile delivery defined`)
+  }
+
+  var result = await API[api](lastMile, accessor ? access(accessor, data) : {})
+
+  return {
+    data: result
+  }
+}
+
+LastMileAPI.parameterSpec = [
+  {
+    type: 'entity-selector',
+    name: 'lastMileDelivery',
+    label: 'lastMileDelivery',
+    property: {
+      queryName: 'lastMileDeliveries',
+      valueKey: 'name'
+    }
+  },
+  {
+    type: 'select',
+    name: 'api',
+    label: 'api',
+    property: {
+      options: ['', 'createShipmentRequest']
+    }
+  },
+  {
+    type: 'string',
+    name: 'accessor',
+    label: 'accessor'
+  }
+]
+
+TaskRegistry.registerTaskHandler('lmd-api', LastMileAPI)

package/server/entities/courier-service.ts

@@ -0,0 +1,44 @@
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { Column, CreateDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
+
+@Entity()
+@Index(
+  'ix_courier_service_0',
+  (courierService: CourierService) => [courierService.domain, courierService.name, courierService.transporterId],
+  {
+    unique: true
+  }
+)
+export class CourierService {
+  @PrimaryGeneratedColumn('uuid')
+  id: string
+
+  @ManyToOne(type => Domain)
+  domain: Domain
+
+  @Column()
+  name: string
+
+  @Column({ nullable: true })
+  description: string
+
+  @Column({ nullable: true })
+  transporterId: string
+
+  @CreateDateColumn()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  updatedAt: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  creator: User
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  updater: User
+}

package/server/entities/index.ts

@@ -0,0 +1,6 @@
+import { CourierService } from './courier-service'
+import { LastMileDelivery } from './last-mile-delivery'
+
+export const entities = [CourierService, LastMileDelivery]
+
+export { CourierService, LastMileDelivery }

package/server/entities/last-mile-delivery.ts

@@ -0,0 +1,84 @@
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  ManyToMany,
+  JoinTable,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn
+} from 'typeorm'
+import { CourierService } from '../entities'
+
+@Entity()
+@Index(
+  'ix_last_mile_delivery_0',
+  (lastMileDelivery: LastMileDelivery) => [lastMileDelivery.domain, lastMileDelivery.id],
+  { unique: true }
+)
+export class LastMileDelivery {
+  @PrimaryGeneratedColumn('uuid')
+  id: string
+
+  @ManyToOne(type => Domain)
+  domain: Domain
+
+  @Column()
+  name: string
+
+  @Column({ nullable: true })
+  description: string
+
+  @Column()
+  platform: string
+
+  @ManyToMany(type => CourierService)
+  @JoinTable()
+  courierServices: CourierService[]
+
+  @Column({ nullable: true })
+  clientId: string
+
+  @Column({ nullable: true })
+  clientType: string
+
+  @Column({ nullable: true })
+  clientName: string
+
+  @Column()
+  countryCode: string
+
+  @Column({ nullable: true })
+  secretKey: string
+
+  @Column({ nullable: true })
+  accessInfo: string
+
+  @Column({ nullable: true })
+  accessToken: string
+
+  @Column({ nullable: true })
+  refreshToken: string
+
+  @Column()
+  status: string
+
+  @CreateDateColumn()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  updatedAt: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  creator: User
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  updater: User
+}

package/server/graphql/index.ts

@@ -0,0 +1,9 @@
+import { deepMerge } from '@things-factory/utils'
+
+import * as resolvers from './resolvers'
+import * as typeDefs from './types'
+
+export const schema = {
+  typeDefs,
+  resolvers: deepMerge.apply(null, Object.values(resolvers))
+}

package/server/graphql/resolvers/courier-service/courier-service-query.ts

@@ -0,0 +1,54 @@
+import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { CourierService as CourierServiceEntity } from '../../../entities'
+
+export const Query = {
+  async courierService(_: any, { name }, context: ResolverContext) {
+    const { domain, user, tx } = context.state
+    const repository = tx.getRepository(CourierServiceEntity)
+
+    return await repository.findOne({
+      where: { domain: { id: domain.id }, name }
+    })
+  },
+
+  async courierServices(_: any, params: ListParam, context: ResolverContext) {
+    const { domain, user, tx } = context.state
+    const convertedParams = convertListParams(params)
+    const [items, total] = await tx.getRepository(CourierServiceEntity).findAndCount({
+      ...convertedParams,
+      where: { domain: { id: domain.id } }
+    })
+
+    return { items, total }
+  }
+}
+
+export const CourierService = {
+  async domain(courierService) {
+    return (
+      await getRepository(CourierServiceEntity).findOne({
+        where: { id: courierService.id },
+        relations: ['domain']
+      })
+    )?.domain
+  },
+
+  async creator(courierService) {
+    return (
+      await getRepository(CourierServiceEntity).findOne({
+        where: { id: courierService.id },
+        relations: ['creator']
+      })
+    )?.creator
+  },
+
+  async updater(courierService) {
+    return (
+      await getRepository(CourierServiceEntity).findOne({
+        where: { id: courierService.id },
+        relations: ['updater']
+      })
+    )?.updater
+  }
+}

package/server/graphql/resolvers/courier-service/create-courier-service.ts

@@ -0,0 +1,16 @@
+import { getRepository } from '@things-factory/shell'
+
+import { CourierService } from '../../../entities'
+
+export const createCourierService = {
+  async createCourierService(_: any, { courierService }, context: ResolverContext) {
+    const { domain, user } = context.state
+
+    return await getRepository(CourierService).save({
+      ...courierService,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+}

package/server/graphql/resolvers/courier-service/delete-courier-service.ts

@@ -0,0 +1,13 @@
+import { getRepository } from '@things-factory/shell'
+
+import { CourierService } from '../../../entities'
+
+export const deleteCourierService = {
+  async deleteCourierService(_: any, { name }, context: ResolverContext) {
+    const { domain, user } = context.state
+
+    await getRepository(CourierService).delete({ domain: { id: domain.id }, name })
+
+    return true
+  }
+}

package/server/graphql/resolvers/courier-service/delete-courier-services.ts

@@ -0,0 +1,18 @@
+import { In } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
+import { CourierService } from '../../../entities'
+
+export const deleteCourierServices = {
+  async deleteCourierServices(_: any, { names }, context: ResolverContext) {
+    const { domain, user } = context.state
+
+    await getRepository(CourierService).delete({
+      domain: { id: domain.id },
+      name: In(names)
+    })
+
+    return true
+  }
+}

package/server/graphql/resolvers/courier-service/index.ts

@@ -0,0 +1,19 @@
+import { Query, CourierService } from './courier-service-query'
+
+import { updateCourierService } from './update-courier-service'
+import { updateMultipleCourierService } from './update-multiple-courier-service'
+import { createCourierService } from './create-courier-service'
+import { deleteCourierService } from './delete-courier-service'
+import { deleteCourierServices } from './delete-courier-services'
+
+export const CourierServiceResolver = {
+  CourierService,
+  Query,
+  Mutation: {
+    ...updateCourierService,
+    ...updateMultipleCourierService,
+    ...createCourierService,
+    ...deleteCourierService,
+    ...deleteCourierServices
+  }
+}

package/server/graphql/resolvers/courier-service/update-courier-service.ts

@@ -0,0 +1,20 @@
+import { getRepository } from '@things-factory/shell'
+
+import { CourierService } from '../../../entities'
+
+export const updateCourierService = {
+  async updateCourierService(_: any, { name, patch }, context: ResolverContext) {
+    const { domain, user } = context.state
+
+    const repository = getRepository(CourierService)
+    const courierService = await repository.findOne({
+      where: { domain: { id: domain.id }, name }
+    })
+
+    return await repository.save({
+      ...courierService,
+      ...patch,
+      updater: user
+    })
+  }
+}

package/server/graphql/resolvers/courier-service/update-multiple-courier-service.ts

@@ -0,0 +1,46 @@
+import { getRepository } from '@things-factory/shell'
+
+import { CourierService } from '../../../entities'
+
+export const updateMultipleCourierService = {
+  async updateMultipleCourierService(_: any, { patches }, context: ResolverContext) {
+    const { domain, user } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const courierServiceRepo = getRepository(CourierService)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await courierServiceRepo.save({
+          ...newRecord,
+          domain: domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const courierService = await courierServiceRepo.findOneBy({ domain: { id: domain.id }, id: newRecord.id })
+
+        const result = await courierServiceRepo.save({
+          ...courierService,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+}

package/server/graphql/resolvers/index.ts

@@ -0,0 +1,2 @@
+export * from './last-mile-delivery'
+export * from './courier-service'

package/server/graphql/resolvers/last-mile-delivery/create-last-mile-delivery.ts

@@ -0,0 +1,14 @@
+import { LastMileDelivery } from '../../../entities'
+
+export const createLastMileDelivery = {
+  async createLastMileDelivery(_: any, { lastMileDelivery }, context: ResolverContext) {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(LastMileDelivery).save({
+      ...lastMileDelivery,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+}

package/server/graphql/resolvers/last-mile-delivery/delete-last-mile-deliveries.ts

@@ -0,0 +1,26 @@
+import { In } from 'typeorm'
+
+import { LMD_STATUS } from '../../../controllers'
+import { LastMileDelivery } from '../../../entities'
+
+export const deleteLastMileDeliveries = {
+  async deleteLastMileDeliveries(_: any, { ids }, context: ResolverContext) {
+    const { domain, user, tx } = context.state
+
+    let lastMileDeliveries: LastMileDelivery[] = await tx.getRepository(LastMileDelivery).find({
+      where: { id: In(ids) }
+    })
+
+    lastMileDeliveries = lastMileDeliveries.map((lastMileDelivery: LastMileDelivery) => {
+      return {
+        ...lastMileDelivery,
+        status: LMD_STATUS.TERMINATED,
+        updater: user
+      }
+    })
+
+    await tx.getRepository(LastMileDelivery).save(lastMileDeliveries)
+
+    return true
+  }
+}

package/server/graphql/resolvers/last-mile-delivery/delete-last-mile-delivery.ts

@@ -0,0 +1,13 @@
+import { getRepository } from '@things-factory/shell'
+
+import { LastMileDelivery } from '../../../entities'
+
+export const deleteLastMileDelivery = {
+  async deleteLastMileDelivery(_: any, { name }, context: ResolverContext) {
+    const { domain, user } = context.state
+
+    await getRepository(LastMileDelivery).delete({ domain: { id: domain.id }, name })
+
+    return true
+  }
+}

package/server/graphql/resolvers/last-mile-delivery/index.ts

@@ -0,0 +1,19 @@
+import { Query, LastMileDelivery } from './last-mile-delivery-query'
+
+import { updateLastMileDelivery } from './update-last-mile-delivery'
+import { updateMultipleLastMileDelivery } from './update-multiple-last-mile-delivery'
+import { createLastMileDelivery } from './create-last-mile-delivery'
+import { deleteLastMileDelivery } from './delete-last-mile-delivery'
+import { deleteLastMileDeliveries } from './delete-last-mile-deliveries'
+
+export const LastMileDeliveryResolver = {
+  LastMileDelivery,
+  Query,
+  Mutation: {
+    ...updateLastMileDelivery,
+    ...updateMultipleLastMileDelivery,
+    ...createLastMileDelivery,
+    ...deleteLastMileDelivery,
+    ...deleteLastMileDeliveries
+  }
+}

package/server/graphql/resolvers/last-mile-delivery/last-mile-delivery-query.ts

@@ -0,0 +1,52 @@
+import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { LastMileDelivery as LastMileDeliveryEntity } from '../../../entities'
+
+export const Query = {
+  async lastMileDelivery(_: any, { name }, context: ResolverContext) {
+    const { domain, user } = context.state
+    const repository = getRepository(LastMileDeliveryEntity)
+
+    return await repository.findOne({
+      where: { domain: { id: domain.id }, name }
+    })
+  },
+
+  async lastMileDeliveries(_: any, params: ListParam, context: ResolverContext) {
+    const convertedParams = convertListParams(params)
+    const [items, total] = await getRepository(LastMileDeliveryEntity).findAndCount({
+      ...convertedParams
+    })
+
+    return { items, total }
+  }
+}
+
+export const LastMileDelivery = {
+  async domain(lastMileDelivery) {
+    return (
+      await getRepository(LastMileDeliveryEntity).findOne({
+        where: { id: lastMileDelivery.id },
+        relations: ['domain']
+      })
+    )?.domain
+  },
+
+  async creator(lastMileDelivery) {
+    return (
+      await getRepository(LastMileDeliveryEntity).findOne({
+        where: { id: lastMileDelivery.id },
+        relations: ['creator']
+      })
+    )?.creator
+  },
+
+  async updater(lastMileDelivery) {
+    return (
+      await getRepository(LastMileDeliveryEntity).findOne({
+        where: { id: lastMileDelivery.id },
+        relations: ['updater']
+      })
+    )?.updater
+  }
+}

package/server/graphql/resolvers/last-mile-delivery/update-last-mile-delivery.ts

@@ -0,0 +1,18 @@
+import { LastMileDelivery } from '../../../entities'
+
+export const updateLastMileDelivery = {
+  async updateLastMileDelivery(_: any, { name, patch }, context: ResolverContext) {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(LastMileDelivery)
+    const lastMileDelivery = await repository.findOne({
+      where: { domain: { id: domain.id }, name }
+    })
+
+    return await repository.save({
+      ...lastMileDelivery,
+      ...patch,
+      updater: user
+    })
+  }
+}

package/server/graphql/resolvers/last-mile-delivery/update-multiple-last-mile-delivery.ts

@@ -0,0 +1,45 @@
+import { LastMileDelivery } from '../../../entities'
+
+export const updateMultipleLastMileDelivery = {
+  async updateMultipleLastMileDelivery(_: any, { patches }, context: ResolverContext) {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const lastMileDeliveryRepo = tx.getRepository(LastMileDelivery)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await lastMileDeliveryRepo.save({
+          ...newRecord,
+          domain: domain,
+          status: 'inactive',
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const lastMileDelivery = await lastMileDeliveryRepo.findOneBy({ domain: { id: domain.id }, id: newRecord.id })
+
+        const result = await lastMileDeliveryRepo.save({
+          ...lastMileDelivery,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+}

package/server/graphql/types/courier-service/courier-service-list.ts

@@ -0,0 +1,8 @@
+import gql from 'graphql-tag'
+
+export const CourierServiceList = gql`
+  type CourierServiceList {
+    items: [CourierService]
+    total: Int
+  }
+`

package/server/graphql/types/courier-service/courier-service-patch.ts

@@ -0,0 +1,11 @@
+import gql from 'graphql-tag'
+
+export const CourierServicePatch = gql`
+  input CourierServicePatch {
+    id: String
+    name: String
+    description: String
+    transporterId: String
+    cuFlag: String
+  }
+`

package/server/graphql/types/courier-service/courier-service.ts

@@ -0,0 +1,15 @@
+import gql from 'graphql-tag'
+
+export const CourierService = gql`
+  type CourierService {
+    id: String
+    name: String
+    domain: Domain
+    description: String
+    transporterId: String
+    updater: User
+    creator: User
+    updatedAt: String
+    createdAt: String
+  }
+`

package/server/graphql/types/courier-service/index.ts

@@ -0,0 +1,21 @@
+import gql from 'graphql-tag'
+
+export * from './courier-service'
+export * from './new-courier-service'
+export * from './courier-service-patch'
+export * from './courier-service-list'
+
+export const CourierServiceResolver = gql`
+  extend type Mutation {
+    createCourierService(courierService: NewCourierService!): CourierService
+    updateCourierService(name: String!, patch: CourierServicePatch!): CourierService
+    updateMultipleCourierService(patches: [CourierServicePatch]!): [CourierService]
+    deleteCourierService(name: String!): Boolean
+    deleteCourierServices(names: [String]!): Boolean
+  }
+
+  extend type Query {
+    courierServices(filters: [Filter], pagination: Pagination, sortings: [Sorting]): CourierServiceList @transaction
+    courierService(name: String!): CourierService @transaction
+  }
+`

package/server/graphql/types/courier-service/new-courier-service.ts

@@ -0,0 +1,9 @@
+import gql from 'graphql-tag'
+
+export const NewCourierService = gql`
+  input NewCourierService {
+    name: String!
+    description: String
+    transporterId: String
+  }
+`

package/server/graphql/types/index.ts

@@ -0,0 +1,2 @@
+export * from './last-mile-delivery'
+export * from './courier-service'