@things-factory/operato-pms 6.1.83 → 6.1.85

package/server/entities/truck.ts

@@ -1,58 +0,0 @@
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-
-import { Organization } from '../entities'
-
-@Entity()
-@Index('ix_truck_0', (truck: Truck) => [truck.domain, truck.id], { unique: true })
-export class Truck {
-  @PrimaryGeneratedColumn('uuid')
-  id: string
-
-  @ManyToOne(type => Domain)
-  domain: Domain
-
-  @RelationId((truck: Truck) => truck.domain)
-  domainId: string
-
-  @Column()
-  name: string
-
-  @Column({ nullable: true })
-  description: string
-
-  @ManyToOne(type => Organization)
-  organization: Organization
-
-  @Column({ nullable: true })
-  deletedAt: Date
-
-  @CreateDateColumn()
-  createdAt: Date
-
-  @UpdateDateColumn()
-  updatedAt: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  creator: User
-
-  @RelationId((truck: Truck) => truck.creator)
-  creatorId: string
-
-  @ManyToOne(type => User, { nullable: true })
-  updater: User
-
-  @RelationId((truck: Truck) => truck.updater)
-  updaterId: string
-}

package/server/graphql/index.ts

@@ -1,9 +0,0 @@
-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/block/block-query.ts

@@ -1,36 +0,0 @@
-import { IsNull } from 'typeorm'
-
-import { buildQuery, ListParam } from '@things-factory/shell'
-
-import { Block as BlockEntity } from '../../../entities'
-
-export const Query = {
-  async block(_: any, { name }, context: ResolverContext) {
-    const { domain, tx } = context.state
-
-    return await tx.getRepository(BlockEntity).findOne({
-      where: { domain: { id: domain.id }, name, deletedAt: IsNull() },
-      relations: ['domain', 'creator', 'updater']
-    })
-  },
-
-  async blocks(_: any, params: ListParam, context: ResolverContext) {
-    const { tx } = context.state
-
-    const queryBuilder = tx.getRepository(BlockEntity).createQueryBuilder()
-    buildQuery(queryBuilder, params, context)
-
-    queryBuilder
-      .leftJoinAndSelect('Block.domain', 'Domain')
-      .leftJoinAndSelect('Block.parentBlock', 'ParentBlock')
-      .leftJoinAndSelect('Block.creator', 'Creator')
-      .leftJoinAndSelect('Block.updater', 'Updater')
-
-    if (params.filters?.length > 0) queryBuilder.andWhere('Block.deletedAt IS NULL')
-    else queryBuilder.where('Block.deletedAt IS NULL')
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/block/delete-blocks.ts

@@ -1,39 +0,0 @@
-import { In, IsNull, Not } from 'typeorm'
-
-import { Block, BlockDetail } from '../../../entities'
-
-export const deleteBlocks = {
-  async deleteBlocks(_: any, { ids }, context: ResolverContext) {
-    try {
-      const { tx, domain } = context.state
-      const block = await tx.getRepository(Block).find({ where: { id: In(ids), deletedAt: Not(IsNull()) } })
-
-      await tx.getRepository(Block).update(
-        {
-          domain: { id: domain.id },
-          id: In(ids)
-        },
-        {
-          deletedAt: new Date()
-        }
-      )
-
-      await Promise.all(
-        block.map(async blk => {
-          await tx.getRepository(BlockDetail).update(
-            {
-              domain: { id: domain.id },
-              block: { id: blk.id }
-            },
-            {
-              deletedAt: new Date()
-            }
-          )
-        })
-      )
-      return true
-    } catch (error) {
-      throw error
-    }
-  }
-}

package/server/graphql/resolvers/block/index.ts

@@ -1,11 +0,0 @@
-import { Query } from './block-query'
-import { updateMultipleBlockResolver } from './update-multiple-block'
-import { deleteBlocks } from './delete-blocks'
-
-export const BlockResolver = {
-  Query,
-  Mutation: {
-    ...updateMultipleBlockResolver,
-    ...deleteBlocks
-  }
-}

package/server/graphql/resolvers/block/update-multiple-block.ts

@@ -1,69 +0,0 @@
-import { EntityManager, Repository } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { getRepository } from '@things-factory/shell'
-
-import { Block } from '../../../entities'
-
-export const updateMultipleBlockResolver = {
-  updateMultipleBlock
-}
-
-export async function updateMultipleBlock(_: any, { patches }, context: ResolverContext) {
-  const { domain, user, tx } = context.state
-  const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-  const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-  const blockRepo = tx.getRepository(Block)
-
-  let results = []
-
-  if (_createRecords.length > 0) {
-    for (let i = 0; i < _createRecords.length; i++) {
-      const newRecord = _createRecords[i]
-
-      if (newRecord?.parentBlock) {
-        await updateParentBlock(tx, user, newRecord.parentBlock)
-      }
-
-      const result = await blockRepo.save({
-        ...newRecord,
-        parentBlock: newRecord?.parentBlock ? await blockRepo.findOneBy({ id: newRecord.parentBlock.id }) : null,
-        hasChildren: false,
-        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 block = await blockRepo.findOneBy({ id: newRecord.id })
-
-      if (newRecord?.parentBlock) {
-        await updateParentBlock(tx, user, newRecord.parentBlock)
-      }
-
-      const result = await blockRepo.save({
-        ...block,
-        ...newRecord,
-        updater: user
-      })
-
-      results.push({ ...result, cuFlag: 'M' })
-    }
-  }
-
-  return results
-}
-
-export async function updateParentBlock(tx: EntityManager, user: User, parentBlock: Block): Promise<void> {
-  const blockRepo: Repository<Block> = tx ? tx.getRepository(Block) : getRepository(Block)
-  parentBlock = await blockRepo.findOneBy({ id: parentBlock.id })
-  parentBlock.hasChildren = true
-  parentBlock.updater = user
-  await blockRepo.save(parentBlock)
-}

package/server/graphql/resolvers/block-detail/block-detail-query.ts

@@ -1,55 +0,0 @@
-import { IsNull } from 'typeorm'
-
-import { buildQuery, getRepository, ListParam } from '@things-factory/shell'
-
-import { Block, BlockDetail as BlockDetailEntity } from '../../../entities'
-
-export const Query = {
-  async blockDetail(_: any, { name }, context: ResolverContext) {
-    const { domain, tx } = context.state
-
-    return await tx.getRepository(BlockDetailEntity).findOne({
-      where: { domain: { id: domain.id }, name, deletedAt: IsNull() },
-      relations: ['domain', 'block', 'creator', 'updater']
-    })
-  },
-
-  async blockDetails(_: any, params: ListParam, context: ResolverContext) {
-    const { tx } = context.state
-
-    const customFilterNames = ['blockId', 'yearPlanted']
-    const customFilters = params.filters.filter(x => customFilterNames.indexOf(x.name) >= 0)
-
-    const queryBuilder = tx.getRepository(BlockDetailEntity).createQueryBuilder()
-    buildQuery(queryBuilder, params, context)
-
-    queryBuilder
-      .leftJoinAndSelect('BlockDetail.domain', 'Domain')
-      .leftJoinAndSelect('BlockDetail.creator', 'Creator')
-      .leftJoinAndSelect('BlockDetail.updater', 'Updater')
-      .leftJoinAndSelect('BlockDetail.block', 'Block')
-      .where('BlockDetail.deletedAt IS NULL')
-
-    let blockId = customFilters.find(x => x.name == 'blockId')
-    if (blockId) {
-      queryBuilder.andWhere('"Block"."id" = :blockId', { blockId: blockId.value })
-    }
-
-    let yearPlanted = customFilters.find(x => x.name == 'yearPlanted')
-    if (yearPlanted) {
-      queryBuilder.andWhere('BlockDetail.yearPlanted = :yearPlanted', { yearPlanted: yearPlanted.value })
-    }
-
-    queryBuilder.orderBy('BlockDetail.validFrom', 'DESC')
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-}
-
-export const BlockDetail = {
-  async block(blockDetail) {
-    return await getRepository(Block).findOneBy({ id: blockDetail.blockId })
-  }
-}

package/server/graphql/resolvers/block-detail/delete-block-details.ts

@@ -1,20 +0,0 @@
-import { In } from 'typeorm'
-
-import { BlockDetail } from '../../../entities'
-
-export const deleteBlockDetails = {
-  async deleteBlockDetails(_: any, { ids }, context: ResolverContext) {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(BlockDetail).update(
-      {
-        domain: { id: domain.id },
-        id: In(ids)
-      },
-      {
-        deletedAt: new Date()
-      }
-    )
-    return true
-  }
-}

package/server/graphql/resolvers/block-detail/index.ts

@@ -1,12 +0,0 @@
-import { Query, BlockDetail } from './block-detail-query'
-import { updateMultipleBlockDetail } from './update-multiple-block-detail'
-import { deleteBlockDetails } from './delete-block-details'
-
-export const BlockDetailResolver = {
-  BlockDetail,
-  Query,
-  Mutation: {
-    ...updateMultipleBlockDetail,
-    ...deleteBlockDetails
-  }
-}

package/server/graphql/resolvers/block-detail/update-multiple-block-detail.ts

@@ -1,55 +0,0 @@
-import { Block, BlockDetail } from '../../../entities'
-import { NoGenerator } from '../../../utils'
-
-export const updateMultipleBlockDetail = {
-  async updateMultipleBlockDetail(_: 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 blockDetailRepo = tx.getRepository(BlockDetail)
-    const blockRepo = tx.getRepository(Block)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        if (!newRecord.block?.id) throw new Error('No block information found')
-        const block = await blockRepo.findOneBy({ id: newRecord.block.id })
-
-        const result = await blockDetailRepo.save({
-          ...newRecord,
-          domain,
-          name: NoGenerator.blockDetail(),
-          block,
-          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 blockDetail = await blockDetailRepo.findOneBy({ id: newRecord.id })
-
-        if (!newRecord.block?.id) throw new Error('No block information found')
-        const block = await blockRepo.findOneBy({ id: newRecord.block.id })
-
-        const result = await blockDetailRepo.save({
-          ...blockDetail,
-          ...newRecord,
-          block,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-}

package/server/graphql/resolvers/daily-block-detail/create-daily-block-detail.ts

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

package/server/graphql/resolvers/daily-block-detail/daily-block-detail-query.ts

@@ -1,36 +0,0 @@
-import { EntityManager, IsNull } from 'typeorm'
-
-import { buildQuery, Domain, ListParam } from '@things-factory/shell'
-
-import { DailyBlockDetail as DailyBlockDetailEntity } from '../../../entities'
-
-export const Query = {
-  async dailyBlockDetail(_: any, { name }, context: ResolverContext) {
-    const { domain, tx } = context.state
-
-    return await tx.getRepository(DailyBlockDetailEntity).findOne({
-      where: { domain: { id: domain.id }, name, deletedAt: IsNull() },
-      relations: ['domain', 'block', 'creator', 'updater']
-    })
-  },
-
-  async dailyBlockDetails(_: any, params: ListParam, context: ResolverContext) {
-    const { tx } = context.state
-
-    const queryBuilder = tx.getRepository(DailyBlockDetailEntity).createQueryBuilder()
-    buildQuery(queryBuilder, params, context)
-
-    queryBuilder
-      .leftJoinAndSelect('DailyBlockDetail.domain', 'Domain')
-      .leftJoinAndSelect('DailyBlockDetail.block', 'Block')
-      .leftJoinAndSelect('DailyBlockDetail.creator', 'Creator')
-      .leftJoinAndSelect('DailyBlockDetail.updater', 'Updater')
-
-    if (params.filters?.length > 0) queryBuilder.andWhere('DailyBlockDetail.deletedAt IS NULL')
-    else queryBuilder.where('DailyBlockDetail.deletedAt IS NULL')
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/daily-block-detail/delete-daily-block-detail.ts

@@ -1,14 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-import { Domain } from '@things-factory/shell'
-
-import { DailyBlockDetail } from '../../../entities'
-
-export const deleteDailyBlockDetail = {
-  async deleteDailyBlockDetail(_: any, { name }, context: ResolverContext) {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(DailyBlockDetail).delete({ domain, name })
-    return true
-  }
-}

package/server/graphql/resolvers/daily-block-detail/delete-daily-block-details.ts

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

package/server/graphql/resolvers/daily-block-detail/index.ts

@@ -1,18 +0,0 @@
-import { Query } from './daily-block-detail-query'
-
-import { updateDailyBlockDetail } from './update-daily-block-detail'
-import { updateMultipleDailyBlockDetail } from './update-multiple-daily-block-detail'
-import { createDailyBlockDetail } from './create-daily-block-detail'
-import { deleteDailyBlockDetail } from './delete-daily-block-detail'
-import { deleteDailyBlockDetails } from './delete-daily-block-details'
-
-export const DailyBlockDetailResolver = {
-  Query,
-  Mutation: {
-    ...updateDailyBlockDetail,
-    ...updateMultipleDailyBlockDetail,
-    ...createDailyBlockDetail,
-    ...deleteDailyBlockDetail,
-    ...deleteDailyBlockDetails
-  }
-}

package/server/graphql/resolvers/daily-block-detail/update-daily-block-detail.ts

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

package/server/graphql/resolvers/daily-block-detail/update-multiple-daily-block-detail.ts

@@ -1,44 +0,0 @@
-import { DailyBlockDetail } from '../../../entities'
-
-export const updateMultipleDailyBlockDetail = {
-  async updateMultipleDailyBlockDetail(_: any, { patches }, context: ResolverContext) {
-    const { domain, tx, 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 dailyBlockDetailRepo = tx.getRepository(DailyBlockDetail)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await dailyBlockDetailRepo.save({
-          ...newRecord,
-          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 dailyBlockDetail = await dailyBlockDetailRepo.findOneBy({ id: newRecord.id })
-
-        const result = await dailyBlockDetailRepo.save({
-          ...dailyBlockDetail,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-}

package/server/graphql/resolvers/daily-dispatch/daily-dispatch-query.ts

@@ -1,48 +0,0 @@
-import { EntityManager, IsNull } from 'typeorm'
-
-import { buildQuery, Domain, ListParam } from '@things-factory/shell'
-
-import { DailyDispatch as DailyDispatchEntity } from '../../../entities'
-
-export const Query = {
-  async dailyDispatch(_: any, { name }, context: ResolverContext) {
-    const { domain, tx } = context.state
-
-    return await tx.getRepository(DailyDispatchEntity).findOne({
-      where: { domain: { id: domain.id }, name, deletedAt: IsNull() },
-      relations: [
-        'domain',
-        'dailyDispatchDetails',
-        'dailyDispatchDetails.ramp',
-        'driver',
-        'dispatchTo',
-        'transport',
-        'creator',
-        'updater'
-      ]
-    })
-  },
-
-  async dailyDispatches(_: any, params: ListParam, context: ResolverContext) {
-    const { tx } = context.state
-
-    const queryBuilder = tx.getRepository(DailyDispatchEntity).createQueryBuilder()
-    buildQuery(queryBuilder, params, context)
-
-    queryBuilder
-      .leftJoinAndSelect('DailyDispatch.domain', 'Domain')
-      .leftJoinAndSelect('DailyDispatch.driver', 'Driver')
-      .leftJoinAndSelect('DailyDispatch.dispatchTo', 'DispatchTo')
-      .leftJoinAndSelect('DailyDispatch.transport', 'Transport')
-      .leftJoinAndSelect('DailyDispatch.creator', 'Creator')
-      .leftJoinAndSelect('DailyDispatch.updater', 'Updater')
-      .leftJoinAndSelect('DailyDispatch.dailyDispatchDetails', 'DailyDispatchDetails')
-
-    if (params.filters?.length > 0) queryBuilder.andWhere('DailyDispatch.deletedAt IS NULL')
-    else queryBuilder.where('DailyDispatch.deletedAt IS NULL')
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/daily-dispatch/delete-daily-dispatch.ts

@@ -1,34 +0,0 @@
-import { EntityManager, IsNull } from 'typeorm'
-
-import { Domain } from '@things-factory/shell'
-
-import { DailyDispatch, DailyDispatchDetail } from '../../../entities'
-
-export const deleteDailyDispatch = {
-  async deleteDailyDispatch(_: any, { name }, context: ResolverContext) {
-    const { domain, tx } = context.state
-    const dailyDispatch = await tx
-      .getRepository(DailyDispatch)
-      .findOneOrFail({ where: { name, deletedAt: IsNull() }, relations: ['dailyDispatchDetails'] })
-
-    await tx.getRepository(DailyDispatch).update(
-      {
-        domain: { id: domain.id },
-        name
-      },
-      {
-        deletedAt: new Date()
-      }
-    )
-
-    await tx.getRepository(DailyDispatchDetail).update(
-      {
-        domain: { id: domain.id },
-        dailyDispatch: { id: dailyDispatch.id }
-      },
-      {
-        deletedAt: new Date()
-      }
-    )
-  }
-}