@things-factory/operato-pms 3.8.0 → 3.8.13

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

@@ -1,17 +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_TYPE, INVENTORY_STATUS, TRANSACTION_TYPE } from '../../../constants'
-import {
-  Block,
-  DailyLoading,
-  DailyLoadingDetail,
-  DailyLoadingRamp,
-  Ramp,
-  OrganizationStaff,
-  PlantationInventory
-} from '../../../entities'
-import { NoGenerator, generateTransactionHistory } from '../../../utils'
+
+import { Block, DailyLoading, DailyLoadingDetail, PlantationInventory, Ramp, Truck } from '../../../entities'
+import { NoGenerator } from '../../../utils'
 
 export const updateDailyLoading = {
   async updateDailyLoading(_: any, { name, dailyLoadingPatch }, context: any) {
@@ -21,23 +14,13 @@ export const updateDailyLoading = {
     let dailyLoading: DailyLoading = await dailyLoadingRepo.findOne({
       where: { name },
       relations: [
-        'block',
         'dailyLoadingDetails',
-        'dailyLoadingDetails.organizationStaff',
-        'dailyLoadingRamps',
-        'dailyLoadingRamps.ramp'
+        'dailyLoadingDetails.truck',
+        'dailyLoadingDetails.ramp',
+        'dailyLoadingDetails.block'
       ]
     })
 
-    const block: Block = await tx.getRepository(Block).findOne({
-      where: { name: dailyLoadingPatch.block }
-    })
-
-    const {
-      totalBunch: prevLoadedBunch,
-      totalWeight: prevLoadedTonnage
-    }: { totalBunch: number; totalWeight: number } = dailyLoading
-
     // get sum of bunch loaded from all trip
     var totalBunch: number = dailyLoadingPatch.dailyLoadingDetails.reduce(function (prev, cur) {
       return prev + cur.totalBunchLoaded
@@ -47,7 +30,6 @@ export const updateDailyLoading = {
       return prev + cur.totalBunchWeight
     }, 0)
 
-    dailyLoading.block = block
     dailyLoading.totalBunch = totalBunch
     dailyLoading.totalWeight = totalWeight
     dailyLoading.loadingDate = dailyLoadingPatch.loadingDate
@@ -56,8 +38,6 @@ export const updateDailyLoading = {
 
     // 2. Create daily loading detail
     await updateDailyLoadingDetail(domain, dailyLoading, dailyLoadingPatch.dailyLoadingDetails, user, tx)
-    await updateDailyLoadingRamp(domain, dailyLoading, dailyLoadingPatch.dailyLoadingRamps, user, tx)
-    await updatePlantationInventory(domain, dailyLoading, prevLoadedBunch, prevLoadedTonnage, block, user, tx)
 
     return dailyLoading
   }
@@ -70,8 +50,9 @@ export async function updateDailyLoadingDetail(
   user: User,
   tx?: EntityManager
 ): Promise<void> {
-  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)
 
@@ -90,22 +71,22 @@ export async function updateDailyLoadingDetail(
       dailyLoadingDetails.map(async (record: DailyLoadingDetail) => {
         const foundDailyLoadingDetailPatch = dailyLoadingDetailPatches.find(detail => detail.name === record.name)
 
-        const foundStaff: OrganizationStaff = await organizationStaffRepo.findOne({
-          where: { id: foundDailyLoadingDetailPatch.organizationStaff.id }
-        })
-
         return {
           ...record,
           dailyLoading,
-          organizationStaff: foundStaff,
-          totalBunchLoaded: foundDailyLoadingDetailPatch.totalBunchLoaded,
-          totalBunchWeight: foundDailyLoadingDetailPatch.totalBunchWeight,
-          remark: foundDailyLoadingDetailPatch.remark,
+          truck: await truckRepo.findOne({ id: record.truck.id }),
+          block: await blockRepo.findOne({ id: record.block.id }),
+          ramp: await rampRepo.findOne({ id: record.ramp.id }),
+          totalBunchLoaded: foundDailyLoadingDetailPatch?.totalBunchLoaded || 0,
+          totalBunchWeight: foundDailyLoadingDetailPatch?.totalBunchWeight || 0,
+          remark: foundDailyLoadingDetailPatch?.remark || null,
           updater: user
         }
       })
     )
-    await dailyLoadingDetailRepo.save(updatedDailyLoadingDetails)
+    updatedDailyLoadingDetails = await dailyLoadingDetailRepo.save(updatedDailyLoadingDetails)
+
+    // await updatePlantationInventory(domain, dailyLoading, updatedDailyLoadingDetails, user, tx)
   }
 
   if (newDailyLoadingDetail?.length > 0) {
@@ -114,14 +95,13 @@ export async function updateDailyLoadingDetail(
         let newDailyLoadingDetail: DailyLoadingDetail = new DailyLoadingDetail()
         newDailyLoadingDetail.domain = domain
         newDailyLoadingDetail.name = NoGenerator.dailyLoadingDetail()
-        newDailyLoadingDetail.organizationStaff = await organizationStaffRepo.findOne({
-          id: dailyLoadingDetail.organizationStaff.id
-        })
-        newDailyLoadingDetail.totalBunchLoaded = dailyLoadingDetail.totalBunchLoaded
-        newDailyLoadingDetail.totalBunchWeight = dailyLoadingDetail.totalBunchWeight
-        newDailyLoadingDetail.remark = dailyLoadingDetail.remark
+        newDailyLoadingDetail.truck = await truckRepo.findOne({ id: dailyLoadingDetail.truck.id })
+        newDailyLoadingDetail.block = await blockRepo.findOne({ id: dailyLoadingDetail.block.id })
+        newDailyLoadingDetail.ramp = await rampRepo.findOne({ id: dailyLoadingDetail.ramp.id })
+        newDailyLoadingDetail.totalBunchLoaded = dailyLoadingDetail?.totalBunchLoaded || 0
+        newDailyLoadingDetail.totalBunchWeight = dailyLoadingDetail?.totalBunchWeight || 0
+        newDailyLoadingDetail.remark = dailyLoadingDetail?.remark || null
         newDailyLoadingDetail.creator = user
-        newDailyLoadingDetail.updater = user
         newDailyLoadingDetail.dailyLoading = dailyLoading
 
         await dailyLoadingDetailRepo.save(newDailyLoadingDetail)
@@ -130,70 +110,10 @@ export async function updateDailyLoadingDetail(
   }
 }
 
-export async function updateDailyLoadingRamp(
-  domain: Domain,
-  dailyLoading: DailyLoading,
-  dailyLoadingRampPatches: DailyLoadingRamp[],
-  user: User,
-  tx?: EntityManager
-): Promise<void> {
-  const rampRepo: Repository<Ramp> = tx?.getRepository(Ramp) || getRepository(Ramp)
-  const dailyLoadingRampRepo: Repository<DailyLoadingRamp> =
-    tx?.getRepository(DailyLoadingRamp) || getRepository(DailyLoadingRamp)
-
-  let updatedDailyLoadingRamps: any[] = []
-  const dailyLoadingRamps: DailyLoadingRamp[] = dailyLoading.dailyLoadingRamps
-  const existingDailyLoadingRamps: DailyLoadingRamp[] = dailyLoadingRampPatches.filter(detail => detail.name !== null)
-
-  // new row added in client side
-  const newDailyLoadingRamps: DailyLoadingRamp[] = dailyLoadingRampPatches.filter(detail => detail.name === null)
-
-  if (existingDailyLoadingRamps?.length > 0) {
-    // TODO: delete function for removing data
-    updatedDailyLoadingRamps = await Promise.all(
-      dailyLoadingRamps.map(async (dailyLoadingRamp: DailyLoadingRamp) => {
-        const foundDailyLoadingRampPatch = dailyLoadingRampPatches.find(detail => detail.name === dailyLoadingRamp.name)
-
-        const foundRamp: Ramp = await rampRepo.findOne({
-          where: { id: foundDailyLoadingRampPatch.ramp.id }
-        })
-
-        return {
-          ...dailyLoadingRamp,
-          dailyLoading,
-          ramp: foundRamp,
-          totalBunchWeight: foundDailyLoadingRampPatch.totalBunchWeight,
-          updater: user
-        }
-      })
-    )
-    await dailyLoadingRampRepo.save(updatedDailyLoadingRamps)
-  }
-
-  if (newDailyLoadingRamps?.length > 0) {
-    await Promise.all(
-      newDailyLoadingRamps.map(async (dailyLoadingRamp: DailyLoadingRamp) => {
-        let newDailyLoadingRamp: DailyLoadingRamp = new DailyLoadingRamp()
-        newDailyLoadingRamp.domain = domain
-        newDailyLoadingRamp.name = NoGenerator.dailyLoadingDetail()
-        newDailyLoadingRamp.ramp = await rampRepo.findOne({ id: dailyLoadingRamp.ramp.id })
-        newDailyLoadingRamp.totalBunchWeight = dailyLoadingRamp.totalBunchWeight
-        newDailyLoadingRamp.creator = user
-        newDailyLoadingRamp.updater = user
-        newDailyLoadingRamp.dailyLoading = dailyLoading
-
-        await dailyLoadingRampRepo.save(newDailyLoadingRamp)
-      })
-    )
-  }
-}
-
 export async function updatePlantationInventory(
   domain: Domain,
   dailyLoading: DailyLoading,
-  prevLoadedBunch: number,
-  prevLoadedTonnage: number,
-  block: Block,
+  updatedDailyLoadingDetails: DailyLoadingDetail[],
   user: User,
   tx?: EntityManager
 ): Promise<void> {
@@ -201,110 +121,4 @@ export async function updatePlantationInventory(
     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 originBunchesInventory: number = existingBunchesInventory.totalBunches + prevLoadedBunch
-  const loadedFieldBunches: number = dailyLoading.totalBunch
-
-  if (!existingBunchesInventory) throw new Error('Unable to find plantation bunches inventory')
-  existingBunchesInventory.totalBunches = originBunchesInventory - loadedFieldBunches
-  existingBunchesInventory.updater = user
-  existingBunchesInventory = await plantationInvRepo.save(existingBunchesInventory)
-
-  await generateTransactionHistory(
-    existingBunchesInventory,
-    dailyLoading.id,
-    dailyLoading.name,
-    TRANSACTION_TYPE.BUNCHES_ADJUSTMENT,
-    dailyLoading.loadingDate,
-    prevLoadedBunch,
-    0,
-    user,
-    tx
-  )
-
-  await generateTransactionHistory(
-    existingBunchesInventory,
-    dailyLoading.id,
-    dailyLoading.name,
-    TRANSACTION_TYPE.BUNCHES_ADJUSTMENT,
-    dailyLoading.loadingDate,
-    -loadedFieldBunches,
-    0,
-    user,
-    tx
-  )
-
-  await Promise.all(
-    dailyLoading.dailyLoadingRamps.map(async (record: any) => {
-      const ramp: Ramp = await rampRepo.findOne({
-        where: { domain, id: record.ramp.id }
-      })
-
-      let existingRampTonnage: PlantationInventory = await plantationInvRepo.findOne({
-        where: { domain, type: INVENTORY_TYPE.RAMP_TONNAGE, ramp },
-        relations: ['domain', 'block', 'ramp']
-      })
-
-      const originRampTonnage: number = existingRampTonnage.totalTonnage - prevLoadedTonnage
-      const loadedRampTonnage: number = dailyLoading.totalWeight
-
-      if (existingRampTonnage) {
-        existingRampTonnage.totalTonnage = originRampTonnage - loadedRampTonnage
-        existingRampTonnage.updater = user
-        await plantationInvRepo.save(existingRampTonnage)
-
-        await generateTransactionHistory(
-          existingRampTonnage,
-          dailyLoading.id,
-          dailyLoading.name,
-          TRANSACTION_TYPE.TONNAGE_ADJUSTMENT,
-          dailyLoading.loadingDate,
-          0,
-          -prevLoadedTonnage,
-          user,
-          tx
-        )
-
-        await generateTransactionHistory(
-          existingRampTonnage,
-          dailyLoading.id,
-          dailyLoading.name,
-          TRANSACTION_TYPE.TONNAGE_ADJUSTMENT,
-          dailyLoading.loadingDate,
-          0,
-          loadedRampTonnage,
-          user,
-          tx
-        )
-      } else {
-        let plantationInventory: PlantationInventory = new PlantationInventory()
-        plantationInventory.domain = domain
-        plantationInventory.name = NoGenerator.rampTonnageName()
-        plantationInventory.block = block
-        plantationInventory.type = INVENTORY_TYPE.RAMP_TONNAGE
-        plantationInventory.totalTonnage = record.totalBunchWeight
-        plantationInventory.status = INVENTORY_STATUS.STORED
-        plantationInventory.ramp = ramp
-        plantationInventory.creator = user
-        plantationInventory = await plantationInvRepo.save(plantationInventory)
-
-        await generateTransactionHistory(
-          plantationInventory,
-          dailyLoading.id,
-          dailyLoading.name,
-          TRANSACTION_TYPE.LOADING,
-          dailyLoading.loadingDate,
-          0,
-          record.totalBunchWeight,
-          user,
-          tx
-        )
-      }
-    })
-  )
 }

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

@@ -0,0 +1,96 @@
+// 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: any) {
+    if (blockId == 'ALL_BLOCKS') {
+      // should remove block filter
+      // 'ALL_BLOCKS' was hardcoded from dashboard
+    }
+
+    const year: string = yearAndMonth.substring(0, 4)
+    const month: string = yearAndMonth.substring(4)
+
+    let data = []
+
+    for (let i = 1, l = new Date(Number(year), Number(month), 0).getDate(); i <= l; i++) {
+      let theDate = new Date(`${year}-${month}-${i}`)
+      theDate.setHours(8, 0, 0, 0)
+
+      data.push({
+        blockId,
+        tonnage: Math.floor(Math.random() * 1000) + 200, // generate random value within 200-1000
+        year,
+        month,
+        date: theDate.toLocaleString('default', { day: '2-digit', month: 'short' })
+      })
+    }
+
+    return data.sort((a, b) => (a.date > b.date ? 1 : -1))
+  },
+
+  async monthlyYields(_: any, { blockId, yearAndMonth }, context: any) {
+    if (blockId == 'ALL_BLOCKS') {
+      // should remove block filter
+      // 'ALL_BLOCKS' was hardcoded from dashboard
+    }
+
+    const year: string = yearAndMonth.substring(0, 4)
+    const month: string = yearAndMonth.substring(4)
+
+    let data = []
+
+    for (let i = 1, l = new Date(Number(year), Number(month), 0).getDate(); i <= l; i++) {
+      let theDate = new Date(`${year}-${month}-${i}`)
+      theDate.setHours(8, 0, 0, 0)
+
+      data.push({
+        blockId,
+        yield: Math.floor(Math.random() * 1000) + 200, // generate random value within 200-1000
+        year,
+        month,
+        date: theDate.toLocaleString('default', { day: '2-digit', month: 'short' })
+      })
+    }
+
+    return data.sort((a, b) => (a.date > b.date ? 1 : -1))
+  },
+
+  async weeklyBunchesCount(_: any, { targetDate }, context: any) {
+    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: 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: any) {
+    return {
+      bunches: Math.floor(Math.random() * 10000) + 500,
+      tonnage: Math.floor(Math.random() * 10000) + 500
+    }
+  },
+
+  async productionsOverview(_: any, { something }, context: any) {
+    return {
+      averageBunchWeight: Math.floor(Math.random() * 150) + 70,
+      bunchesCount: Math.floor(Math.random() * 10000) + 500,
+      tonnageWeighed: Math.floor(Math.random() * 10000) + 500
+    }
+  }
+}

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

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

package/server/graphql/resolvers/index.ts

@@ -1,16 +1,20 @@
-export * from './block'
 export * from './block-detail'
+export * from './block'
 export * from './daily-block-detail'
-export * from './daily-dispatch'
 export * from './daily-dispatch-detail'
-export * from './daily-harvest'
+export * from './daily-dispatch'
 export * from './daily-harvest-detail'
-export * from './daily-loading'
+export * from './daily-harvest'
 export * from './daily-loading-detail'
 export * from './daily-loading-ramp'
-export * from './organization'
+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 './report'
 export * from './record-transaction'
+export * from './report'
+
+export * from './truck'

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

@@ -1,5 +1,7 @@
-import { buildQuery, ListParam, Domain } from '@things-factory/shell'
-import { IsNull, EntityManager } from 'typeorm'
+import { EntityManager, IsNull } from 'typeorm'
+
+import { buildQuery, Domain, ListParam } from '@things-factory/shell'
+
 import { OrganizationStaff as OrganizationStaffEntity } from '../../../entities'
 
 export const Query = {
@@ -15,7 +17,7 @@ export const Query = {
   async organizationStaffs(_: any, params: ListParam, context: any) {
     const { tx }: { tx: EntityManager } = context.state
 
-    const queryBuilder = tx.getRepository(OrganizationStaffEntity).createQueryBuilder()
+    const queryBuilder = await tx.getRepository(OrganizationStaffEntity).createQueryBuilder()
     buildQuery(queryBuilder, params, context)
 
     queryBuilder
@@ -27,7 +29,14 @@ export const Query = {
     if (params.filters?.length > 0) queryBuilder.andWhere('OrganizationStaff.deletedAt IS NULL')
     else queryBuilder.where('OrganizationStaff.deletedAt IS NULL')
 
-    const [items, total] = await queryBuilder.getManyAndCount()
+    let [items, total] = await queryBuilder.getManyAndCount()
+
+    items = items.map(item => {
+      return {
+        ...item,
+        organizationName: item.organization?.name
+      }
+    })
 
     return { items, total }
   }

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

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

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

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

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

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

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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,38 @@
+import { getRepository } from 'typeorm'
+import { Domain, ListParam, convertListParams } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { PlantationSetting as PlantationSettingEntity } from '../../../entities'
+
+export const Query = {
+  async plantationSetting(_: any, { name }, context: any) {
+    const { domain, user } = context.state
+    const repository = getRepository(PlantationSettingEntity)
+
+    return await repository.findOne({
+      where: { domain, name }
+    })
+  },
+
+  async plantationSettings(_: any, params: ListParam, context: any) {
+    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).findOne(plantationSetting.domainId)
+  },
+
+  async creator(plantationSetting) {
+    return await getRepository(User).findOne(plantationSetting.creatorId)
+  },
+
+  async updater(plantationSetting) {
+    return await getRepository(User).findOne(plantationSetting.updaterId)
+  }
+}

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

@@ -0,0 +1,46 @@
+import { getRepository } from 'typeorm'
+import { PlantationSetting } from '../../../entities'
+
+export const updateMultiplePlantationSetting = {
+  async updateMultiplePlantationSetting(_: any, { patches }, context: any) {
+    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.findOne({ domain, 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

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