@things-factory/transport-base 8.0.0-beta.9 → 8.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/transport-base",
-  "version": "8.0.0-beta.9",
+  "version": "8.0.2",
   "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.9"
+    "@things-factory/biz-base": "^8.0.2"
   },
-  "gitHead": "86b1dfa26292926a2d5447fdc23bfa5a9e983245"
+  "gitHead": "39d60f56e142561233ddf6d47b539c637971357c"
 }

package/server/constants/index.ts

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

package/server/constants/transport.ts

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

package/server/index.ts

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

package/server/migrations/index.ts

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

@@ -0,0 +1,25 @@
+/* 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

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

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

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

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

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

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