@things-factory/operato-pms 6.1.83 → 6.1.85

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

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

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

@@ -1,12 +0,0 @@
-import { Query } from './daily-loading-ramp-query'
-
-import { updateDailyLoadingRamp } from './update-daily-loading-ramp'
-import { deleteDailyLoadingRamp } from './delete-daily-loading-ramp'
-
-export const DailyLoadingRampResolver = {
-  Query,
-  Mutation: {
-    ...updateDailyLoadingRamp,
-    ...deleteDailyLoadingRamp
-  }
-}

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

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

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

@@ -1,245 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-// import { buildQuery, ListParam } from '@things-factory/shell'
-
-export const Query = {
-  /**
-   * @param blockId: id of the block
-   * @param yearAndMonth: the format will be something like 202001; combination of year 2020 and month 01
-   * @returns tonnage data with its sorted date
-   */
-  async monthlyTonnageProductions(_: any, { blockId, yearAndMonth }, context: ResolverContext) {
-    try {
-      const { tx } = context.state
-
-      const year = parseInt(yearAndMonth.substring(0, 4))
-      const month = parseInt(yearAndMonth.substring(4))
-
-      let data: any[] = await getDailyProductionData(blockId, year, month, tx)
-      let result = []
-
-      result = data.map(itm => {
-        return {
-          ...itm,
-          blockId,
-          tonnage: itm.todayWeightCollected,
-          year: itm.dateDay.getFullYear(),
-          month: itm.dateDay.getMonth(),
-          date: itm.dateDay.toLocaleString('default', { day: '2-digit', month: 'short' })
-        }
-      })
-
-      return result
-    } catch (ex) {}
-  },
-
-  async monthlyYields(_: any, { blockId, yearAndMonth }, context: ResolverContext) {
-    try {
-      const { tx } = context.state
-
-      const year = parseInt(yearAndMonth.substring(0, 4))
-      const month = parseInt(yearAndMonth.substring(4))
-
-      let data: any[] = await getDailyProductionData(blockId, year, month, tx)
-      let result = []
-
-      result = data.map(itm => {
-        return {
-          ...itm,
-          blockId,
-          yield: (itm.todayHectareCover != 0 ? itm.todayWeightCollected / itm.todayHectareCover : 0).toFixed(4),
-          year: itm.dateDay.getFullYear(),
-          month: itm.dateDay.getMonth(),
-          date: itm.dateDay.toLocaleString('default', { day: '2-digit', month: 'short' })
-        }
-      })
-
-      return result
-    } catch (ex) {}
-  },
-
-  async weeklyBunchesCount(_: any, { targetDate }, context: ResolverContext) {
-    if (!targetDate || targetDate == '') targetDate = new Date()
-
-    let bunchesCount = []
-
-    for (let i = 0; i < 7; i++) {
-      bunchesCount.push({
-        date: new Date(targetDate).toLocaleString('default', { day: '2-digit', month: 'short' }),
-        harvestedCount: 0,
-        collectedCount: 0
-        // harvestedCount: Math.floor(Math.random() * 1000) + 500,
-        // collectedCount: Math.floor(Math.random() * 500) + 50
-      })
-      targetDate.setDate(targetDate.getDate() - 1)
-    }
-
-    return bunchesCount.reverse()
-  },
-
-  async tonnageAndBunchesInventories(_: any, { something }, context: ResolverContext) {
-    return {
-      bunches: 0,
-      tonnage: 0
-      // bunches: Math.floor(Math.random() * 10000) + 500,
-      // tonnage: Math.floor(Math.random() * 10000) + 500
-    }
-  },
-
-  async productionsOverview(_: any, { something }, context: ResolverContext) {
-    return {
-      averageBunchWeight: 0,
-      bunchesCount: 0,
-      tonnageWeighed: 0
-      // averageBunchWeight: Math.floor(Math.random() * 150) + 70,
-      // bunchesCount: Math.floor(Math.random() * 10000) + 500,
-      // tonnageWeighed: Math.floor(Math.random() * 10000) + 500
-    }
-  }
-}
-
-export async function getDailyProductionData(
-  blockId: String,
-  year: number,
-  month: number,
-  tx: EntityManager
-): Promise<any> {
-  await tx.query(`
-    CREATE TEMP TABLE temp_blocks on commit drop AS (
-      WITH RECURSIVE b AS (   
-        SELECT b.id AS block_id, * FROM blocks b 
-        WHERE b.deleted_at IS null
-        UNION ALL
-        SELECT b.id AS block_id, cb.* FROM blocks cb
-        INNER JOIN b ON b.id = cb.parent_block_id
-        WHERE cb.deleted_at IS null
-      )
-      SELECT block_id, id, name FROM b 
-      ${blockId != 'all-blocks' && blockId != '' ? `WHERE block_id = '${blockId}' or id = '${blockId}'` : ``}
-      GROUP BY block_id, id, name 
-      ORDER BY block_id, id, name 
-    );
-  `)
-
-  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('-')
-
-  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 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,
-        ${
-          blockId != 'all-blocks' && blockId != '' ? `(select name from blocks b2 WHERE id = '${blockId}')` : `''`
-        } 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]
-  )
-
-  const result: any = await tx.query(`
-    select * from temp_daily_production_data dt
-  `)
-
-  return 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,
-      todayWeightCollected: parseFloat(itm.today_ramp_weight_collected).toFixed(4),
-      todayWeightBalInRamp: parseFloat(itm.today_weight_bal_in_ramp).toFixed(4),
-      todayWeightDispatch: parseFloat(itm.today_weight_dispatch).toFixed(4)
-    }
-  })
-}

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

@@ -1,5 +0,0 @@
-import { Query } from './dashboard-query'
-
-export const DashboardResolver = {
-  Query
-}

package/server/graphql/resolvers/index.ts

@@ -1,20 +0,0 @@
-export * from './block-detail'
-export * from './block'
-export * from './daily-block-detail'
-export * from './daily-dispatch-detail'
-export * from './daily-dispatch'
-export * from './daily-harvest-detail'
-export * from './daily-harvest'
-export * from './daily-loading-detail'
-export * from './daily-loading-ramp'
-export * from './daily-loading'
-export * from './dashboard'
-export * from './organization-staff'
-export * from './organization'
-export * from './plantation-inventory'
-export * from './plantation-setting'
-export * from './ramp'
-export * from './record-transaction'
-export * from './report'
-
-export * from './truck'

package/server/graphql/resolvers/organization/delete-organizations.ts

@@ -1,40 +0,0 @@
-import { In, IsNull } from 'typeorm'
-
-import { Organization, OrganizationStaff } from '../../../entities'
-
-export const deleteOrganizations = {
-  async deleteOrganizations(_: any, { ids }, context: ResolverContext) {
-    try {
-      const { tx, domain } = context.state
-
-      const organization = await tx.getRepository(Organization).find({ where: { id: In(ids), deletedAt: IsNull() } })
-
-      await tx.getRepository(Organization).update(
-        {
-          domain: { id: domain.id },
-          id: In(ids)
-        },
-        {
-          deletedAt: new Date()
-        }
-      )
-
-      await Promise.all(
-        organization.map(async org => {
-          await tx.getRepository(OrganizationStaff).update(
-            {
-              domain: { id: domain.id },
-              organization: { id: org.id }
-            },
-            {
-              deletedAt: new Date()
-            }
-          )
-        })
-      )
-      return true
-    } catch (error) {
-      throw error
-    }
-  }
-}

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

@@ -1,11 +0,0 @@
-import { Query } from './organization-query'
-import { updateMultipleOrganizationResolver } from './update-multiple-organization'
-import { deleteOrganizations } from './delete-organizations'
-
-export const OrganizationResolver = {
-  Query,
-  Mutation: {
-    ...updateMultipleOrganizationResolver,
-    ...deleteOrganizations
-  }
-}

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

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

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

@@ -1,48 +0,0 @@
-import { ORGANIZATION_STATUS } from '../../../constants'
-import { Organization } from '../../../entities'
-
-export const updateMultipleOrganizationResolver = {
-  updateMultipleOrganization
-}
-
-export async function updateMultipleOrganization(_: any, { patches }, context: ResolverContext) {
-  const { tx, 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 organizationRepo = tx.getRepository(Organization)
-
-  if (_createRecords.length > 0) {
-    for (let i = 0; i < _createRecords.length; i++) {
-      const newRecord = _createRecords[i]
-
-      const result = await organizationRepo.save({
-        ...newRecord,
-        domain,
-        status: ORGANIZATION_STATUS.ACTIVE,
-        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 organization = await organizationRepo.findOneBy({ id: newRecord.id })
-
-      const result = await organizationRepo.save({
-        ...organization,
-        ...newRecord,
-        updater: user
-      })
-
-      results.push({ ...result, cuFlag: 'M' })
-    }
-  }
-
-  return results
-}

package/server/graphql/resolvers/organization-staff/delete-organization-staffs.ts

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

package/server/graphql/resolvers/organization-staff/index.ts

@@ -1,12 +0,0 @@
-import { Query } from './organization-staff-query'
-
-import { updateMultipleOrganizationStaffResolver } from './update-multiple-organization-staff'
-import { deleteOrganizationStaffs } from './delete-organization-staffs'
-
-export const OrganizationStaffResolver = {
-  Query,
-  Mutation: {
-    ...updateMultipleOrganizationStaffResolver,
-    ...deleteOrganizationStaffs
-  }
-}

package/server/graphql/resolvers/organization-staff/organization-staff-query.ts

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

package/server/graphql/resolvers/organization-staff/update-multiple-organization-staff.ts

@@ -1,60 +0,0 @@
-import { ORGANIZATION_STAFF_STATUS } from '../../../constants'
-import { Organization, OrganizationStaff } from '../../../entities'
-
-export const updateMultipleOrganizationStaffResolver = {
-  updateMultipleOrganizationStaff
-}
-
-export async function updateMultipleOrganizationStaff(_: any, { patches }, context: ResolverContext) {
-  const { tx, 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 organizationStaffRepo = tx.getRepository(OrganizationStaff)
-
-  if (_createRecords.length > 0) {
-    for (let i = 0; i < _createRecords.length; i++) {
-      const newRecord = _createRecords[i]
-
-      const organization = await tx.getRepository(Organization).findOneOrFail({
-        where: { id: newRecord?.organization?.id }
-      })
-
-      const result = await organizationStaffRepo.save({
-        ...newRecord,
-        organization,
-        domain,
-        status: ORGANIZATION_STAFF_STATUS.ACTIVE,
-        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 organizationStaff = await organizationStaffRepo.findOneBy({ id: newRecord.id })
-
-      if (newRecord?.organization?.id) {
-        const organization = await tx.getRepository(Organization).findOneOrFail({
-          where: { id: newRecord?.organization?.id }
-        })
-        newRecord = { ...newRecord, organization }
-      }
-
-      const result = await organizationStaffRepo.save({
-        ...organizationStaff,
-        ...newRecord,
-        updater: user
-      })
-
-      results.push({ ...result, cuFlag: 'M' })
-    }
-  }
-
-  return results
-}

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

@@ -1,6 +0,0 @@
-import { Query } from './plantation-inventory-query'
-
-export const PlantationInventoryResolver = {
-  Query,
-  Mutation: {}
-}

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

@@ -1,43 +0,0 @@
-import { buildQuery, ListParam } from '@things-factory/shell'
-
-import { Block as BlockEntity, PlantationInventory as PlantationInventoryEntity } from '../../../entities'
-
-export const Query = {
-  async plantationInventory(_: any, { blockId, type }, context: ResolverContext) {
-    const { tx, domain } = context.state
-
-    return await tx.getRepository(PlantationInventoryEntity).findOne({
-      where: {
-        domain: { id: domain.id },
-        block: { id: (await tx.getRepository(BlockEntity).findOne({ where: { id: blockId } })).id },
-        type
-      },
-      relations: ['domain', 'block', 'ramp', 'creator', 'updater']
-    })
-  },
-
-  async plantationInventories(_: any, params: ListParam, context: ResolverContext) {
-    const { tx } = context.state
-
-    const queryBuilder = tx.getRepository(PlantationInventoryEntity).createQueryBuilder()
-    buildQuery(queryBuilder, params, context)
-
-    let [items, total] = await queryBuilder
-      .leftJoinAndSelect('PlantationInventory.domain', 'Domain')
-      .leftJoinAndSelect('PlantationInventory.block', 'Block')
-      .leftJoinAndSelect('PlantationInventory.ramp', 'Ramp')
-      .leftJoinAndSelect('PlantationInventory.creator', 'Creator')
-      .leftJoinAndSelect('PlantationInventory.updater', 'Updater')
-      .getManyAndCount()
-
-    items = items.map((item: PlantationInventoryEntity) => {
-      return {
-        ...item,
-        rampName: item?.ramp ? item.ramp.name : null,
-        rampId: item?.ramp ? item.ramp.id : null
-      }
-    })
-
-    return { items, total }
-  }
-}

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

@@ -1,16 +0,0 @@
-import { getRepository } from '@things-factory/shell'
-
-import { PlantationSetting } from '../../../entities'
-
-export const createPlantationSetting = {
-  async createPlantationSetting(_: any, { plantationSetting }, context: ResolverContext) {
-    const { domain, user } = context.state
-
-    return await getRepository(PlantationSetting).save({
-      ...plantationSetting,
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-}