@things-factory/operato-pms 6.1.83 → 6.1.85

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

@@ -1,153 +0,0 @@
-import { EntityManager, IsNull, Repository } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain, getRepository } from '@things-factory/shell'
-
-import { INVENTORY_TYPE, TRANSACTION_TYPE } from '../../../constants'
-import { Block, DailyHarvest, DailyHarvestDetail, OrganizationStaff, PlantationInventory } from '../../../entities'
-import { generateTransactionHistory, NoGenerator } from '../../../utils'
-
-export const updateDailyHarvest = {
-  async updateDailyHarvest(_: any, { name, dailyHarvestPatch }, context: ResolverContext) {
-    const { domain, user, tx } = context.state
-    const dailyHarvestRepo = tx.getRepository(DailyHarvest)
-    const dailyHarvestDetailRepo = tx.getRepository(DailyHarvestDetail)
-    const organizationStaffRepo = tx.getRepository(OrganizationStaff)
-
-    let foundDailyHarvest: DailyHarvest = await dailyHarvestRepo.findOne({
-      where: { name },
-      relations: ['block', 'dailyHarvestDetails', 'dailyHarvestDetails.organizationStaff']
-    })
-
-    // for existing data row
-    let foundDailyHarvestDetails: DailyHarvestDetail[] = foundDailyHarvest.dailyHarvestDetails // from DB
-    let existingDailyHarvestDetails: DailyHarvestDetail[] = dailyHarvestPatch.dailyHarvestDetails.filter(
-      detail => detail.name !== null
-    ) // from client side
-
-    // new row has been added
-    let newDailyHarvestDetails: DailyHarvestDetail[] = dailyHarvestPatch.dailyHarvestDetails.filter(
-      detail => detail.name === null
-    )
-
-    const block: Block = await tx.getRepository(Block).findOne({
-      where: { domain: { id: domain.id }, name: dailyHarvestPatch.block, deletedAt: IsNull() }
-    })
-
-    const collectedBunch: number = dailyHarvestPatch.collectedBunch || 0
-
-    // get sum of bunch harvested from all staff
-    var totalBunchHarvested = dailyHarvestPatch.dailyHarvestDetails.reduce(function (prev, cur) {
-      return prev + cur.totalBunchHarvested
-    }, 0)
-
-    foundDailyHarvest.block = block
-    foundDailyHarvest.coverage = dailyHarvestPatch.coverage
-    foundDailyHarvest.harvestingRound = dailyHarvestPatch.harvestingRound
-    foundDailyHarvest.yesterdayBalanceBunchInField = dailyHarvestPatch.yesterdayBalanceBunchInField
-    foundDailyHarvest.totalBunchHarvested = totalBunchHarvested
-    foundDailyHarvest.collectedBunch = collectedBunch
-    foundDailyHarvest.balanceBunchInField =
-      foundDailyHarvest.yesterdayBalanceBunchInField + totalBunchHarvested - collectedBunch
-    foundDailyHarvest.harvestDate = dailyHarvestPatch.harvestDate
-    foundDailyHarvest.updater = user
-    await dailyHarvestRepo.save(foundDailyHarvest)
-
-    if (existingDailyHarvestDetails?.length > 0) {
-      await Promise.all(
-        foundDailyHarvestDetails.map(async (record: DailyHarvestDetail) => {
-          if (record.totalBunchHarvested == 0) {
-            await dailyHarvestDetailRepo.delete(record.id)
-          } else {
-            const foundDailyHarvestDetailPatch = dailyHarvestPatch.dailyHarvestDetails.find(
-              detail => detail.name === record.name
-            )
-
-            const foundStaff: OrganizationStaff = await organizationStaffRepo.findOne({
-              where: { id: foundDailyHarvestDetailPatch.organizationStaff.id }
-            })
-
-            await dailyHarvestDetailRepo.save({
-              ...record,
-              dailyHarvest: foundDailyHarvest,
-              organizationStaff: foundStaff,
-              totalBunchHarvested: foundDailyHarvestDetailPatch.totalBunchHarvested,
-              totalTonnageHarvested: foundDailyHarvestDetailPatch.totalTonnageHarvested,
-              remark: foundDailyHarvestDetailPatch.remark,
-              updater: user
-            })
-          }
-        })
-      )
-    }
-
-    // during edit user add new row
-    if (newDailyHarvestDetails?.length > 0) {
-      await Promise.all(
-        newDailyHarvestDetails.map(async (dailyHarvestDetail: DailyHarvestDetail) => {
-          let newDailyHarvestDetail: DailyHarvestDetail = new DailyHarvestDetail()
-          newDailyHarvestDetail.dailyHarvest = await dailyHarvestRepo.findOne({
-            where: { domain: { id: domain.id }, name }
-          })
-          newDailyHarvestDetail.domain = domain
-          newDailyHarvestDetail.name = NoGenerator.dailyHarvestDetail()
-          newDailyHarvestDetail.organizationStaff = await organizationStaffRepo.findOneBy({
-            id: dailyHarvestDetail.organizationStaff.id
-          })
-          newDailyHarvestDetail.totalBunchHarvested = dailyHarvestDetail.totalBunchHarvested
-          newDailyHarvestDetail.totalTonnageHarvested = dailyHarvestDetail.totalTonnageHarvested
-          newDailyHarvestDetail.remark = dailyHarvestDetail.remark
-          newDailyHarvestDetail.creator = user
-          newDailyHarvestDetail.updater = user
-
-          await dailyHarvestDetailRepo.save(newDailyHarvestDetail)
-        })
-      )
-    }
-
-    await updatePlantationInventory(domain, foundDailyHarvest, block, user, tx)
-
-    return foundDailyHarvest
-  }
-}
-
-export async function updatePlantationInventory(
-  domain: Domain,
-  foundDailyHarvest: DailyHarvest,
-  block: Block,
-  user: User,
-  tx?: EntityManager
-): Promise<void> {
-  const plantationInvRepo: Repository<PlantationInventory> =
-    tx?.getRepository(PlantationInventory) || getRepository(PlantationInventory)
-
-  let existingPlantationInventory: PlantationInventory = await plantationInvRepo.findOne({
-    where: { domain: { id: domain.id }, block: { id: block.id }, type: INVENTORY_TYPE.FIELD_BUNCHES },
-    relations: ['domain', 'block', 'ramp']
-  })
-
-  if (!existingPlantationInventory) throw new Error('Unable to find plantation bunches inventory')
-
-  let newTotalBunches: number = 0
-  let currentBunchInField: number = existingPlantationInventory.totalBunches
-
-  newTotalBunches = foundDailyHarvest.totalBunchHarvested - currentBunchInField
-
-  existingPlantationInventory.totalBunches = currentBunchInField + newTotalBunches
-  existingPlantationInventory.updater = user
-  await plantationInvRepo.save(existingPlantationInventory)
-
-  await generateTransactionHistory(
-    block,
-    domain,
-    null,
-    foundDailyHarvest.id,
-    foundDailyHarvest.name,
-    TRANSACTION_TYPE.BUNCHES_ADJUSTMENT,
-    foundDailyHarvest.harvestDate,
-    newTotalBunches,
-    0,
-    user,
-    tx
-  )
-}

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

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

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

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

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

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

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

@@ -1,38 +0,0 @@
-import { EntityManager, IsNull } from 'typeorm'
-
-import { Domain } from '@things-factory/shell'
-
-import { DailyLoading, DailyLoadingDetail } from '../../../entities'
-
-export const deleteDailyLoading = {
-  async deleteDailyLoading(_: any, { name }, context: ResolverContext) {
-    try {
-      const { domain, tx } = context.state
-
-      const dailyLoading = await tx.getRepository(DailyLoading).findOneOrFail({ where: { name, deletedAt: IsNull() } })
-
-      await tx.getRepository(DailyLoading).update(
-        {
-          domain: { id: domain.id },
-          name
-        },
-        {
-          deletedAt: new Date()
-        }
-      )
-
-      await tx.getRepository(DailyLoadingDetail).update(
-        {
-          domain: { id: domain.id },
-          dailyLoading: { id: dailyLoading.id }
-        },
-        {
-          deletedAt: new Date()
-        }
-      )
-      return true
-    } catch (error) {
-      throw error
-    }
-  }
-}

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

@@ -1,149 +0,0 @@
-import { EntityManager, 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, DailyLoading, DailyLoadingDetail, PlantationInventory, Ramp, Truck } from '../../../entities'
-import { generateTransactionHistory, NoGenerator } from '../../../utils'
-
-export const generateDailyLoading = {
-  async generateDailyLoading(_: any, { dailyLoading }, context: ResolverContext) {
-    const { domain, user, tx } = context.state
-
-    let dailyLoadingDetails: DailyLoadingDetail[] = dailyLoading.dailyLoadingDetails
-
-    const totalWeight: number = dailyLoadingDetails.reduce(function (prev, cur) {
-      return prev + cur.totalBunchWeight
-    }, 0)
-
-    const totalBunch: number = dailyLoadingDetails.reduce(function (prev, cur) {
-      return prev + cur.totalBunchLoaded
-    }, 0)
-
-    // 1. Create daily loading
-    let newDailyLoading: DailyLoading = new DailyLoading()
-    newDailyLoading.name = NoGenerator.dailyLoading()
-    newDailyLoading.domain = domain
-    newDailyLoading.loadingDate = dailyLoading.loadingDate
-    newDailyLoading.totalBunch = totalBunch
-    newDailyLoading.totalWeight = totalWeight
-    newDailyLoading.status = RECORD_STATUS.STORED
-    newDailyLoading.creator = user
-
-    newDailyLoading = await tx.getRepository(DailyLoading).save(newDailyLoading)
-
-    // 2. Create daily loading detail
-    dailyLoadingDetails = await addDailyLoadingDetail(
-      domain,
-      newDailyLoading,
-      dailyLoadingDetails.map((record: DailyLoadingDetail) => {
-        return { ...record }
-      }),
-      user,
-      tx
-    )
-
-    return newDailyLoading
-  }
-}
-
-export async function addDailyLoadingDetail(
-  domain: Domain,
-  newDailyLoading: DailyLoading,
-  dailyLoadingDetails: DailyLoadingDetail[],
-  user: User,
-  tx?: EntityManager
-): Promise<DailyLoadingDetail[]> {
-  const truckRepo: Repository<Truck> = tx?.getRepository(Truck) || getRepository(Truck)
-  const blockRepo: Repository<Block> = tx?.getRepository(Block) || getRepository(Block)
-  const rampRepo: Repository<Ramp> = tx?.getRepository(Ramp) || getRepository(Ramp)
-
-  const dailyLoadingDetailRepo: Repository<DailyLoadingDetail> =
-    tx?.getRepository(DailyLoadingDetail) || getRepository(DailyLoadingDetail)
-
-  dailyLoadingDetails = await Promise.all(
-    dailyLoadingDetails.map(async (record: DailyLoadingDetail) => {
-      return {
-        ...record,
-        domain,
-        name: NoGenerator.dailyLoadingDetail(),
-        truck: await truckRepo.findOneBy({ id: record.truck.id }),
-        block: await blockRepo.findOneBy({ id: record.block.id }),
-        ramp: await rampRepo.findOneBy({ id: record.ramp.id }),
-        dailyLoading: newDailyLoading,
-        creator: user
-      }
-    })
-  )
-
-  dailyLoadingDetails = await dailyLoadingDetailRepo.save(dailyLoadingDetails)
-  await updatePlantationInventory(domain, newDailyLoading, dailyLoadingDetails, user, tx)
-
-  return dailyLoadingDetails
-}
-
-export async function updatePlantationInventory(
-  domain: Domain,
-  newDailyLoading: DailyLoading,
-  dailyLoadingDetails: DailyLoadingDetail[],
-  user: User,
-  tx?: EntityManager
-): Promise<void> {
-  const plantationInvRepo: Repository<PlantationInventory> =
-    tx?.getRepository(PlantationInventory) || getRepository(PlantationInventory)
-
-  await Promise.all(
-    dailyLoadingDetails.map(async (dailyLoadingDetail: any) => {
-      let existingRampTonnage: PlantationInventory = await plantationInvRepo.findOne({
-        where: { domain: { id: domain.id }, type: INVENTORY_TYPE.RAMP_TONNAGE, ramp: dailyLoadingDetail.ramp },
-        relations: ['domain', 'block', 'ramp']
-      })
-
-      if (existingRampTonnage) {
-        existingRampTonnage.totalTonnage = existingRampTonnage.totalTonnage + dailyLoadingDetail.totalBunchWeight
-        existingRampTonnage.updater = user
-        await plantationInvRepo.save(existingRampTonnage)
-
-        await generateTransactionHistory(
-          dailyLoadingDetail.block,
-          domain,
-          dailyLoadingDetail.ramp,
-          newDailyLoading.id,
-          newDailyLoading.name,
-          TRANSACTION_TYPE.LOADING,
-          newDailyLoading.loadingDate,
-          0,
-          dailyLoadingDetail.totalBunchWeight,
-          user,
-          tx
-        )
-      } else {
-        let plantationInventory: PlantationInventory = new PlantationInventory()
-        plantationInventory.domain = domain
-        plantationInventory.name = NoGenerator.rampTonnageName()
-        plantationInventory.block = dailyLoadingDetail.block
-        plantationInventory.type = INVENTORY_TYPE.RAMP_TONNAGE
-        plantationInventory.totalTonnage = dailyLoadingDetail.totalBunchWeight
-        plantationInventory.status = INVENTORY_STATUS.STORED
-        plantationInventory.ramp = dailyLoadingDetail.ramp
-        plantationInventory.creator = user
-        plantationInventory = await plantationInvRepo.save(plantationInventory)
-
-        await generateTransactionHistory(
-          dailyLoadingDetail.block,
-          domain,
-          dailyLoadingDetail.ramp,
-          newDailyLoading.id,
-          newDailyLoading.name,
-          TRANSACTION_TYPE.LOADING,
-          newDailyLoading.loadingDate,
-          0,
-          dailyLoadingDetail.totalBunchWeight,
-          user,
-          tx
-        )
-      }
-    })
-  )
-}

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

@@ -1,14 +0,0 @@
-import { Query } from './daily-loading-query'
-
-import { generateDailyLoading } from './generate-daily-loading'
-import { updateDailyLoading } from './update-daily-loading'
-import { deleteDailyLoading } from './delete-daily-loading'
-
-export const DailyLoadingResolver = {
-  Query,
-  Mutation: {
-    ...generateDailyLoading,
-    ...updateDailyLoading,
-    ...deleteDailyLoading
-  }
-}

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

@@ -1,154 +0,0 @@
-import { EntityManager, Repository } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain, getRepository } from '@things-factory/shell'
-
-import { INVENTORY_TYPE, TRANSACTION_TYPE } from '../../../constants'
-import { Block, DailyLoading, DailyLoadingDetail, PlantationInventory, Ramp, Truck } from '../../../entities'
-import { generateTransactionHistory, NoGenerator } from '../../../utils'
-
-export const updateDailyLoading = {
-  async updateDailyLoading(_: any, { name, dailyLoadingPatch }, context: ResolverContext) {
-    const { domain, user, tx } = context.state
-    const dailyLoadingRepo = tx.getRepository(DailyLoading)
-
-    let dailyLoading: DailyLoading = await dailyLoadingRepo.findOne({
-      where: { name },
-      relations: [
-        'dailyLoadingDetails',
-        'dailyLoadingDetails.truck',
-        'dailyLoadingDetails.ramp',
-        'dailyLoadingDetails.block'
-      ]
-    })
-
-    // get sum of bunch loaded from all trip
-    var totalBunch: number = dailyLoadingPatch.dailyLoadingDetails.reduce(function (prev, cur) {
-      return prev + cur.totalBunchLoaded
-    }, 0)
-
-    var totalWeight: number = dailyLoadingPatch.dailyLoadingDetails.reduce(function (prev, cur) {
-      return prev + cur.totalBunchWeight
-    }, 0)
-
-    dailyLoading.totalBunch = totalBunch
-    dailyLoading.totalWeight = totalWeight
-    dailyLoading.loadingDate = dailyLoadingPatch.loadingDate
-    dailyLoading.updater = user
-    dailyLoading = await dailyLoadingRepo.save(dailyLoading)
-
-    // 2. Create daily loading detail
-    await updateDailyLoadingDetail(domain, dailyLoading, dailyLoadingPatch.dailyLoadingDetails, user, tx)
-
-    return dailyLoading
-  }
-}
-
-export async function updateDailyLoadingDetail(
-  domain: Domain,
-  dailyLoading: DailyLoading,
-  dailyLoadingDetailPatches: any[],
-  user: User,
-  tx?: EntityManager
-): Promise<void> {
-  const truckRepo: Repository<Truck> = tx?.getRepository(Truck) || getRepository(Truck)
-  const blockRepo: Repository<Block> = tx?.getRepository(Block) || getRepository(Block)
-  const rampRepo: Repository<Ramp> = tx?.getRepository(Ramp) || getRepository(Ramp)
-  const dailyLoadingDetailRepo: Repository<DailyLoadingDetail> =
-    tx?.getRepository(DailyLoadingDetail) || getRepository(DailyLoadingDetail)
-
-  let updatedDailyLoadingDetails: any[] = []
-  const dailyLoadingDetails: DailyLoadingDetail[] = dailyLoading.dailyLoadingDetails
-  // for existing data row
-  const existingDailyLoadingDetails: DailyLoadingDetail[] = dailyLoadingDetailPatches.filter(
-    detail => detail.name !== null
-  )
-
-  // new row added in client side
-  const newDailyLoadingDetail: DailyLoadingDetail[] = dailyLoadingDetailPatches.filter(detail => detail.name === null)
-
-  if (existingDailyLoadingDetails?.length > 0) {
-    updatedDailyLoadingDetails = await Promise.all(
-      dailyLoadingDetails.map(async (existingRecord: DailyLoadingDetail) => {
-        const foundDailyLoadingDetailPatch = dailyLoadingDetailPatches.find(
-          detail => detail.name === existingRecord.name
-        )
-
-        if (foundDailyLoadingDetailPatch.totalBunchWeight !== existingRecord.totalBunchWeight) {
-          await updatePlantationInventory(domain, dailyLoading, foundDailyLoadingDetailPatch, existingRecord, user, tx)
-        }
-
-        return {
-          ...existingRecord,
-          dailyLoading,
-          truck: await truckRepo.findOneBy({ id: existingRecord.truck.id }),
-          block: await blockRepo.findOneBy({ id: existingRecord.block.id }),
-          ramp: await rampRepo.findOneBy({ id: existingRecord.ramp.id }),
-          totalBunchLoaded: foundDailyLoadingDetailPatch?.totalBunchLoaded || 0,
-          totalBunchWeight: foundDailyLoadingDetailPatch?.totalBunchWeight || 0,
-          remark: foundDailyLoadingDetailPatch?.remark || null,
-          updater: user
-        }
-      })
-    )
-    updatedDailyLoadingDetails = await dailyLoadingDetailRepo.save(updatedDailyLoadingDetails)
-  }
-
-  if (newDailyLoadingDetail?.length > 0) {
-    await Promise.all(
-      newDailyLoadingDetail.map(async (dailyLoadingDetail: DailyLoadingDetail) => {
-        let newDailyLoadingDetail: DailyLoadingDetail = new DailyLoadingDetail()
-        newDailyLoadingDetail.domain = domain
-        newDailyLoadingDetail.name = NoGenerator.dailyLoadingDetail()
-        newDailyLoadingDetail.truck = await truckRepo.findOneBy({ id: dailyLoadingDetail.truck.id })
-        newDailyLoadingDetail.block = await blockRepo.findOneBy({ id: dailyLoadingDetail.block.id })
-        newDailyLoadingDetail.ramp = await rampRepo.findOneBy({ id: dailyLoadingDetail.ramp.id })
-        newDailyLoadingDetail.totalBunchLoaded = dailyLoadingDetail?.totalBunchLoaded || 0
-        newDailyLoadingDetail.totalBunchWeight = dailyLoadingDetail?.totalBunchWeight || 0
-        newDailyLoadingDetail.remark = dailyLoadingDetail?.remark || null
-        newDailyLoadingDetail.creator = user
-        newDailyLoadingDetail.dailyLoading = dailyLoading
-
-        await dailyLoadingDetailRepo.save(newDailyLoadingDetail)
-      })
-    )
-  }
-}
-
-export async function updatePlantationInventory(
-  domain: Domain,
-  dailyLoading: DailyLoading,
-  foundDailyLoadingDetailPatch: any,
-  existingRecord: DailyLoadingDetail,
-  user: User,
-  tx?: EntityManager
-): Promise<void> {
-  const plantationInvRepo: Repository<PlantationInventory> =
-    tx?.getRepository(PlantationInventory) || getRepository(PlantationInventory)
-
-  let existingRampTonnage: PlantationInventory = await plantationInvRepo.findOne({
-    where: { domain: { id: domain.id }, type: INVENTORY_TYPE.RAMP_TONNAGE, ramp: { id: existingRecord.ramp.id } },
-    relations: ['domain', 'block', 'ramp']
-  })
-
-  if (existingRampTonnage) {
-    const tonnageChanges: number = foundDailyLoadingDetailPatch.totalBunchWeight - existingRecord.totalBunchWeight
-    existingRampTonnage.totalTonnage = existingRampTonnage.totalTonnage + tonnageChanges
-    existingRampTonnage.updater = user
-    await plantationInvRepo.save(existingRampTonnage)
-
-    await generateTransactionHistory(
-      existingRampTonnage.block,
-      domain,
-      existingRampTonnage.ramp,
-      dailyLoading.id,
-      dailyLoading.name,
-      TRANSACTION_TYPE.LOADING_ADJUSTMENT,
-      dailyLoading.loadingDate,
-      0,
-      tonnageChanges,
-      user,
-      tx
-    )
-  }
-}

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

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

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

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

package/server/graphql/resolvers/daily-loading-ramp/daily-loading-ramp-query.ts

@@ -1,34 +0,0 @@
-import { EntityManager, IsNull } from 'typeorm'
-
-import { buildQuery, Domain, ListParam } from '@things-factory/shell'
-
-import { DailyLoadingRamp as DailyLoadingRampEntity } from '../../../entities'
-
-export const Query = {
-  async dailyLoadingRamp(_: any, { name }, context: ResolverContext) {
-    const { domain, tx } = context.state
-
-    return await tx.getRepository(DailyLoadingRampEntity).findOne({
-      where: { domain: { id: domain.id }, name, deletedAt: IsNull() },
-      relations: ['domain', 'dailyLoading', 'ramp', 'creator', 'updater']
-    })
-  },
-
-  async dailyLoadingRamps(_: any, params: ListParam, context: ResolverContext) {
-    const { tx } = context.state
-
-    const queryBuilder = tx.getRepository(DailyLoadingRampEntity).createQueryBuilder()
-    buildQuery(queryBuilder, params, context)
-
-    queryBuilder
-      .leftJoinAndSelect('DailyLoadingRamp.domain', 'Domain')
-      .leftJoinAndSelect('DailyLoadingRamp.dailyLoading', 'DailyLoading')
-      .leftJoinAndSelect('DailyLoadingRamp.ramp', 'Ramp')
-      .leftJoinAndSelect('DailyLoadingRamp.creator', 'Creator')
-      .leftJoinAndSelect('DailyLoadingRamp.updater', 'Updater')
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-}