@things-factory/transport-base 8.0.0-beta.8 → 8.0.0

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

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

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

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

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