@things-factory/operato-pms 6.1.83 → 6.1.85

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

@@ -1,131 +0,0 @@
-import { EntityManager, Repository } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain, getRepository } from '@things-factory/shell'
-
-import { RECORD_STATUS, TRANSACTION_TYPE } from '../../../constants'
-import { DailyDispatch, DailyDispatchDetail, Organization, OrganizationStaff, Ramp, Truck } from '../../../entities'
-import { generateTransactionHistory, NoGenerator } from '../../../utils'
-
-export const generateDailyDispatch = {
-  async generateDailyDispatch(_: any, { dailyDispatch }, context: ResolverContext) {
-    const { domain, user, tx } = context.state
-
-    let dailyDispatchDetails: DailyDispatchDetail[] = dailyDispatch.dailyDispatchDetails
-    let driver: OrganizationStaff
-    let transport: Truck
-    let dispatchTo: Organization
-
-    if (dailyDispatch?.driver) {
-      driver = await tx.getRepository(OrganizationStaff).findOne({
-        where: { id: dailyDispatch.driver.id }
-      })
-    }
-
-    if (dailyDispatch?.transport) {
-      transport = await tx.getRepository(Truck).findOne({
-        where: { id: dailyDispatch.transport.id }
-      })
-    }
-
-    if (dailyDispatch?.dispatchTo) {
-      dispatchTo = await tx.getRepository(Organization).findOne({
-        where: { id: dailyDispatch.dispatchTo.id }
-      })
-    }
-
-    const totalTonnageRelease: number = dailyDispatchDetails.reduce(function (prev, cur) {
-      return prev + cur.collectedRampWeight
-    }, 0)
-
-    // 1. Create daily dispatchment
-    let newDailyDispatch: DailyDispatch = new DailyDispatch()
-    newDailyDispatch.name = NoGenerator.dailyDispatch()
-    newDailyDispatch.domain = domain
-    newDailyDispatch.transport = transport
-    newDailyDispatch.transportNo = transport.name
-    newDailyDispatch.driver = driver
-    newDailyDispatch.driverIdentification = driver?.idNumber ? driver.idNumber : null
-    newDailyDispatch.externalDriver = driver?.name ? driver?.name : null
-    newDailyDispatch.totalTonnageRelease = totalTonnageRelease
-    newDailyDispatch.chitNo = dailyDispatch?.chitNo
-    newDailyDispatch.percentage = dailyDispatch?.percentage
-    newDailyDispatch.dispatchTo = dispatchTo
-    newDailyDispatch.dispatchAt = dailyDispatch.dispatchAt
-    newDailyDispatch.status = RECORD_STATUS.STORED
-    newDailyDispatch.creator = user
-    newDailyDispatch = await tx.getRepository(DailyDispatch).save(newDailyDispatch)
-
-    // 2. Create daily dispatch detail
-    dailyDispatchDetails = await addDailyDispatchDetail(
-      domain,
-      newDailyDispatch,
-      dailyDispatchDetails.map((record: DailyDispatchDetail) => {
-        return { ...record }
-      }),
-      user,
-      tx
-    )
-
-    await generateDispatchTransaction(domain, newDailyDispatch, dailyDispatchDetails, user, tx)
-
-    return newDailyDispatch
-  }
-}
-
-export async function addDailyDispatchDetail(
-  domain: Domain,
-  newDailyDispatch: DailyDispatch,
-  dailyDispatchDetails: DailyDispatchDetail[],
-  user: User,
-  tx?: EntityManager
-): Promise<DailyDispatchDetail[]> {
-  const rampRepo: Repository<Ramp> = tx?.getRepository(Ramp) || getRepository(Ramp)
-  const dailyDispatchDetailRepo: Repository<DailyDispatchDetail> =
-    tx?.getRepository(DailyDispatchDetail) || getRepository(DailyDispatchDetail)
-
-  dailyDispatchDetails = await Promise.all(
-    dailyDispatchDetails.map(async (dailyDispatchDetail: DailyDispatchDetail) => {
-      return {
-        ...dailyDispatchDetail,
-        domain,
-        name: NoGenerator.dailyDispatchDetail(),
-        ramp: await rampRepo.findOneBy({ id: dailyDispatchDetail.ramp.id }),
-        dailyDispatch: newDailyDispatch,
-        creator: user,
-        updater: user
-      }
-    })
-  )
-
-  return await dailyDispatchDetailRepo.save(dailyDispatchDetails)
-}
-
-export async function generateDispatchTransaction(
-  domain: Domain,
-  newDailyDispatch: DailyDispatch,
-  dailyDispatchDetails: DailyDispatchDetail[],
-  user: User,
-  tx?: EntityManager
-): Promise<void> {
-  await Promise.all(
-    dailyDispatchDetails.map(async record => {
-      const dispatchedTonnage: number = record.collectedRampWeight
-      const dispatchDate: string = newDailyDispatch.dispatchAt.toString().split('T')[0]
-
-      await generateTransactionHistory(
-        null,
-        domain,
-        record.ramp,
-        newDailyDispatch.id,
-        newDailyDispatch.name,
-        TRANSACTION_TYPE.DISPATCHMENT,
-        dispatchDate,
-        0,
-        -dispatchedTonnage,
-        user,
-        tx
-      )
-    })
-  )
-}

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

@@ -1,14 +0,0 @@
-import { Query } from './daily-dispatch-query'
-
-import { generateDailyDispatch } from './generate-daily-dispatch'
-import { deleteDailyDispatch } from './delete-daily-dispatch'
-import { updateDailyDispatch } from './update-daily-dispatch'
-
-export const DailyDispatchResolver = {
-  Query,
-  Mutation: {
-    ...generateDailyDispatch,
-    ...deleteDailyDispatch,
-    ...updateDailyDispatch
-  }
-}

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

@@ -1,36 +0,0 @@
-import { DailyDispatch, DailyDispatchDetail } from '../../../entities'
-
-export const updateDailyDispatch = {
-  async updateDailyDispatch(_: any, { name, chitNo, percentage, dailyDispatchDetails }, context: ResolverContext) {
-    const { domain, tx, user } = context.state
-
-    const repository = tx.getRepository(DailyDispatch)
-    const dailyDispatch = await repository.findOne({
-      where: { domain: { id: domain.id }, name },
-      relations: ['dailyDispatchDetails']
-    })
-
-    let foundDailyDispatchDetails: DailyDispatchDetail[] = dailyDispatch.dailyDispatchDetails
-
-    foundDailyDispatchDetails = foundDailyDispatchDetails.map(record => {
-      const matchedDispatchDetail: any = dailyDispatchDetails.find(
-        dispatchDetail => dispatchDetail.name === record.name
-      )
-
-      return {
-        ...record,
-        ...matchedDispatchDetail,
-        updater: user
-      }
-    })
-
-    await tx.getRepository(DailyDispatchDetail).save(foundDailyDispatchDetails)
-
-    return await repository.save({
-      ...dailyDispatch,
-      chitNo,
-      percentage,
-      updater: user
-    })
-  }
-}

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

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

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

@@ -1,6 +0,0 @@
-import { Query } from './daily-dispatch-detail-query'
-
-export const DailyDispatchDetailResolver = {
-  Query,
-  Mutation: {}
-}

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

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

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

@@ -1,65 +0,0 @@
-import { IsNull } from 'typeorm'
-
-import { INVENTORY_TYPE, TRANSACTION_TYPE } from '../../../constants'
-import { DailyHarvest, DailyHarvestDetail, PlantationInventory } from '../../../entities'
-import { generateTransactionHistory } from '../../../utils'
-
-export const deleteDailyHarvest = {
-  async deleteDailyHarvest(_: any, { name }, context: ResolverContext) {
-    try {
-      const { domain, user, tx } = context.state
-      const dailyHarvest = await tx
-        .getRepository(DailyHarvest)
-        .findOneOrFail({ where: { name, deletedAt: IsNull() }, relations: ['block'] })
-
-      await tx.getRepository(DailyHarvest).update(
-        {
-          domain: { id: domain.id },
-          name
-        },
-        {
-          deletedAt: new Date()
-        }
-      )
-
-      await tx.getRepository(DailyHarvestDetail).update(
-        {
-          domain: { id: domain.id },
-          dailyHarvest: { id: dailyHarvest.id }
-        },
-        {
-          deletedAt: new Date()
-        }
-      )
-
-      const foundPlantationInv: PlantationInventory = await tx.getRepository(PlantationInventory).findOne({
-        where: { domain: { id: domain.id }, block: { id: dailyHarvest.block.id }, type: INVENTORY_TYPE.FIELD_BUNCHES },
-        relations: ['domain', 'block']
-      })
-
-      await tx.getRepository(PlantationInventory).save({
-        ...foundPlantationInv,
-        totalBunches: foundPlantationInv.totalBunches - dailyHarvest.totalBunchHarvested,
-        updater: user
-      })
-
-      await generateTransactionHistory(
-        dailyHarvest.block,
-        domain,
-        null,
-        dailyHarvest.id,
-        dailyHarvest.name,
-        TRANSACTION_TYPE.TERMINATED,
-        dailyHarvest.harvestDate,
-        -dailyHarvest.totalBunchHarvested,
-        0,
-        user,
-        tx
-      )
-
-      return true
-    } catch (error) {
-      throw error
-    }
-  }
-}

package/server/graphql/resolvers/daily-harvest/generate-daily-harvest.ts

@@ -1,205 +0,0 @@
-import { EntityManager, IsNull, Repository } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain, getRepository } from '@things-factory/shell'
-
-import { INVENTORY_STATUS, INVENTORY_TYPE, RECORD_STATUS, TRANSACTION_TYPE } from '../../../constants'
-import { Block, DailyHarvest, DailyHarvestDetail, OrganizationStaff, PlantationInventory } from '../../../entities'
-import { generateTransactionHistory, NoGenerator } from '../../../utils'
-
-export const generateDailyHarvest = {
-  async generateDailyHarvest(_: any, { dailyHarvest }, context: ResolverContext) {
-    const { domain, user, tx } = context.state
-
-    let dailyHarvestDetails: DailyHarvestDetail[] = dailyHarvest.dailyHarvestDetails
-
-    const block: Block = await tx.getRepository(Block).findOne({
-      where: { domain: { id: domain.id }, name: dailyHarvest.block, deletedAt: IsNull() }
-    })
-
-    // get sum of bunch harvested from all staff
-    const totalBunchHarvested: number = dailyHarvestDetails.reduce(function (prev, cur) {
-      return prev + cur.totalBunchHarvested
-    }, 0)
-
-    const collectedBunch: number = dailyHarvest.collectedBunch || 0
-    let yesterdayBalanceBunchInField: number = dailyHarvest.yesterdayBalanceBunchInField || 0
-
-    // 1. Create daily harvest
-    let newDailyHarvest: DailyHarvest = new DailyHarvest()
-    newDailyHarvest.name = NoGenerator.dailyHarvest()
-    newDailyHarvest.domain = domain
-    newDailyHarvest.block = block
-    newDailyHarvest.harvestingRound = dailyHarvest.harvestingRound
-    newDailyHarvest.harvestDate = dailyHarvest.harvestDate
-    newDailyHarvest.coverage = dailyHarvest.coverage
-    newDailyHarvest.yesterdayBalanceBunchInField = yesterdayBalanceBunchInField
-    newDailyHarvest.totalBunchHarvested = totalBunchHarvested
-    newDailyHarvest.collectedBunch = collectedBunch
-    newDailyHarvest.balanceBunchInField = yesterdayBalanceBunchInField + totalBunchHarvested - collectedBunch
-    newDailyHarvest.status = RECORD_STATUS.STORED
-    newDailyHarvest.creator = user
-    newDailyHarvest.updater = user
-
-    await tx.getRepository(DailyHarvest).save(newDailyHarvest)
-
-    // 2. Create daily harvest detail
-    await addDailyHarvestDetail(
-      domain,
-      newDailyHarvest,
-      dailyHarvestDetails.map((record: DailyHarvestDetail) => {
-        return { ...record }
-      }),
-      user,
-      tx
-    )
-
-    // 3. Create bunches inventory in field
-    await addPlantationInventory(domain, newDailyHarvest, block, user, tx)
-
-    return newDailyHarvest
-  }
-}
-
-export async function addDailyHarvestDetail(
-  domain: Domain,
-  newDailyHarvest: DailyHarvest,
-  dailyHarvestDetails: DailyHarvestDetail[],
-  user: User,
-  tx?: EntityManager
-): Promise<void> {
-  const organizationStaffRepo: Repository<OrganizationStaff> =
-    tx?.getRepository(OrganizationStaff) || getRepository(OrganizationStaff)
-  const dailyHarvestDetailRepo: Repository<DailyHarvestDetail> =
-    tx?.getRepository(DailyHarvestDetail) || getRepository(DailyHarvestDetail)
-
-  dailyHarvestDetails = await Promise.all(
-    dailyHarvestDetails.map(async (record: DailyHarvestDetail) => {
-      return {
-        ...record,
-        domain,
-        name: NoGenerator.dailyHarvestDetail(),
-        organizationStaff: await organizationStaffRepo.findOneBy({ id: record.organizationStaff.id }),
-        dailyHarvest: newDailyHarvest,
-        creator: user,
-        updater: user
-      }
-    })
-  )
-
-  await dailyHarvestDetailRepo.save(dailyHarvestDetails)
-}
-
-export async function addPlantationInventory(
-  domain: Domain,
-  newDailyHarvest: DailyHarvest,
-  block: Block,
-  user: User,
-  tx?: EntityManager
-): Promise<void> {
-  const plantationInvRepo: Repository<PlantationInventory> =
-    tx?.getRepository(PlantationInventory) || getRepository(PlantationInventory)
-
-  let existingFieldBunch: PlantationInventory = await plantationInvRepo.findOne({
-    where: { domain: { id: domain.id }, block: { id: block.id }, type: INVENTORY_TYPE.FIELD_BUNCHES },
-    relations: ['domain', 'block']
-  })
-
-  let newTotalBunches: number = 0
-
-  if (existingFieldBunch) {
-    const totalBunches: number = existingFieldBunch.totalBunches
-
-    if (totalBunches < 0) {
-      existingFieldBunch = await plantationInvRepo.save({ ...existingFieldBunch, totalBunches: 0 })
-    }
-
-    newTotalBunches = existingFieldBunch.totalBunches + newDailyHarvest.totalBunchHarvested
-
-    existingFieldBunch.totalBunches = newTotalBunches
-    existingFieldBunch.updater = user
-    existingFieldBunch = await plantationInvRepo.save(existingFieldBunch)
-
-    await generateTransactionHistory(
-      block,
-      domain,
-      null,
-      newDailyHarvest.id,
-      newDailyHarvest.name,
-      TRANSACTION_TYPE.HARVEST,
-      newDailyHarvest.harvestDate,
-      newDailyHarvest.totalBunchHarvested,
-      0,
-      user,
-      tx
-    )
-
-    if (newDailyHarvest.collectedBunch > 0) {
-      existingFieldBunch.totalBunches -= newDailyHarvest.collectedBunch
-      existingFieldBunch.updater = user
-      existingFieldBunch = await plantationInvRepo.save(existingFieldBunch)
-
-      await generateTransactionHistory(
-        block,
-        domain,
-        null,
-        newDailyHarvest.id,
-        newDailyHarvest.name,
-        TRANSACTION_TYPE.LOADING,
-        newDailyHarvest.harvestDate,
-        -newDailyHarvest.collectedBunch,
-        0,
-        user,
-        tx
-      )
-    }
-  } else {
-    newTotalBunches = newTotalBunches + newDailyHarvest.totalBunchHarvested
-
-    let plantationInventory: PlantationInventory = new PlantationInventory()
-    plantationInventory.domain = domain
-    plantationInventory.name = NoGenerator.fieldBunchName()
-    plantationInventory.block = block
-    plantationInventory.type = INVENTORY_TYPE.FIELD_BUNCHES
-    plantationInventory.totalBunches = newTotalBunches
-    plantationInventory.status = INVENTORY_STATUS.STORED
-    plantationInventory.creator = user
-    plantationInventory.updater = user
-
-    plantationInventory = await plantationInvRepo.save(plantationInventory)
-
-    await generateTransactionHistory(
-      block,
-      domain,
-      null,
-      newDailyHarvest.id,
-      newDailyHarvest.name,
-      TRANSACTION_TYPE.HARVEST,
-      newDailyHarvest.harvestDate,
-      newDailyHarvest.totalBunchHarvested,
-      0,
-      user,
-      tx
-    )
-
-    if (newDailyHarvest.collectedBunch > 0) {
-      plantationInventory.totalBunches -= newDailyHarvest.collectedBunch
-      plantationInventory.updater = user
-      plantationInventory = await plantationInvRepo.save(plantationInventory)
-
-      await generateTransactionHistory(
-        block,
-        domain,
-        null,
-        newDailyHarvest.id,
-        newDailyHarvest.name,
-        TRANSACTION_TYPE.LOADING,
-        newDailyHarvest.harvestDate,
-        -newDailyHarvest.collectedBunch,
-        0,
-        user,
-        tx
-      )
-    }
-  }
-}

package/server/graphql/resolvers/daily-harvest/index.ts

@@ -1,14 +0,0 @@
-import { Query } from './daily-harvest-query'
-
-import { generateDailyHarvest } from './generate-daily-harvest'
-import { updateDailyHarvest } from './update-daily-harvest'
-import { deleteDailyHarvest } from './delete-daily-harvest'
-
-export const DailyHarvestResolver = {
-  Query,
-  Mutation: {
-    ...generateDailyHarvest,
-    ...updateDailyHarvest,
-    ...deleteDailyHarvest
-  }
-}