@things-factory/operato-pms 6.1.83 → 6.1.85

package/server/graphql/resolvers/plantation-setting/delete-plantation-setting.ts

@@ -1,13 +0,0 @@
-import { getRepository } from '@things-factory/shell'
-
-import { PlantationSetting } from '../../../entities'
-
-export const deletePlantationSetting = {
-  async deletePlantationSetting(_: any, { name }, context: ResolverContext) {
-    const { domain, user } = context.state
-
-    await getRepository(PlantationSetting).delete({ domain, name })
-
-    return true
-  }
-}

package/server/graphql/resolvers/plantation-setting/delete-plantation-settings.ts

@@ -1,18 +0,0 @@
-import { In } from 'typeorm'
-
-import { getRepository } from '@things-factory/shell'
-
-import { PlantationSetting } from '../../../entities'
-
-export const deletePlantationSettings = {
-  async deletePlantationSettings(_: any, { names }, context: ResolverContext) {
-    const { domain, user } = context.state
-
-    await getRepository(PlantationSetting).delete({
-      domain,
-      name: In(names)
-    })
-
-    return true
-  }
-}

package/server/graphql/resolvers/plantation-setting/index.ts

@@ -1,19 +0,0 @@
-import { Query, PlantationSetting } from './plantation-setting-query'
-
-import { updatePlantationSetting } from './update-plantation-setting'
-import { updateMultiplePlantationSetting } from './update-multiple-plantation-setting'
-import { createPlantationSetting } from './create-plantation-setting'
-import { deletePlantationSetting } from './delete-plantation-setting'
-import { deletePlantationSettings } from './delete-plantation-settings'
-
-export const PlantationSettingResolver = {
-  PlantationSetting,
-  Query,
-  Mutation: {
-    ...updatePlantationSetting,
-    ...updateMultiplePlantationSetting,
-    ...createPlantationSetting,
-    ...deletePlantationSetting,
-    ...deletePlantationSettings
-  }
-}

package/server/graphql/resolvers/plantation-setting/plantation-setting-query.ts

@@ -1,38 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { convertListParams, Domain, getRepository, ListParam } from '@things-factory/shell'
-
-import { PlantationSetting as PlantationSettingEntity } from '../../../entities'
-
-export const Query = {
-  async plantationSetting(_: any, { name }, context: ResolverContext) {
-    const { domain, user } = context.state
-    const repository = getRepository(PlantationSettingEntity)
-
-    return await repository.findOne({
-      where: { domain: { id: domain.id }, name }
-    })
-  },
-
-  async plantationSettings(_: any, params: ListParam, context: ResolverContext) {
-    const convertedParams = convertListParams(params)
-    const [items, total] = await getRepository(PlantationSettingEntity).findAndCount({
-      ...convertedParams
-    })
-
-    return { items, total }
-  }
-}
-
-export const PlantationSetting = {
-  async domain(plantationSetting) {
-    return await getRepository(Domain).findOneBy({ id: plantationSetting.domainId })
-  },
-
-  async creator(plantationSetting) {
-    return await getRepository(User).findOneBy({ id: plantationSetting.creatorId })
-  },
-
-  async updater(plantationSetting) {
-    return await getRepository(User).findOneBy({ id: plantationSetting.updaterId })
-  }
-}

package/server/graphql/resolvers/plantation-setting/update-multiple-plantation-setting.ts

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

package/server/graphql/resolvers/plantation-setting/update-plantation-setting.ts

@@ -1,20 +0,0 @@
-import { getRepository } from '@things-factory/shell'
-
-import { PlantationSetting } from '../../../entities'
-
-export const updatePlantationSetting = {
-  async updatePlantationSetting(_: any, { name, patch }, context: ResolverContext) {
-    const { domain, user } = context.state
-
-    const repository = getRepository(PlantationSetting)
-    const plantationSetting = await repository.findOne({
-      where: { domain: { id: domain.id }, name }
-    })
-
-    return await repository.save({
-      ...plantationSetting,
-      ...patch,
-      updater: user
-    })
-  }
-}

package/server/graphql/resolvers/ramp/delete-ramps.ts

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

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

@@ -1,12 +0,0 @@
-import { Query } from './ramp-query'
-
-import { updateMultipleRampResolver } from './update-multiple-ramp'
-import { deleteRamps } from './delete-ramps'
-
-export const RampResolver = {
-  Query,
-  Mutation: {
-    ...updateMultipleRampResolver,
-    ...deleteRamps
-  }
-}

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

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

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

@@ -1,61 +0,0 @@
-import { RAMP_STATUS } from '../../../constants'
-import { Block, Ramp } from '../../../entities'
-
-export const updateMultipleRampResolver = {
-  updateMultipleRamp
-}
-
-export async function updateMultipleRamp(_: any, { patches }, context: ResolverContext) {
-  const { tx, domain, user } = context.state
-  const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-  const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-  const rampRepo = tx.getRepository(Ramp)
-  const blockRepo = tx.getRepository(Block)
-
-  let results = []
-
-  if (_createRecords.length > 0) {
-    for (let i = 0; i < _createRecords.length; i++) {
-      const newRecord = _createRecords[i]
-
-      const block = await blockRepo.findOneOrFail({
-        where: { id: newRecord?.block?.id }
-      })
-
-      const result = await rampRepo.save({
-        ...newRecord,
-        block,
-        domain,
-        status: RAMP_STATUS.EMPTY,
-        creator: user,
-        updater: user
-      })
-
-      results.push({ ...result, cuFlag: '+' })
-    }
-  }
-
-  if (_updateRecords.length > 0) {
-    for (let i = 0; i < _updateRecords.length; i++) {
-      let newRecord = _updateRecords[i]
-      const ramp = await rampRepo.findOneBy({ id: newRecord.id })
-
-      if (newRecord?.block?.id) {
-        const block = await blockRepo.findOneOrFail({
-          where: { id: newRecord?.block?.id }
-        })
-        newRecord = { ...newRecord, block }
-      }
-
-      const result = await rampRepo.save({
-        ...ramp,
-        ...newRecord,
-        updater: user
-      })
-
-      results.push({ ...result, cuFlag: 'M' })
-    }
-  }
-
-  return results
-}

package/server/graphql/resolvers/record-transaction/index.ts

@@ -1,6 +0,0 @@
-import { Query } from './record-transaction-query'
-
-export const RecordTransactionResolver = {
-  Query,
-  Mutation: {}
-}

package/server/graphql/resolvers/record-transaction/record-transaction-query.ts

@@ -1,34 +0,0 @@
-import { buildQuery, ListParam } from '@things-factory/shell'
-
-import { RecordTransaction as RecordTransactionEntity } from '../../../entities'
-
-export const Query = {
-  async recordTransaction(_: any, { name }, context: ResolverContext) {
-    const { tx, domain } = context.state
-
-    return await tx.getRepository(RecordTransactionEntity).findOne({
-      where: { domain: { id: domain.id }, name },
-      relations: ['domain', 'plantationInventory', 'block', 'creator', 'updater']
-    })
-  },
-
-  async recordTransactions(_: any, params: ListParam, context: ResolverContext) {
-    const { tx } = context.state
-
-    const queryBuilder = tx.getRepository(RecordTransactionEntity).createQueryBuilder()
-    buildQuery(queryBuilder, params, context)
-
-    queryBuilder
-      .leftJoinAndSelect('RecordTransaction.domain', 'Domain')
-      .leftJoinAndSelect('RecordTransaction.plantationInventory', 'PlantationInventory')
-      .leftJoinAndSelect('RecordTransaction.block', 'Block')
-      .leftJoinAndSelect('RecordTransaction.creator', 'Creator')
-      .leftJoinAndSelect('RecordTransaction.updater', 'Updater')
-      .orderBy('RecordTransaction.transactionDate', 'ASC')
-      .addOrderBy('RecordTransaction.createdAt', 'ASC')
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/report/daily-ffb-dispatch-production-reports.ts

@@ -1,149 +0,0 @@
-import { IsNull } from 'typeorm'
-
-import { getRepository, ListParam } from '@things-factory/shell'
-
-import { Block, Organization, Ramp } from '../../../entities'
-
-export const dailyFfbDispatchProductionReports = {
-  async dailyFfbDispatchProductionReports(_: any, params: ListParam, context: ResolverContext) {
-    try {
-      const { domain, tx } = context.state
-
-      let year = parseInt(params.filters.filter(x => x.name == 'month')[0].value.split('-')[0])
-      let month = parseInt(params.filters.filter(x => x.name == 'month')[0].value.split('-')[1])
-
-      let fromDate = new Date(year, month - 1, 1)
-      let toDate = new Date(year, month, 1)
-      toDate.setDate(toDate.getDate() - 1)
-
-      let fromDateString = [
-        fromDate.getFullYear().toString(),
-        String(fromDate.getMonth() + 1).padStart(2, '0'),
-        '01'
-      ].join('-')
-
-      let toDateString = [
-        toDate.getFullYear().toString(),
-        String(toDate.getMonth() + 1).padStart(2, '0'),
-        String(toDate.getDate()).padStart(2, '0')
-      ].join('-')
-
-      let ramps = await getRepository(Ramp).find({
-        where: { domain: { id: domain.id }, deletedAt: IsNull() },
-        relations: ['block']
-      })
-
-      let organizations = await getRepository(Organization).find({
-        where: { domain: { id: domain.id }, deletedAt: IsNull() }
-      })
-
-      let blocks = await tx.getRepository(Block).query(
-        `
-        SELECT b.id, b.name FROM ramps r
-        INNER JOIN blocks b ON b.id = r.block_id 
-        WHERE b.deleted_at IS NULL
-        AND r.domain_id = $1
-        GROUP BY b.id, b.name         
-      `,
-        [domain.id]
-      )
-
-      // --  WHERE dd.dispatch_at::timestamp between $1::timestamp and $2::timestamp
-      // [fromDateString, toDateString]
-      await tx.query(`create extension if not exists tablefunc`)
-
-      await tx.query(
-        `
-          CREATE TEMP TABLE raw_block_dispatch ON COMMIT DROP AS (
-            SELECT "name", "dispatch_at", sum(weight) AS weight	FROM(
-              SELECT * FROM (
-                SELECT dd.id,COALESCE(b.name, 'unknown') AS name, 1 AS "rank", dd.dispatch_at::date AS dispatch_at,
-                COALESCE(ddd.adjusted_weight, ddd.collected_ramp_weight, 0) AS weight
-                FROM daily_dispatches dd 
-                INNER JOIN daily_dispatch_details ddd ON ddd.daily_dispatch_id = dd.id
-                INNER JOIN ramps r ON r.id = ddd.ramp_id 
-                INNER JOIN blocks b ON b.id = r.block_id
-                WHERE dd.dispatch_at::date between $1 and $2
-                UNION
-                SELECT dd.id, COALESCE(c.name, 'unknown') AS name, CASE WHEN c.name IS NULL THEN 3 ELSE 2 END AS "rank", dd.dispatch_at::date AS dispatch_at,
-                COALESCE((SELECT SUM(COALESCE(ddd.adjusted_weight, ddd.collected_ramp_weight, 0)) FROM daily_dispatch_details ddd WHERE ddd.daily_dispatch_id = dd.id),0) AS weight	
-                FROM daily_dispatches dd 
-                LEFT JOIN organizations c ON c.id = dd.dispatch_to_id
-                WHERE dd.dispatch_at::date between $1 and $2
-              ) foo 
-              ORDER BY "rank", "name", "dispatch_at"
-            ) foo
-            GROUP BY "name", "dispatch_at"
-            ORDER BY name, "dispatch_at"
-          )          
-        `,
-        [fromDateString, toDateString]
-      )
-
-      await tx.query(
-        `
-          CREATE TEMP TABLE pivot_block_dispatch ON COMMIT DROP AS (
-            SELECT * FROM crosstab(
-              $$
-                SELECT rbd."dispatch_at",  rbd."name",
-                CONCAT('today: ', round(rbd.weight,2)::varchar, ' | todate: ', round(coalesce(sum(rbd.weight) over (PARTITION BY "name" ORDER BY name, dispatch_at asc rows between unbounded preceding and current row), 0),2)::varchar) AS weight
-                FROM raw_block_dispatch rbd
-                ORDER BY rbd."dispatch_at",  rbd."name"
-              $$,
-              $$
-                SELECT b.name FROM ramps r INNER JOIN blocks b ON b.id = r.block_id WHERE r.deleted_at IS NULL AND r.domain_id = '${
-                  domain.id
-                }' 
-                GROUP BY b.id, b.name
-                UNION
-                SELECT c.name FROM organizations c
-              $$
-            ) AS (dispatch_at date, ${[
-              ...blocks.map(block => `"${block.name}" varchar`),
-              ...organizations.map(organization => `"${organization.name}" varchar`)
-            ].join(',')},"unknown" varchar)
-          );
-        `
-      )
-
-      await tx.query(
-        `
-          CREATE TEMP TABLE temp_monthly_production_data ON COMMIT DROP AS (
-            SELECT TO_CHAR(md.dateDay:: DATE, 'dd/mm/yyyy') as "date"
-            , row_to_json((SELECT d FROM (SELECT ${[
-              ...blocks.map(block => `pbd."${block.name}"`),
-              ...organizations.map(organization => `pbd."${organization.name}"`)
-            ].join(',')}, pbd."unknown") d))::varchar as "blockData"
-            , (SELECT sum(weight) FROM raw_block_dispatch rbd WHERE rbd.dispatch_at = pbd.dispatch_at) AS "today"
-            FROM (select generate_series((date '${fromDateString}')::timestamp, (date '${toDateString}')::timestamp, interval '1 day')::date as dateDay) as md 
-            LEFT JOIN pivot_block_dispatch pbd on pbd.dispatch_at::date = md.dateDay
-          );
-        `
-      )
-
-      const result: any = await tx.query(
-        `
-          select "date", "blockData", "today"
-          from temp_monthly_production_data dt
-        `
-      )
-
-      const total: any = await tx.query(
-        `
-          select count(*) from temp_monthly_production_data
-        `
-      )
-
-      return {
-        items: result.map(itm => {
-          return {
-            ...itm
-          }
-        }),
-        total: total[0].count
-      }
-    } catch (error) {
-      throw error
-    }
-  }
-}

package/server/graphql/resolvers/report/daily-production-reports.ts

@@ -1,167 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-import { ListParam } from '@things-factory/shell'
-
-import { Block } from '../../../entities'
-
-export const dailyProductionReports = {
-  async dailyProductionReports(_: any, params: ListParam, context: ResolverContext) {
-    try {
-      const { tx } = context.state
-
-      let year = parseInt(params.filters.filter(x => x.name == 'month')[0].value.split('-')[0])
-      let month = parseInt(params.filters.filter(x => x.name == 'month')[0].value.split('-')[1])
-
-      let fromDate = new Date(year, month - 1, 1)
-      let toDate = new Date(year, month, 1)
-      toDate.setDate(toDate.getDate() - 1)
-
-      let fromDateString = [
-        fromDate.getFullYear().toString(),
-        String(fromDate.getMonth() + 1).padStart(2, '0'),
-        '01'
-      ].join('-')
-
-      let toDateString = [
-        toDate.getFullYear().toString(),
-        String(toDate.getMonth() + 1).padStart(2, '0'),
-        String(toDate.getDate()).padStart(2, '0')
-      ].join('-')
-
-      const block = await tx
-        .getRepository(Block)
-        .findOneOrFail({ where: { id: params.filters.filter(x => x.name == 'block')[0].value } })
-
-      await tx.query(
-        `
-        CREATE TEMP TABLE temp_blocks on commit drop AS (
-          WITH RECURSIVE b AS (   
-            SELECT $1::uuid as block_id, * FROM blocks b 
-            WHERE id = $1::uuid
-            AND b.deleted_at IS null
-            UNION ALL
-            SELECT $1::uuid as block_id, cb.* FROM blocks cb
-            INNER JOIN b ON b.id = cb.parent_block_id
-            WHERE cb.deleted_at IS null
-          )
-          SELECT * FROM b
-        );
-      `,
-        [block.id]
-      )
-
-      await tx.query(
-        `
-        CREATE TEMP TABLE temp_records on commit drop AS (	
-          select blk.block_id, coalesce(sum(field_bunches),0) AS today_field_bunches, 
-          round(coalesce(sum(ramp_weight),0)::numeric,4) AS today_ramp_weight,
-          sum(case when transaction_type = 'HARVEST' OR transaction_type = 'BUNCHES_ADJUSTMENT' then field_bunches else 0 end) as today_bunch_harvest,
-          sum(case when transaction_type = 'LOADING' OR transaction_type = 'LOADING_ADJUSTMENT' then -field_bunches else 0 end) as today_bunch_collected,
-          round(sum(case when transaction_type = 'LOADING' OR transaction_type = 'LOADING_ADJUSTMENT' then ramp_weight else 0 end)::numeric,4) as today_ramp_weight_collected,
-          round(sum(case when transaction_type = 'DISPATCHMENT' OR transaction_type = 'DISPATCHMENT_ADJUSTMENT' then -ramp_weight else 0 end)::numeric,4) as today_weight_dispatch,	  
-          transaction_date
-          from record_transactions t2
-          inner join temp_blocks blk on blk.id = t2.block_id
-          where transaction_date <= $1
-          group by blk.block_id, transaction_date
-        )
-      `,
-        [toDateString]
-      )
-
-      await tx.query(
-        `
-          create temp table temp_daily_production_data on commit drop as (
-            select *,
-            prev_bunch_bal_in_field + today_bunch_harvest as today_bunch_in_field,
-            prev_bunch_bal_in_field + today_bunch_harvest - today_bunch_collected as today_bunch_bal_in_field,
-            prev_weight_bal_in_ramp + today_ramp_weight_collected - today_weight_dispatch as today_weight_bal_in_ramp FROM (
-              select extract(day from md.dateDay) as date_day,
-              coalesce(
-              (
-                select sum(today_field_bunches) from temp_records t2 
-                where transaction_date::timestamp < md.dateDay
-              )
-              , 0) as prev_bunch_bal_in_field,
-              coalesce(
-              (
-                select sum(today_ramp_weight) from temp_records t2 
-                where transaction_date::timestamp < md.dateDay
-              )
-              , 0) as prev_weight_bal_in_ramp,
-              coalesce(today_bunch_harvest, 0) as today_bunch_harvest,
-              coalesce(sum(today_bunch_harvest) over (order by dateDay asc rows between unbounded preceding and current row), 0) as to_date_bunch_harvest,
-              coalesce(today_bunch_collected, 0) as today_bunch_collected, 
-              coalesce(sum(today_bunch_collected) over (order by dateDay asc rows between unbounded preceding and current row), 0) as to_date_bunch_collected,
-              coalesce(today_ramp_weight_collected, 0) as today_ramp_weight_collected, 
-              coalesce(sum(today_ramp_weight_collected) over (order by dateDay asc rows between unbounded preceding and current row), 0) as to_date_ramp_weight_collected,
-              coalesce(today_weight_dispatch, 0) as today_weight_dispatch, 
-              coalesce(sum(today_weight_dispatch) over (order by dateDay asc rows between unbounded preceding and current row), 0) as to_date_weight_dispatch,
-              coalesce(tot.today_out_turn, 0) as today_out_turn,
-              coalesce(sum(tot.today_out_turn) over (order by dateDay asc rows between unbounded preceding and current row), 0) as to_date_out_turn,
-              (select name from blocks b2 where id = $3) as block,
-              coalesce(thr.today_harvesting_round, 0) as today_harvesting_round,
-              coalesce(thr.today_hectare_cover, 0) as today_hectare_cover
-              from 
-              (select generate_series((date '${fromDateString}')::timestamp, (date '${toDateString}')::timestamp, interval '1 day')::date as dateDay) as md 
-              left join (
-                select * from temp_records trx
-                where transaction_date between $1 and $2 
-                order by transaction_date
-              ) as dt on dt.transaction_date::date = md.dateDay
-              LEFT JOIN (
-                select sum(harvesting_round) AS today_harvesting_round, sum(coverage) AS today_hectare_cover, harvest_date 
-                from daily_harvests dh 
-                inner join temp_blocks blk on blk.id = dh.block_id
-                where harvest_date between $1 and $2
-                group by blk.block_id, harvest_date
-              ) as thr ON thr.harvest_date::date = md.dateDay
-              LEFT JOIN (
-                select count(*) AS today_out_turn, dh.harvest_date 
-                from daily_harvest_details dhd 
-                inner join daily_harvests dh on dh.id = dhd.daily_harvest_id
-                inner join temp_blocks blk on blk.id = dh.block_id
-                where dh.harvest_date between $1 and $2
-                GROUP BY blk.block_id, dh.harvest_date
-              ) as tot ON tot.harvest_date::date = md.dateDay
-            ) dt
-          )`,
-        [fromDateString, toDateString, block.id]
-      )
-
-      const result: any = await tx.query(`
-        select * from temp_daily_production_data dt
-      `)
-
-      const total: any = await tx.query(`
-        select count(*) from temp_daily_production_data
-      `)
-
-      let items = result.map(itm => {
-        return {
-          block: itm.block,
-          dateDay: itm.date_day,
-          diffInBunches: parseFloat(itm.diff_in_bunches).toFixed(1),
-          prevBunchBalInField: parseFloat(itm.prev_bunch_bal_in_field).toFixed(1),
-          prevWeightBalInRamp: parseFloat(itm.prev_weight_bal_in_ramp).toFixed(4),
-          toDateBunchHarvest: parseFloat(itm.to_date_bunch_harvest).toFixed(1),
-          toDateOutTurn: itm.to_date_out_turn,
-          toDateWeightDispatch: parseFloat(itm.to_date_weight_dispatch).toFixed(4),
-          todayBunchBalInField: parseFloat(itm.today_bunch_bal_in_field).toFixed(1),
-          todayBunchCollected: parseFloat(itm.today_bunch_collected).toFixed(1),
-          todayBunchHarvest: parseFloat(itm.today_bunch_harvest).toFixed(1),
-          todayBunchInField: parseFloat(itm.today_bunch_in_field).toFixed(1),
-          todayHarvestingRound: itm.today_harvesting_round,
-          todayHectareCover: parseFloat(itm.today_hectare_cover).toFixed(4),
-          todayOutTurn: itm.today_out_turn,
-          todayWeightBalInRamp: parseFloat(itm.today_weight_bal_in_ramp).toFixed(4),
-          todayWeightDispatch: parseFloat(itm.today_weight_dispatch).toFixed(4)
-        }
-      })
-
-      return { items, total: total[0].count }
-    } catch (error) {
-      throw error
-    }
-  }
-}