@things-factory/operato-pms 3.8.0 → 3.8.13

package/server/entities/truck.ts

@@ -0,0 +1,58 @@
+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/resolvers/daily-dispatch/daily-dispatch-query.ts

@@ -1,5 +1,7 @@
-import { buildQuery, Domain, ListParam } from '@things-factory/shell'
 import { EntityManager, IsNull } from 'typeorm'
+
+import { buildQuery, Domain, ListParam } from '@things-factory/shell'
+
 import { DailyDispatch as DailyDispatchEntity } from '../../../entities'
 
 export const Query = {
@@ -8,7 +10,16 @@ export const Query = {
 
     return await tx.getRepository(DailyDispatchEntity).findOne({
       where: { domain, name, deletedAt: IsNull() },
-      relations: ['domain', 'dailyDispatchDetails', 'dailyDispatchDetails.ramp', 'driver', 'creator', 'updater']
+      relations: [
+        'domain',
+        'dailyDispatchDetails',
+        'dailyDispatchDetails.ramp',
+        'driver',
+        'dispatchTo',
+        'transport',
+        'creator',
+        'updater'
+      ]
     })
   },
 
@@ -21,6 +32,8 @@ export const Query = {
     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')

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

@@ -1,8 +1,18 @@
+import { EntityManager, getRepository, Repository } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager, getRepository, Repository } from 'typeorm'
-import { RECORD_STATUS, INVENTORY_TYPE, TRANSACTION_TYPE } from '../../../constants'
-import { DailyDispatch, DailyDispatchDetail, OrganizationStaff, PlantationInventory, Ramp } from '../../../entities'
+
+import { INVENTORY_TYPE, RECORD_STATUS, TRANSACTION_TYPE } from '../../../constants'
+import {
+  DailyDispatch,
+  DailyDispatchDetail,
+  Organization,
+  OrganizationStaff,
+  PlantationInventory,
+  Ramp,
+  Truck
+} from '../../../entities'
 import { generateTransactionHistory, NoGenerator } from '../../../utils'
 
 export const generateDailyDispatch = {
@@ -11,10 +21,24 @@ export const generateDailyDispatch = {
 
     let dailyDispatchDetails: DailyDispatchDetail[] = dailyDispatch.dailyDispatchDetails
     let driver: OrganizationStaff
+    let transport: Truck
+    let dispatchTo: Organization
 
-    if (!dailyDispatch?.externalDriver) {
+    if (dailyDispatch?.driver) {
       driver = await tx.getRepository(OrganizationStaff).findOne({
-        where: { staffId: dailyDispatch.staffId }
+        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 }
       })
     }
 
@@ -26,14 +50,15 @@ export const generateDailyDispatch = {
     let newDailyDispatch: DailyDispatch = new DailyDispatch()
     newDailyDispatch.name = NoGenerator.dailyDispatch()
     newDailyDispatch.domain = domain
-    newDailyDispatch.transportNo = dailyDispatch.transportNo
-    newDailyDispatch.driverIdentification = dailyDispatch?.driverIdentification
-      ? dailyDispatch.driverIdentification
-      : null
-    newDailyDispatch.driver = driver ? driver : null
-    newDailyDispatch.externalDriver = dailyDispatch?.externalDriver ? dailyDispatch.externalDriver : null
+    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.dispatchTo = dailyDispatch.dispatchTo
+    newDailyDispatch.chitNo = dailyDispatch?.chitNo
+    newDailyDispatch.percentage = dailyDispatch?.percentage
+    newDailyDispatch.dispatchTo = dispatchTo
     newDailyDispatch.dispatchAt = dailyDispatch.dispatchAt
     newDailyDispatch.status = RECORD_STATUS.STORED
     newDailyDispatch.creator = user
@@ -50,7 +75,7 @@ export const generateDailyDispatch = {
       tx
     )
 
-    // await updatePlantationInventory(domain, newDailyDispatch, dailyDispatchDetails, user, tx)
+    await updatePlantationInventory(domain, newDailyDispatch, dailyDispatchDetails, user, tx)
 
     return newDailyDispatch
   }
@@ -108,13 +133,14 @@ export async function updatePlantationInventory(
       rampInventory.totalTonnage = currentRampTonnage - dispatchedTonnage
       rampInventory.updater = user
       rampInventory = await plantationInvRepo.save(rampInventory)
+      const dispatchDate: string = newDailyDispatch.dispatchAt.toString().split('T')[0]
 
       await generateTransactionHistory(
         rampInventory,
         newDailyDispatch.id,
         newDailyDispatch.name,
         TRANSACTION_TYPE.DISPATCHMENT,
-        newDailyDispatch.dispatchAt.toISOString().split('T')[0],
+        dispatchDate,
         0,
         -dispatchedTonnage,
         user,

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

@@ -1,10 +1,12 @@
+import { EntityManager } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager } from 'typeorm'
+
 import { DailyDispatch, DailyDispatchDetail } from '../../../entities'
 
 export const updateDailyDispatch = {
-  async updateDailyDispatch(_: any, { name, dailyDispatchDetails }, context: any) {
+  async updateDailyDispatch(_: any, { name, chitNo, percentage, dailyDispatchDetails }, context: any) {
     const { domain, tx, user }: { domain: Domain; tx: EntityManager; user: User } = context.state
 
     const repository = tx.getRepository(DailyDispatch)
@@ -31,6 +33,8 @@ export const updateDailyDispatch = {
 
     return await repository.save({
       ...dailyDispatch,
+      chitNo,
+      percentage,
       updater: user
     })
   }

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

@@ -1,11 +1,15 @@
-import { buildQuery, Domain, ListParam } from '@things-factory/shell'
 import { EntityManager, IsNull } from 'typeorm'
-import { DailyHarvest as DailyHarvestEntity } from '../../../entities'
+
+import { buildQuery, Domain, ListParam } from '@things-factory/shell'
+
+import { DailyHarvest as DailyHarvestEntity, RecordTransaction } from '../../../entities'
 
 export const Query = {
   async dailyHarvest(_: any, { name }, context: any) {
     const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
 
+    const transaction: RecordTransaction = await tx.getRepository(RecordTransaction).findOne({ where: { domain } })
+
     return await tx.getRepository(DailyHarvestEntity).findOne({
       where: { domain, name, deletedAt: IsNull() },
       relations: [
@@ -13,6 +17,7 @@ export const Query = {
         'block',
         'dailyHarvestDetails',
         'dailyHarvestDetails.organizationStaff',
+        'dailyHarvestDetails.organizationStaff.organization',
         'creator',
         'updater'
       ]

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

@@ -1,6 +1,8 @@
+import { EntityManager, getRepository, IsNull, Repository } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager, getRepository, IsNull, Repository } from 'typeorm'
+
 import { INVENTORY_STATUS, INVENTORY_TYPE, RECORD_STATUS, TRANSACTION_TYPE } from '../../../constants'
 import { Block, DailyHarvest, DailyHarvestDetail, OrganizationStaff, PlantationInventory } from '../../../entities'
 import { generateTransactionHistory, NoGenerator } from '../../../utils'
@@ -12,14 +14,19 @@ export const generateDailyHarvest = {
     let dailyHarvestDetails: DailyHarvestDetail[] = dailyHarvest.dailyHarvestDetails
 
     const block: Block = await tx.getRepository(Block).findOne({
-      where: { name: dailyHarvest.block, deletedAt: IsNull() }
+      where: { domain, name: dailyHarvest.block, deletedAt: IsNull() }
     })
 
     // get sum of bunch harvested from all staff
-    const totalBunchHarvested = dailyHarvestDetails.reduce(function (prev, cur) {
+    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
+
+    if (collectedBunch > totalBunchHarvested) throw new Error('Collected bunch more than total bunch harvested today')
+
     // 1. Create daily harvest
     let newDailyHarvest: DailyHarvest = new DailyHarvest()
     newDailyHarvest.name = NoGenerator.dailyHarvest()
@@ -28,7 +35,10 @@ export const generateDailyHarvest = {
     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
@@ -104,7 +114,7 @@ export async function addPlantationInventory(
 
     existingFieldBunch.totalBunches = newTotalBunches
     existingFieldBunch.updater = user
-    await plantationInvRepo.save(existingFieldBunch)
+    existingFieldBunch = await plantationInvRepo.save(existingFieldBunch)
 
     await generateTransactionHistory(
       existingFieldBunch,
@@ -117,6 +127,24 @@ export async function addPlantationInventory(
       user,
       tx
     )
+
+    if (newDailyHarvest.collectedBunch > 0) {
+      existingFieldBunch.totalBunches -= newDailyHarvest.collectedBunch
+      existingFieldBunch.updater = user
+      existingFieldBunch = await plantationInvRepo.save(existingFieldBunch)
+
+      await generateTransactionHistory(
+        existingFieldBunch,
+        newDailyHarvest.id,
+        newDailyHarvest.name,
+        TRANSACTION_TYPE.BUNCHES_ADJUSTMENT,
+        newDailyHarvest.harvestDate,
+        -newDailyHarvest.collectedBunch,
+        0,
+        user,
+        tx
+      )
+    }
   } else {
     newTotalBunches = newTotalBunches + newDailyHarvest.totalBunchHarvested
 
@@ -143,5 +171,23 @@ export async function addPlantationInventory(
       user,
       tx
     )
+
+    if (newDailyHarvest.collectedBunch > 0) {
+      plantationInventory.totalBunches -= newDailyHarvest.collectedBunch
+      plantationInventory.updater = user
+      plantationInventory = await plantationInvRepo.save(plantationInventory)
+
+      await generateTransactionHistory(
+        plantationInventory,
+        newDailyHarvest.id,
+        newDailyHarvest.name,
+        TRANSACTION_TYPE.BUNCHES_ADJUSTMENT,
+        newDailyHarvest.harvestDate,
+        -newDailyHarvest.collectedBunch,
+        0,
+        user,
+        tx
+      )
+    }
   }
 }

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

@@ -1,6 +1,8 @@
+import { EntityManager, getRepository, IsNull, Repository } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager, getRepository, IsNull, Repository } from 'typeorm'
+
 import { INVENTORY_TYPE, TRANSACTION_TYPE } from '../../../constants'
 import { Block, DailyHarvest, DailyHarvestDetail, OrganizationStaff, PlantationInventory } from '../../../entities'
 import { generateTransactionHistory, NoGenerator } from '../../../utils'
@@ -29,9 +31,11 @@ export const updateDailyHarvest = {
     )
 
     const block: Block = await tx.getRepository(Block).findOne({
-      where: { name: dailyHarvestPatch.block, deletedAt: IsNull() }
+      where: { domain, 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
@@ -40,7 +44,11 @@ export const updateDailyHarvest = {
     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)
@@ -64,6 +72,7 @@ export const updateDailyHarvest = {
               dailyHarvest: foundDailyHarvest,
               organizationStaff: foundStaff,
               totalBunchHarvested: foundDailyHarvestDetailPatch.totalBunchHarvested,
+              totalTonnageHarvested: foundDailyHarvestDetailPatch.totalTonnageHarvested,
               remark: foundDailyHarvestDetailPatch.remark,
               updater: user
             })
@@ -84,6 +93,7 @@ export const updateDailyHarvest = {
             id: dailyHarvestDetail.organizationStaff.id
           })
           newDailyHarvestDetail.totalBunchHarvested = dailyHarvestDetail.totalBunchHarvested
+          newDailyHarvestDetail.totalTonnageHarvested = dailyHarvestDetail.totalTonnageHarvested
           newDailyHarvestDetail.remark = dailyHarvestDetail.remark
           newDailyHarvestDetail.creator = user
           newDailyHarvestDetail.updater = user

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

@@ -1,5 +1,7 @@
-import { buildQuery, ListParam, Domain } from '@things-factory/shell'
 import { EntityManager, IsNull } from 'typeorm'
+
+import { buildQuery, Domain, ListParam } from '@things-factory/shell'
+
 import { DailyLoading as DailyLoadingEntity } from '../../../entities'
 
 export const Query = {
@@ -10,11 +12,10 @@ export const Query = {
       where: { domain, name, deletedAt: IsNull() },
       relations: [
         'domain',
-        'block',
         'dailyLoadingDetails',
-        'dailyLoadingDetails.organizationStaff',
-        'dailyLoadingRamps',
-        'dailyLoadingRamps.ramp',
+        'dailyLoadingDetails.truck',
+        'dailyLoadingDetails.block',
+        'dailyLoadingDetails.ramp',
         'creator',
         'updater'
       ]
@@ -29,7 +30,6 @@ export const Query = {
 
     queryBuilder
       .leftJoinAndSelect('DailyLoading.domain', 'Domain')
-      .leftJoinAndSelect('DailyLoading.block', 'Block')
       .leftJoinAndSelect('DailyLoading.creator', 'Creator')
       .leftJoinAndSelect('DailyLoading.updater', 'Updater')
 

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

@@ -1,16 +1,10 @@
+import { EntityManager, getRepository, Repository } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
-import { EntityManager, getRepository, Repository } from 'typeorm'
+
 import { INVENTORY_STATUS, INVENTORY_TYPE, RECORD_STATUS, TRANSACTION_TYPE } from '../../../constants'
-import {
-  Block,
-  DailyLoading,
-  DailyLoadingDetail,
-  DailyLoadingRamp,
-  OrganizationStaff,
-  PlantationInventory,
-  Ramp
-} from '../../../entities'
+import { Block, DailyLoading, DailyLoadingDetail, PlantationInventory, Ramp, Truck } from '../../../entities'
 import { generateTransactionHistory, NoGenerator } from '../../../utils'
 
 export const generateDailyLoading = {
@@ -18,26 +12,19 @@ export const generateDailyLoading = {
     const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
 
     let dailyLoadingDetails: DailyLoadingDetail[] = dailyLoading.dailyLoadingDetails
-    let dailyLoadingRamps: DailyLoadingRamp[] = dailyLoading.dailyLoadingRamps
 
-    const block: Block = await tx.getRepository(Block).findOne({
-      where: { name: dailyLoading.block }
-    })
+    const totalWeight: number = dailyLoadingDetails.reduce(function (prev, cur) {
+      return prev + cur.totalBunchWeight
+    }, 0)
 
-    // get sum of bunch loaded from all trip
     const totalBunch: number = dailyLoadingDetails.reduce(function (prev, cur) {
       return prev + cur.totalBunchLoaded
     }, 0)
 
-    const totalWeight: number = dailyLoadingDetails.reduce(function (prev, cur) {
-      return prev + cur.totalBunchWeight
-    }, 0)
-
     // 1. Create daily loading
     let newDailyLoading: DailyLoading = new DailyLoading()
     newDailyLoading.name = NoGenerator.dailyLoading()
     newDailyLoading.domain = domain
-    newDailyLoading.block = block
     newDailyLoading.loadingDate = dailyLoading.loadingDate
     newDailyLoading.totalBunch = totalBunch
     newDailyLoading.totalWeight = totalWeight
@@ -57,20 +44,6 @@ export const generateDailyLoading = {
       tx
     )
 
-    // 2. Create daily loading ramp
-    dailyLoadingRamps = await addDailyLoadingRamps(
-      domain,
-      newDailyLoading,
-      dailyLoadingRamps.map((record: DailyLoadingRamp) => {
-        return { ...record }
-      }),
-      user,
-      tx
-    )
-
-    // 3. Deduct bunches inventory in field and add ramp tonnage
-    await updatePlantationInventory(domain, newDailyLoading, dailyLoadingRamps, block, user, tx)
-
     return newDailyLoading
   }
 }
@@ -82,8 +55,10 @@ export async function addDailyLoadingDetail(
   user: User,
   tx?: EntityManager
 ): Promise<DailyLoadingDetail[]> {
-  const organizationStaffRepo: Repository<OrganizationStaff> =
-    tx?.getRepository(OrganizationStaff) || getRepository(OrganizationStaff)
+  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)
 
@@ -93,97 +68,40 @@ export async function addDailyLoadingDetail(
         ...record,
         domain,
         name: NoGenerator.dailyLoadingDetail(),
-        organizationStaff: await organizationStaffRepo.findOne({ id: record.organizationStaff.id }),
-        dailyLoading: newDailyLoading,
-        creator: user,
-        updater: user
-      }
-    })
-  )
-
-  return await dailyLoadingDetailRepo.save(dailyLoadingDetails)
-}
-
-export async function addDailyLoadingRamps(
-  domain: Domain,
-  newDailyLoading: DailyLoading,
-  dailyLoadingRamps: DailyLoadingRamp[],
-  user: User,
-  tx?: EntityManager
-): Promise<DailyLoadingRamp[]> {
-  const rampRepo: Repository<Ramp> = tx?.getRepository(Ramp) || getRepository(Ramp)
-  const dailyLoadingRampRepo: Repository<DailyLoadingRamp> =
-    tx?.getRepository(DailyLoadingRamp) || getRepository(DailyLoadingRamp)
-
-  dailyLoadingRamps = await Promise.all(
-    dailyLoadingRamps.map(async (record: DailyLoadingRamp) => {
-      return {
-        ...record,
-        domain,
-        name: NoGenerator.dailyLoadingRamp(),
+        truck: await truckRepo.findOne({ id: record.truck.id }),
+        block: await blockRepo.findOne({ id: record.block.id }),
         ramp: await rampRepo.findOne({ id: record.ramp.id }),
         dailyLoading: newDailyLoading,
-        creator: user,
-        updater: user
+        creator: user
       }
     })
   )
 
-  return await dailyLoadingRampRepo.save(dailyLoadingRamps)
+  dailyLoadingDetails = await dailyLoadingDetailRepo.save(dailyLoadingDetails)
+  await updatePlantationInventory(domain, newDailyLoading, dailyLoadingDetails, user, tx)
+
+  return dailyLoadingDetails
 }
 
 export async function updatePlantationInventory(
   domain: Domain,
   newDailyLoading: DailyLoading,
-  dailyLoadingRamps: DailyLoadingRamp[],
-  block: Block,
+  dailyLoadingDetails: DailyLoadingDetail[],
   user: User,
   tx?: EntityManager
 ): Promise<void> {
   const plantationInvRepo: Repository<PlantationInventory> =
     tx?.getRepository(PlantationInventory) || getRepository(PlantationInventory)
 
-  const rampRepo: Repository<Ramp> = tx?.getRepository(Ramp) || getRepository(Ramp)
-
-  let existingBunchesInventory: PlantationInventory = await plantationInvRepo.findOne({
-    where: { domain, block, type: INVENTORY_TYPE.FIELD_BUNCHES },
-    relations: ['domain', 'block']
-  })
-
-  const currentFieldBunches: number = existingBunchesInventory.totalBunches
-  const loadedFieldBunches: number = newDailyLoading.totalBunch
-
-  // deduct field bunches
-  if (loadedFieldBunches > currentFieldBunches) throw new Error('Insufficient Bunches in Field to be Loaded')
-  existingBunchesInventory.totalBunches = currentFieldBunches - loadedFieldBunches
-  existingBunchesInventory.updater = user
-  existingBunchesInventory = await plantationInvRepo.save(existingBunchesInventory)
-
-  await generateTransactionHistory(
-    existingBunchesInventory,
-    newDailyLoading.id,
-    newDailyLoading.name,
-    TRANSACTION_TYPE.BUNCHES_ADJUSTMENT,
-    newDailyLoading.loadingDate,
-    -loadedFieldBunches,
-    0,
-    user,
-    tx
-  )
-
   await Promise.all(
-    dailyLoadingRamps.map(async (record: any) => {
-      let ramp: Ramp = await rampRepo.findOne({
-        where: { domain, id: record.ramp.id }
-      })
-
+    dailyLoadingDetails.map(async (dailyLoadingDetail: any) => {
       let existingRampTonnage: PlantationInventory = await plantationInvRepo.findOne({
-        where: { domain, type: INVENTORY_TYPE.RAMP_TONNAGE, ramp },
+        where: { domain, type: INVENTORY_TYPE.RAMP_TONNAGE, ramp: dailyLoadingDetail.ramp },
         relations: ['domain', 'block', 'ramp']
       })
 
       if (existingRampTonnage) {
-        existingRampTonnage.totalTonnage = existingRampTonnage.totalTonnage + record.totalBunchWeight
+        existingRampTonnage.totalTonnage = existingRampTonnage.totalTonnage + dailyLoadingDetail.totalBunchWeight
         existingRampTonnage.updater = user
         await plantationInvRepo.save(existingRampTonnage)
 
@@ -194,7 +112,7 @@ export async function updatePlantationInventory(
           TRANSACTION_TYPE.LOADING,
           newDailyLoading.loadingDate,
           0,
-          record.totalBunchWeight,
+          dailyLoadingDetail.totalBunchWeight,
           user,
           tx
         )
@@ -202,11 +120,11 @@ export async function updatePlantationInventory(
         let plantationInventory: PlantationInventory = new PlantationInventory()
         plantationInventory.domain = domain
         plantationInventory.name = NoGenerator.rampTonnageName()
-        plantationInventory.block = block
+        plantationInventory.block = dailyLoadingDetail.block
         plantationInventory.type = INVENTORY_TYPE.RAMP_TONNAGE
-        plantationInventory.totalTonnage = record.totalBunchWeight
+        plantationInventory.totalTonnage = dailyLoadingDetail.totalBunchWeight
         plantationInventory.status = INVENTORY_STATUS.STORED
-        plantationInventory.ramp = ramp
+        plantationInventory.ramp = dailyLoadingDetail.ramp
         plantationInventory.creator = user
         plantationInventory = await plantationInvRepo.save(plantationInventory)
 
@@ -217,7 +135,7 @@ export async function updatePlantationInventory(
           TRANSACTION_TYPE.LOADING,
           newDailyLoading.loadingDate,
           0,
-          record.totalBunchWeight,
+          dailyLoadingDetail.totalBunchWeight,
           user,
           tx
         )