@things-factory/transport-base 8.0.0-beta.1 → 8.0.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/transport-base",
-  "version": "8.0.0-beta.1",
+  "version": "8.0.0-beta.4",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -24,7 +24,7 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@things-factory/biz-base": "^8.0.0-beta.1"
+    "@things-factory/biz-base": "^8.0.0-beta.4"
   },
-  "gitHead": "36c494e587640c1490318ef7b95adab02606e0c2"
+  "gitHead": "d83d12ed4ba07177dff1dac26e37be347d156b43"
 }

package/server/constants/index.ts

@@ -1 +0,0 @@
-export * from './transport'

package/server/constants/transport.ts

@@ -1,10 +0,0 @@
-export const DRIVER_STATUS = {
-  AVAILABLE: 'AVAILABLE',
-  OCCUPIED: 'OCCUPIED'
-}
-
-export const TRUCK_STATUS = {
-  AVAILABLE: 'AVAILABLE',
-  IN_USE: 'IN_USE',
-  ASSIGNED: 'ASSIGNED'
-}

package/server/index.ts

@@ -1,3 +0,0 @@
-export * from './constants'
-export * from './migrations'
-export * from './service'

package/server/migrations/index.ts

@@ -1,9 +0,0 @@
-const glob = require('glob')
-const path = require('path')
-
-export var migrations = []
-
-glob.sync(path.resolve(__dirname, '.', '**', '*.js')).forEach(function(file) {
-  if (file.indexOf('index.js') !== -1) return
-  migrations = migrations.concat(Object.values(require(path.resolve(file))) || [])
-})

package/server/service/index.ts

@@ -1,25 +0,0 @@
-/* IMPORT ENTITIES AND RESOLVERS */
-import { entities as TransportDriverEntity, resolvers as TransportDriverResolvers } from './transport-driver'
-import { entities as TransportVehicleEntity, resolvers as TransportVehicleResolvers } from './transport-vehicle'
-
-/* EXPORT ENTITY TYPES */
-export * from './transport-driver/transport-driver'
-export * from './transport-vehicle/transport-vehicle'
-
-/* EXPORT TYPES */
-export * from './transport-driver/transport-driver-types'
-export * from './transport-vehicle/transport-vehicle-types'
-
-export const entities = [
-  /* ENTITIES */
-  ...TransportDriverEntity,
-  ...TransportVehicleEntity
-]
-
-export const schema = {
-  resolverClasses: [
-    /* RESOLVER CLASSES */
-    ...TransportDriverResolvers,
-    ...TransportVehicleResolvers
-  ]
-}

package/server/service/transport-driver/index.ts

@@ -1,6 +0,0 @@
-import { TransportDriver } from './transport-driver'
-import { TransportDriverMutation } from './transport-driver-mutation'
-import { TransportDriverQuery } from './transport-driver-query'
-
-export const entities = [TransportDriver]
-export const resolvers = [TransportDriverQuery, TransportDriverMutation]

package/server/service/transport-driver/transport-driver-mutation.ts

@@ -1,161 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, In, Repository } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain, getRepository } from '@things-factory/shell'
-
-import { NewTransportDriver, TransportDriverPatch } from '../'
-import { TransportDriver } from './transport-driver'
-
-const debug = require('debug')('things-factory:operato-wms:addTransportDriver')
-
-@Resolver(TransportDriver)
-export class TransportDriverMutation {
-  @Directive('@privilege(category: "transport", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => TransportDriver)
-  async createTransportDriver(
-    @Arg('transportDriver', type => NewTransportDriver) transportDriver: NewTransportDriver,
-    @Ctx() context: ResolverContext
-  ): Promise<TransportDriver> {
-    const { tx, domain, user } = context.state
-    return await createTransportDriver(transportDriver, domain, user, tx)
-  }
-
-  @Directive('@privilege(category: "transport", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => TransportDriver)
-  async updateTransportDriver(
-    @Arg('id') id: string,
-    @Arg('patch', type => TransportDriverPatch) patch: TransportDriverPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<TransportDriver> {
-    const { tx, domain, user } = context.state
-
-    return await updateTransportDriver(id, patch, domain, user, tx)
-  }
-
-  @Directive('@privilege(category: "transport", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deleteTransportDriver(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { tx } = context.state
-
-    return await deleteTransportDriver(id, tx)
-  }
-
-  @Directive('@privilege(category: "transport", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean)
-  async deleteTransportDrivers(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    return await deleteTransportDrivers(ids, context)
-  }
-
-  @Directive('@privilege(category: "transport", privilege: "mutation")')
-  @Directive('@transaction')
-  @Mutation(returns => [TransportDriver])
-  async updateMultipleTransportDriver(
-    @Arg('patches', type => [TransportDriverPatch]) patches: TransportDriverPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<TransportDriver[]> {
-    const { tx, domain, user } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const patch: TransportDriverPatch = _createRecords[i]
-        const result = await createTransportDriver(patch as NewTransportDriver, domain, user, tx)
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const patch: TransportDriverPatch = _updateRecords[i]
-        const result = await updateTransportDriver(patch.id, patch, domain, user, tx)
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-}
-
-export async function createTransportDriver(
-  transportDriver: NewTransportDriver,
-  domain: Domain,
-  user: User,
-  tx?: EntityManager
-) {
-  const repository: Repository<TransportDriver> = tx
-    ? tx.getRepository(TransportDriver)
-    : getRepository(TransportDriver)
-
-  const existingUsers: string[] = (
-    await tx.getRepository(TransportDriver).find({ where: { domain: { id: domain.id } }, relations: ['user'] })
-  ).map(driver => driver.userId)
-  if (existingUsers.includes(transportDriver.userId)) throw new Error('driver user already exists')
-
-  const driverUser = await tx.getRepository(User).findOne({ where: { id: transportDriver.userId } })
-
-  return await repository.save({
-    ...transportDriver,
-    user: driverUser,
-    domain,
-    creator: user,
-    updater: user
-  })
-}
-
-export async function updateTransportDriver(
-  id: string,
-  patch: TransportDriver | TransportDriverPatch,
-  domain: Domain,
-  user: User,
-  tx?: EntityManager
-): Promise<TransportDriver> {
-  const repository: Repository<TransportDriver> = tx
-    ? tx.getRepository(TransportDriver)
-    : getRepository(TransportDriver)
-  const transportDriver = await repository.findOne({
-    where: { domain: { id: domain.id }, id }
-  })
-
-  return await repository.save({
-    ...transportDriver,
-    ...patch,
-    updater: user
-  })
-}
-
-export async function deleteTransportDriver(id: string, tx?: EntityManager) {
-  const repository: Repository<TransportDriver> = tx
-    ? tx.getRepository(TransportDriver)
-    : getRepository(TransportDriver)
-  await repository.delete(id)
-  return true
-}
-
-export async function deleteTransportDrivers(ids: string[], context: ResolverContext) {
-  const { tx, user } = context.state
-
-  const transportDrivers = await tx.getRepository(TransportDriver).find({ where: { id: In(ids) } })
-
-  let deletedTransportDrivers: TransportDriver[] = []
-  deletedTransportDrivers = await Promise.all(
-    transportDrivers.map((transportDriver: TransportDriver) => {
-      transportDriver.deletedAt = new Date()
-      transportDriver.updater = user
-
-      return transportDriver
-    })
-  )
-  await tx.getRepository(TransportDriver).save(deletedTransportDrivers)
-  return true
-}

package/server/service/transport-driver/transport-driver-query.ts

@@ -1,103 +0,0 @@
-import { Arg, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { EntityManager, IsNull } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { buildQuery, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
-
-import { TransportVehicle } from '../transport-vehicle/transport-vehicle'
-import { TransportDriver } from './transport-driver'
-import { TransportDriverList } from './transport-driver-types'
-
-@Resolver(TransportDriver)
-export class TransportDriverQuery {
-  @Directive('@transaction')
-  @Directive('@privilege(category: "transport", privilege: "query", domainOwnerGranted: true)')
-  @Query(returns => TransportDriverList)
-  async transportDrivers(
-    @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<TransportDriverList> {
-    const { domain, tx } = context.state
-
-    const queryBuilder = tx.getRepository(TransportDriver).createQueryBuilder()
-    buildQuery(queryBuilder, { filters, pagination, sortings }, context, {
-      searchables: ['name', 'userEmail', 'driverCode', 'driverTelNo']
-    })
-
-    queryBuilder
-      .leftJoinAndSelect('TransportDriver.domain', 'Domain')
-      .leftJoinAndSelect('TransportDriver.creator', 'Creator')
-      .leftJoinAndSelect('TransportDriver.updater', 'Updater')
-
-    if (filters?.length > 0) {
-      queryBuilder.andWhere('Domain.id = :domainId', { domainId: domain.id }).andWhere('TransportDriver.deletedAt IS NULL')
-    } else {
-      queryBuilder.where('TransportDriver.deletedAt IS NULL').andWhere('Domain.id = :domainId', { domainId: domain.id })
-    }
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "transport", privilege: "query", domainOwnerGranted: true)')
-  @Query(returns => TransportDriver)
-  async transportDriver(@Arg('driverCode') driverCode: string, @Ctx() context: ResolverContext): Promise<TransportDriver> {
-    const { domain, tx } = context.state
-
-    return await tx.getRepository(TransportDriver).findOne({
-      where: { domain: { id: domain.id }, driverCode, deletedAt: IsNull() }
-    })
-  }
-
-  @Directive('@transaction')
-  @Query(returns => TransportDriver)
-  async transportDriverByUser(@Ctx() context: ResolverContext): Promise<TransportDriver> {
-    const { domain, tx, user }: { domain: Domain; tx?: EntityManager; user: User } = context.state
-
-    const driver = await tx.getRepository(TransportDriver).findOne({
-      where: { domain: { id: domain.id }, user: { id: user.id } }
-    })
-
-    return driver
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() transportDriver: TransportDriver): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: transportDriver.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async user(@Root() transportDriver: TransportDriver): Promise<User> {
-    return await getRepository(User).findOneBy({ id: transportDriver.userId })
-  }
-
-  @FieldResolver(type => Bizplace)
-  async bizplace(@Root() transportDriver: TransportDriver): Promise<Bizplace> {
-    return await getRepository(Bizplace).findOneBy({ id: transportDriver.bizplaceId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() transportDriver: TransportDriver): Promise<User> {
-    return await getRepository(User).findOneBy({ id: transportDriver.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() transportDriver: TransportDriver): Promise<User> {
-    return await getRepository(User).findOneBy({ id: transportDriver.creatorId })
-  }
-
-  @FieldResolver(type => [TransportVehicle])
-  async transportVehicles(@Root() transportDriver: TransportDriver): Promise<TransportVehicle[]> {
-    return await (
-      await getRepository(TransportDriver).findOne({
-        where: { id: transportDriver.id },
-        relations: ['transportVehicles']
-      })
-    ).transportVehicles
-  }
-}

package/server/service/transport-driver/transport-driver-types.ts

@@ -1,75 +0,0 @@
-import { Field, InputType, Int, ObjectType } from 'type-graphql'
-
-import { TransportDriver } from './transport-driver'
-
-@ObjectType()
-export class TransportDriverList {
-  @Field(type => [TransportDriver])
-  items: TransportDriver[]
-
-  @Field(type => Int)
-  total: number
-}
-
-@InputType()
-export class NewTransportDriver {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field()
-  userId: string
-
-  @Field()
-  driverCode: string
-
-  @Field({ nullable: true })
-  driverTelNo?: string
-
-  @Field({ nullable: true })
-  licenseType?: string
-
-  @Field({ nullable: true })
-  licenseNo?: string
-
-  @Field({ nullable: true })
-  licContDate?: string
-
-  @Field({ nullable: true })
-  licExpiDate?: string
-}
-
-@InputType()
-export class TransportDriverPatch {
-  @Field({ nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  driverCode?: string
-
-  @Field({ nullable: true })
-  driverTelNo?: string
-
-  @Field({ nullable: true })
-  licenseType?: string
-
-  @Field({ nullable: true })
-  licenseNo?: string
-
-  @Field({ nullable: true })
-  licContDate?: string
-
-  @Field({ nullable: true })
-  licExpiDate?: string
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}

package/server/service/transport-driver/transport-driver.ts

@@ -1,118 +0,0 @@
-import { Field, ID, ObjectType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  JoinTable,
-  ManyToMany,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-
-import { TransportVehicle } from '../transport-vehicle/transport-vehicle'
-
-@Entity()
-@Index(
-  'ix_transport-driver_0',
-  (transportDriver: TransportDriver) => [transportDriver.domain, transportDriver.driverCode, transportDriver.id],
-  {
-    unique: true
-  }
-)
-@ObjectType()
-export class TransportDriver {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain: Domain
-
-  @RelationId((transportDriver: TransportDriver) => transportDriver.domain)
-  domainId: string
-
-  @ManyToOne(type => Bizplace, { nullable: true })
-  @Field(type => Bizplace, { nullable: true })
-  bizplace?: Bizplace
-
-  @RelationId((transportDriver: TransportDriver) => transportDriver.bizplace)
-  bizplaceId?: string
-
-  @ManyToOne(type => User)
-  @Field(type => User)
-  user: User
-
-  @RelationId((transportDriver: TransportDriver) => transportDriver.user)
-  userId: string
-
-  @Column()
-  @Field()
-  name: string
-
-  @Column()
-  @Field()
-  driverCode: string
-
-  @ManyToMany(type => TransportVehicle, transportVehicle => transportVehicle.transportDrivers)
-  @JoinTable({ name: 'drivers_vehicles' })
-  @Field(type => [TransportVehicle], { nullable: true })
-  transportVehicles: TransportVehicle[]
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  driverTelNo: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  liceseType: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  licenseNo: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  licContDate: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  licExpiDate: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description: string
-
-  @ManyToOne(type => User)
-  @Field(type => User, { nullable: true })
-  creator: User
-
-  @RelationId((transportDriver: TransportDriver) => transportDriver.creator)
-  creatorId: string
-
-  @ManyToOne(type => User)
-  @Field(type => User, { nullable: true })
-  updater: User
-
-  @RelationId((transportDriver: TransportDriver) => transportDriver.updater)
-  updaterId: string
-
-  @CreateDateColumn()
-  @Field()
-  createdAt: Date
-
-  @UpdateDateColumn()
-  @Field()
-  updatedAt: Date
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  deletedAt: Date
-}

package/server/service/transport-vehicle/index.ts

@@ -1,6 +0,0 @@
-import { TransportVehicle } from './transport-vehicle'
-import { TransportVehicleMutation } from './transport-vehicle-mutation'
-import { TransportVehicleQuery } from './transport-vehicle-query'
-
-export const entities = [TransportVehicle]
-export const resolvers = [TransportVehicleQuery, TransportVehicleMutation]

package/server/service/transport-vehicle/transport-vehicle-mutation.ts

@@ -1,213 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, In, Repository } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain, getRepository } from '@things-factory/shell'
-
-import { NewTransportVehicle, TransportVehiclePatch } from '../'
-import { TransportDriver } from '../transport-driver/transport-driver'
-import { TransportVehicle } from './transport-vehicle'
-
-const debug = require('debug')('things-factory:operato-wms:addTransportVehicle')
-
-@Resolver(TransportVehicle)
-export class TransportVehicleMutation {
-  @Directive('@transaction')
-  @Directive('@privilege(category: "transport", privilege: "mutation")')
-  @Mutation(returns => TransportVehicle)
-  async createTransportVehicle(
-    @Arg('transportVehicle', type => NewTransportVehicle) transportVehicle: NewTransportVehicle,
-    @Ctx() context: ResolverContext
-  ): Promise<TransportVehicle> {
-    const { tx, domain, user } = context.state
-
-    return await createTransportVehicle(transportVehicle, domain, user, tx)
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "transport", privilege: "mutation")')
-  @Mutation(returns => [TransportVehicle])
-  async updateTransportVehicle(
-    @Arg('patch', type => TransportVehiclePatch) patch: TransportVehiclePatch,
-    @Ctx() context: ResolverContext
-  ): Promise<TransportVehicle> {
-    const { tx, domain, user } = context.state
-
-    return await updateTransportVehicle(patch, domain, user, tx)
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "transport", privilege: "mutation")')
-  @Mutation(returns => [TransportVehicle])
-  async updateMultipleTransportVehicle(
-    @Arg('patches', type => [TransportVehiclePatch]) patches: TransportVehiclePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<TransportVehicle[]> {
-    const { tx, domain, user } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const patch: TransportVehiclePatch = _createRecords[i]
-        const result = await createTransportVehicle(patch, domain, user, tx)
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const patch: TransportVehiclePatch = _updateRecords[i]
-        const result = await updateTransportVehicle(patch, domain, user, tx)
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "transport", privilege: "mutation")')
-  @Mutation(returns => Boolean)
-  async deleteTransportVehicle(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { tx } = context.state
-
-    return await deleteTransportVehicle(id, tx)
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "transport", privilege: "mutation")')
-  @Mutation(returns => Boolean)
-  async deleteTransportVehicles(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    return await deleteTransportVehicles(ids, context)
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "transport", privilege: "mutation")')
-  @Mutation(returns => TransportVehicle)
-  async addTransportVehicleDriver(
-    @Arg('id') id: string,
-    @Arg('driverId', type => String) driverId: string,
-    @Ctx() context: ResolverContext
-  ): Promise<TransportVehicle> {
-    const { domain, user, tx } = context.state
-    const transportVehicleRepo = tx.getRepository(TransportVehicle)
-    const transportVehicle = await transportVehicleRepo.findOne({
-      where: { domain: { id: domain.id }, id },
-      relations: ['domain', 'transportDrivers']
-    })
-
-    if (!transportVehicle) throw new Error('Failed to find vehicle')
-
-    transportVehicle.transportDrivers = []
-
-    const newDriver = await tx
-      .getRepository(TransportDriver)
-      .findOne({ where: { id: driverId, domain: { id: domain.id } } })
-    if (!newDriver) throw new Error('driver not found')
-
-    transportVehicle.transportDrivers.push(newDriver)
-
-    return await transportVehicleRepo.save({
-      ...transportVehicle,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "transport", privilege: "mutation")')
-  @Mutation(returns => TransportVehicle)
-  async deleteTransportVehicleDrivers(
-    @Arg('vehicleId') vehicleId: string,
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<TransportVehicle> {
-    const { domain, user, tx } = context.state
-    const transportVehicleRepo = tx.getRepository(TransportVehicle)
-    const transportVehicle = await transportVehicleRepo.findOne({
-      where: { domain: { id: domain.id }, id: vehicleId },
-      relations: ['domain', 'transportDrivers']
-    })
-
-    if (!transportVehicle) throw new Error('Failed to find vehicle')
-
-    const existedDriverIds: string[] = transportVehicle.transportDrivers.map(transportDriver => transportDriver.id)
-    const newDriverIds: string[] = existedDriverIds.filter(existedDriverId => !ids.includes(existedDriverId))
-
-    return await transportVehicleRepo.save({
-      ...transportVehicle,
-      transportDrivers: await getRepository(TransportDriver).findByIds(newDriverIds),
-      updater: user
-    })
-  }
-}
-
-export async function createTransportVehicle(
-  transportVehicle: TransportVehicle | NewTransportVehicle,
-  domain: Domain,
-  user: User,
-  tx?: EntityManager
-) {
-  const repository: Repository<TransportVehicle> = tx
-    ? tx.getRepository(TransportVehicle)
-    : getRepository(TransportVehicle)
-  return await repository.save({
-    ...transportVehicle,
-    regNumber: transportVehicle.name,
-    domain,
-    creator: user,
-    updater: user
-  })
-}
-
-export async function updateTransportVehicle(
-  patch: TransportVehicle | TransportVehiclePatch,
-  domain: Domain,
-  user: User,
-  tx?: EntityManager
-): Promise<TransportVehicle> {
-  const repository: Repository<TransportVehicle> = tx
-    ? tx.getRepository(TransportVehicle)
-    : getRepository(TransportVehicle)
-  const transportVehicle = await repository.findOne({
-    where: { domain: { id: domain.id }, id: patch.id }
-  })
-
-  return await repository.save({
-    ...transportVehicle,
-    ...patch,
-    regNumber: patch.name,
-    updater: user
-  })
-}
-
-export async function deleteTransportVehicle(id: string, tx?: EntityManager) {
-  const repository: Repository<TransportVehicle> = tx
-    ? tx.getRepository(TransportVehicle)
-    : getRepository(TransportVehicle)
-  await repository.delete(id)
-  return true
-}
-
-export async function deleteTransportVehicles(ids: string[], context: ResolverContext) {
-  const { tx, user } = context.state
-
-  const transportVehicles = await tx.getRepository(TransportVehicle).find({ where: { id: In(ids) } })
-
-  let deletedTransportVehicles: TransportVehicle[] = []
-  deletedTransportVehicles = await Promise.all(
-    transportVehicles.map((transportVehicle: TransportVehicle) => {
-      transportVehicle.deletedAt = new Date()
-      transportVehicle.updater = user
-
-      return transportVehicle
-    })
-  )
-  await tx.getRepository(TransportVehicle).save(deletedTransportVehicles)
-  return true
-}

package/server/service/transport-vehicle/transport-vehicle-query.ts

@@ -1,96 +0,0 @@
-import { Arg, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { IsNull } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { buildQuery, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
-
-import { TransportVehicleList } from '../'
-import { TransportDriver } from '../transport-driver/transport-driver'
-import { TransportVehicle } from './transport-vehicle'
-
-@Resolver(TransportVehicle)
-export class TransportVehicleQuery {
-  @Directive('@transaction')
-  @Directive('@privilege(category: "transport", privilege: "query", domainOwnerGranted: true)')
-  @Query(returns => TransportVehicleList)
-  async transportVehicles(
-    @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<TransportVehicleList> {
-    const { domain, tx } = context.state
-
-    const queryBuilder = tx.getRepository(TransportVehicle).createQueryBuilder()
-    buildQuery(queryBuilder, { filters, pagination, sortings }, context, {
-      searchables: ['name', 'description', 'size']
-    })
-
-    queryBuilder
-      .leftJoinAndSelect('TransportVehicle.domain', 'Domain')
-      .leftJoinAndSelect('TransportVehicle.creator', 'Creator')
-      .leftJoinAndSelect('TransportVehicle.updater', 'Updater')
-
-    if (filters?.length > 0) {
-      queryBuilder
-        .andWhere('Domain.id = :domainId', { domainId: domain.id })
-        .andWhere('TransportVehicle.deletedAt IS NULL')
-    } else {
-      queryBuilder
-        .where('TransportVehicle.deletedAt IS NULL')
-        .andWhere('Domain.id = :domainId', { domainId: domain.id })
-    }
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "transport", privilege: "query", domainOwnerGranted: true)')
-  @Query(returns => TransportVehicle)
-  async transportVehicleById(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<TransportVehicle> {
-    const { domain, user, tx } = context.state
-
-    return await tx.getRepository(TransportVehicle).findOne({
-      where: {
-        id,
-        domain: { id: domain.id },
-        deletedAt: IsNull()
-      }
-    })
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() transportVehicle: TransportVehicle): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: transportVehicle.domainId })
-  }
-
-  @FieldResolver(type => Bizplace)
-  async bizplace(@Root() transportVehicle: TransportVehicle): Promise<Bizplace> {
-    return await getRepository(Bizplace).findOneBy({ id: transportVehicle.bizplaceId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() transportVehicle: TransportVehicle): Promise<User> {
-    return await getRepository(User).findOneBy({ id: transportVehicle.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() transportVehicle: TransportVehicle): Promise<User> {
-    return await getRepository(User).findOneBy({ id: transportVehicle.creatorId })
-  }
-
-  @FieldResolver(type => [TransportDriver])
-  async transportDrivers(@Root() transportVehicle: TransportVehicle): Promise<TransportDriver[]> {
-    return await (
-      await getRepository(TransportVehicle).findOne({
-        where: {
-          id: transportVehicle.id
-        },
-        relations: ['transportDrivers']
-      })
-    ).transportDrivers
-  }
-}

package/server/service/transport-vehicle/transport-vehicle-types.ts

@@ -1,53 +0,0 @@
-import { Field, InputType, Int, ObjectType } from 'type-graphql'
-import { TransportVehicle } from './transport-vehicle'
-
-@ObjectType()
-export class TransportVehicleList {
-  @Field(type => [TransportVehicle])
-  items: TransportVehicle[]
-
-  @Field(type => Int)
-  total: number
-}
-
-@InputType()
-export class NewTransportVehicle {
-  @Field()
-  name: string
-
-  @Field()
-  regNumber: string
-
-  @Field()
-  size: string
-
-  @Field()
-  status: string
-
-  @Field({ nullable: true })
-  description: string
-}
-
-@InputType()
-export class TransportVehiclePatch {
-  @Field({ nullable: true })
-  id: string
-
-  @Field({ nullable: true })
-  name: string
-
-  @Field({ nullable: true })
-  regNumber: string
-
-  @Field({ nullable: true })
-  size: string
-
-  @Field({ nullable: true })
-  status: string
-
-  @Field({ nullable: true })
-  description: string
-
-  @Field({ nullable: true })
-  cuFlag: string
-}

package/server/service/transport-vehicle/transport-vehicle.ts

@@ -1,111 +0,0 @@
-import { Field, ID, ObjectType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToMany,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-
-import { TransportDriver } from '../transport-driver/transport-driver'
-
-@Entity()
-@Index(
-  'ix_transport-vehicle_0',
-  (transportVehicle: TransportVehicle) => [transportVehicle.domain, transportVehicle.name],
-  { unique: true }
-)
-@ObjectType()
-export class TransportVehicle {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain, { nullable: false })
-  @Field(type => Domain)
-  domain: Domain
-
-  @RelationId((transportVehicle: TransportVehicle) => transportVehicle.domain)
-  domainId: string
-
-  @ManyToOne(type => Bizplace, { nullable: true })
-  @Field(type => Bizplace, { nullable: true })
-  bizplace?: Bizplace
-
-  @RelationId((transportVehicle: TransportVehicle) => transportVehicle.bizplace)
-  bizplaceId?: string
-
-  @Column()
-  @Field()
-  name: string
-
-  @ManyToMany(type => TransportDriver, transportDriver => transportDriver.transportVehicles)
-  @Field(type => [TransportDriver], { nullable: true })
-  transportDrivers: TransportDriver[]
-
-  @Column()
-  @Field()
-  regNumber: string
-
-  @Column({ comment: '1ton, 3ton, 5ton, 8ton, 10ton' })
-  @Field()
-  size: string
-
-  @Column()
-  @Field()
-  status: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  ownerType: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  serviceStartDate: Date
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  serviceEndDate: Date
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  isEnabled: boolean
-
-  @ManyToOne(type => User)
-  @Field(type => User, { nullable: true })
-  creator: User
-
-  @RelationId((transportVehicle: TransportVehicle) => transportVehicle.creator)
-  creatorId: string
-
-  @ManyToOne(type => User)
-  @Field(type => User, { nullable: true })
-  updater: User
-
-  @RelationId((transportVehicle: TransportVehicle) => transportVehicle.updater)
-  updaterId: string
-
-  @CreateDateColumn()
-  @Field()
-  createdAt: Date
-
-  @UpdateDateColumn()
-  @Field()
-  updatedAt: Date
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  deletedAt: Date
-}