@things-factory/operato-pms 4.3.373 → 4.3.379

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

@@ -27,10 +27,31 @@ export const Query = {
     const { tx }: { tx: EntityManager } = context.state
 
     try {
-      const dispatchIndex = params.filters.findIndex(filter => filter.name == 'dispatchAt')
-      const dispatchAt = params.filters[dispatchIndex]?.value
+      const fromDateParamIdx = params.filters.findIndex(param => param.name === 'fromDate')
+      if (fromDateParamIdx >= 0) {
+        let dispatchDateFrom = params.filters.find(param => param.name === 'fromDate')?.value
+        params.filters.splice(fromDateParamIdx, 1)
 
-      params.filters = params.filters.splice(dispatchIndex + 1, 1)
+        params.filters.push({
+          name: 'dispatchAt',
+          operator: 'gte',
+          value: dispatchDateFrom,
+          relation: false
+        })
+      }
+
+      const toDateParamIdx = params.filters.findIndex(param => param.name === 'toDate')
+      if (toDateParamIdx >= 0) {
+        let dispatchDateTo = params.filters.find(param => param.name === 'toDate')?.value
+        params.filters.splice(toDateParamIdx, 1)
+
+        params.filters.push({
+          name: 'dispatchAt',
+          operator: 'lte',
+          value: dispatchDateTo,
+          relation: false
+        })
+      }
 
       const queryBuilder = tx.getRepository(DailyDispatchEntity).createQueryBuilder()
       buildQuery(queryBuilder, params, context)
@@ -46,14 +67,10 @@ export const Query = {
 
       if (params.filters?.length > 0) {
         queryBuilder.andWhere('DailyDispatch.deletedAt IS NULL')
-      }
-      else {
+      } else {
         queryBuilder.where('DailyDispatch.deletedAt IS NULL')
       }
 
-      if (dispatchAt)
-        queryBuilder.andWhere(`DailyDispatch.dispatchAt between :dispatchAt::timestamp and :dispatchAt::timestamp + interval '1 day' `, { dispatchAt })
-
       const [items, total] = await queryBuilder.getManyAndCount()
 
       return { items, total }

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

@@ -4,8 +4,16 @@ import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
 
 import { RECORD_STATUS, TRANSACTION_TYPE } from '../../../constants'
-import { DailyDispatch, DailyDispatchDetail, Organization, OrganizationStaff, Ramp, Truck } from '../../../entities'
-import { generateTransactionHistory, NoGenerator } from '../../../utils'
+import {
+  Block,
+  DailyDispatch,
+  DailyDispatchDetail,
+  Organization,
+  OrganizationStaff,
+  Ramp,
+  Truck
+} from '../../../entities'
+import { generateRampBlockHistories, generateTransactionHistory, NoGenerator } from '../../../utils'
 
 export const generateDailyDispatch = {
   async generateDailyDispatch(_: any, { dailyDispatch }, context: any) {
@@ -108,24 +116,100 @@ export async function generateDispatchTransaction(
   user: User,
   tx?: EntityManager
 ): Promise<void> {
-  await Promise.all(
-    dailyDispatchDetails.map(async record => {
-      const dispatchedTonnage: number = record.collectedRampWeight
-      const dispatchDate: string = newDailyDispatch.dispatchAt.toString().split('T')[0]
+  const blockRepo: Repository<Block> = tx?.getRepository(Block) || getRepository(Block)
 
-      await generateTransactionHistory(
-        null,
+  for (let dailyDispatch of dailyDispatchDetails) {
+    const dispatchedTonnage: number = dailyDispatch.collectedRampWeight
+    const dispatchDate: string = newDailyDispatch.dispatchAt.toString().split('T')[0]
+    const ramp: Ramp = dailyDispatch.ramp
+
+    await generateTransactionHistory(
+      null,
+      domain,
+      dailyDispatch.ramp,
+      newDailyDispatch.id,
+      newDailyDispatch.name,
+      TRANSACTION_TYPE.DISPATCHMENT,
+      dispatchDate,
+      0,
+      -dispatchedTonnage,
+      user,
+      tx
+    )
+
+    let rampBlockHistory = await tx.query(
+      `
+        SELECT * FROM (
+          SELECT *, ROW_NUMBER () OVER (PARTITION BY ramp_id, block_id ORDER BY transaction_date desc, transaction_type) AS rn FROM ramp_block_histories 
+          WHERE ramp_id =$1 AND transaction_date <= $2
+        ) foo WHERE rn = 1
+      `,
+      [ramp.id, dispatchDate]
+    )
+
+    let totalRampWeight: number = rampBlockHistory.reduce((total, currentValue) => {
+      total += currentValue.previous_weight + currentValue.weight
+      return total
+    }, 0)
+
+    for (let index = 0; index < rampBlockHistory.length; index++) {
+      const dt2 = rampBlockHistory[index]
+      const block: Block = await blockRepo.findOne({ id: dt2.block_id })
+
+      let currentRampBlockWeight = dt2.previous_weight + dt2.weight
+      let percentage = parseFloat((currentRampBlockWeight / totalRampWeight).toFixed(4))
+      let weight = (-dispatchedTonnage * percentage).toFixed(4)
+
+      //   // insert into ramp_block_histories (id,transaction_type, creator_id, updater_id, transaction_date, created_at, updated_at, weight, domain_id, block_id, ramp_id)
+      //   let processedData = await tx.query(
+      //     `
+      //     insert into ramp_block_histories (id, seq, transaction_type, creator_id, updater_id, transaction_date, created_at, updated_at, domain_id, ramp_id, weight, previous_weight, current_weight, block_id, daily_dispatch_id)
+      //     SELECT uuid_generate_v4() AS id, (select seq from ramp_block_histories where ramp_id = '${ramp.id}' and domain_id = '${domain.id}' order by seq desc limit 1) + 1,'DISPATCH' AS transaction_type,
+      //     '0933baea-e099-494b-9791-3dfe805731f0' AS creator_id, '0933baea-e099-494b-9791-3dfe805731f0' AS updater_id,
+      //     $1 AS transaction_date, $2 AS created_at, $3 AS updated_at,
+      //     $4 AS domain_id, $5 AS ramp_id,
+      //     $6 AS weight,
+      //     $7 AS previous_weight,
+      //     $8 AS current_weight,
+      //     $9 AS block_id,
+      //     $10 AS daily_dispatch_id
+      // `,
+      //     [
+      //       dispatchDate,
+      //       dt2.created_at,
+      //       dt2.updated_at,
+      //       domain.id,
+      //       ramp.id,
+      //       parseFloat(weight),
+      //       parseFloat(currentRampBlockWeight),
+      //       parseFloat(currentRampBlockWeight) + parseFloat(weight),
+      //       dt2.block_id,
+      //       newDailyDispatch.id
+      //     ]
+      //   )
+
+      await generateRampBlockHistories(
+        block,
         domain,
-        record.ramp,
-        newDailyDispatch.id,
-        newDailyDispatch.name,
-        TRANSACTION_TYPE.DISPATCHMENT,
+        ramp,
+        'DISPATCH',
         dispatchDate,
-        0,
-        -dispatchedTonnage,
+        parseFloat(weight),
         user,
+        null,
+        newDailyDispatch,
         tx
       )
-    })
-  )
+
+      // await txMgr.query(`
+      //   SELECT * FROM (
+      //     SELECT *, ROW_NUMBER () OVER (PARTITION BY ramp_id, block_id ORDER BY transaction_date desc) AS rn FROM ramp_block_histories
+      //     WHERE ramp_id =$1 AND transaction_date <= $2
+      //   ) foo WHERE rn = 1
+      // `, [dt.ramp_id, dt.transaction_date]
+      // )
+      let x = dt2
+    }
+    let x = rampBlockHistory
+  }
 }

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

@@ -27,6 +27,32 @@ export const Query = {
   async dailyHarvests(_: any, params: ListParam, context: any) {
     const { tx }: { tx: EntityManager } = context.state
 
+    const fromDateParamIdx = params.filters.findIndex(param => param.name === 'fromDate')
+    if (fromDateParamIdx >= 0) {
+      let harvestDateFrom = params.filters.find(param => param.name === 'fromDate')?.value
+      params.filters.splice(fromDateParamIdx, 1)
+
+      params.filters.push({
+        name: 'harvestDate',
+        operator: 'gte',
+        value: harvestDateFrom,
+        relation: false
+      })
+    }
+
+    const toDateParamIdx = params.filters.findIndex(param => param.name === 'toDate')
+    if (toDateParamIdx >= 0) {
+      let harvestDateTo = params.filters.find(param => param.name === 'toDate')?.value
+      params.filters.splice(toDateParamIdx, 1)
+
+      params.filters.push({
+        name: 'harvestDate',
+        operator: 'lte',
+        value: harvestDateTo,
+        relation: false
+      })
+    }
+
     const queryBuilder = tx.getRepository(DailyHarvestEntity).createQueryBuilder()
     buildQuery(queryBuilder, params, context)
 

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

@@ -25,6 +25,32 @@ export const Query = {
   async dailyLoadings(_: any, params: ListParam, context: any) {
     const { tx }: { tx: EntityManager } = context.state
 
+    const fromDateParamIdx = params.filters.findIndex(param => param.name === 'fromDate')
+    if (fromDateParamIdx >= 0) {
+      let loadingDateFrom = params.filters.find(param => param.name === 'fromDate')?.value
+      params.filters.splice(fromDateParamIdx, 1)
+
+      params.filters.push({
+        name: 'loadingDate',
+        operator: 'gte',
+        value: loadingDateFrom,
+        relation: false
+      })
+    }
+
+    const toDateParamIdx = params.filters.findIndex(param => param.name === 'toDate')
+    if (toDateParamIdx >= 0) {
+      let loadingDateTo = params.filters.find(param => param.name === 'toDate')?.value
+      params.filters.splice(toDateParamIdx, 1)
+
+      params.filters.push({
+        name: 'loadingDate',
+        operator: 'lte',
+        value: loadingDateTo,
+        relation: false
+      })
+    }
+
     const queryBuilder = tx.getRepository(DailyLoadingEntity).createQueryBuilder()
     buildQuery(queryBuilder, params, context)
 

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

@@ -5,7 +5,7 @@ import { Domain } from '@things-factory/shell'
 
 import { INVENTORY_STATUS, INVENTORY_TYPE, RECORD_STATUS, TRANSACTION_TYPE } from '../../../constants'
 import { Block, DailyLoading, DailyLoadingDetail, PlantationInventory, Ramp, Truck } from '../../../entities'
-import { generateTransactionHistory, NoGenerator } from '../../../utils'
+import { generateTransactionHistory, generateRampBlockHistories, NoGenerator } from '../../../utils'
 
 export const generateDailyLoading = {
   async generateDailyLoading(_: any, { dailyLoading }, context: any) {
@@ -93,57 +93,68 @@ export async function updatePlantationInventory(
   const plantationInvRepo: Repository<PlantationInventory> =
     tx?.getRepository(PlantationInventory) || getRepository(PlantationInventory)
 
-  await Promise.all(
-    dailyLoadingDetails.map(async (dailyLoadingDetail: any) => {
-      let existingRampTonnage: PlantationInventory = await plantationInvRepo.findOne({
-        where: { domain, type: INVENTORY_TYPE.RAMP_TONNAGE, ramp: dailyLoadingDetail.ramp },
-        relations: ['domain', 'block', 'ramp']
-      })
-
-      if (existingRampTonnage) {
-        existingRampTonnage.totalTonnage = existingRampTonnage.totalTonnage + dailyLoadingDetail.totalBunchWeight
-        existingRampTonnage.updater = user
-        await plantationInvRepo.save(existingRampTonnage)
-
-        await generateTransactionHistory(
-          dailyLoadingDetail.block,
-          domain,
-          dailyLoadingDetail.ramp,
-          newDailyLoading.id,
-          newDailyLoading.name,
-          TRANSACTION_TYPE.LOADING,
-          newDailyLoading.loadingDate,
-          0,
-          dailyLoadingDetail.totalBunchWeight,
-          user,
-          tx
-        )
-      } else {
-        let plantationInventory: PlantationInventory = new PlantationInventory()
-        plantationInventory.domain = domain
-        plantationInventory.name = NoGenerator.rampTonnageName()
-        plantationInventory.block = dailyLoadingDetail.block
-        plantationInventory.type = INVENTORY_TYPE.RAMP_TONNAGE
-        plantationInventory.totalTonnage = dailyLoadingDetail.totalBunchWeight
-        plantationInventory.status = INVENTORY_STATUS.STORED
-        plantationInventory.ramp = dailyLoadingDetail.ramp
-        plantationInventory.creator = user
-        plantationInventory = await plantationInvRepo.save(plantationInventory)
-
-        await generateTransactionHistory(
-          dailyLoadingDetail.block,
-          domain,
-          dailyLoadingDetail.ramp,
-          newDailyLoading.id,
-          newDailyLoading.name,
-          TRANSACTION_TYPE.LOADING,
-          newDailyLoading.loadingDate,
-          0,
-          dailyLoadingDetail.totalBunchWeight,
-          user,
-          tx
-        )
-      }
+  for (let dailyLoadingDetail of dailyLoadingDetails) {
+    let existingRampTonnage: PlantationInventory = await plantationInvRepo.findOne({
+      where: { domain, type: INVENTORY_TYPE.RAMP_TONNAGE, ramp: dailyLoadingDetail.ramp },
+      relations: ['domain', 'block', 'ramp']
     })
-  )
+
+    if (existingRampTonnage) {
+      existingRampTonnage.totalTonnage = existingRampTonnage.totalTonnage + dailyLoadingDetail.totalBunchWeight
+      existingRampTonnage.updater = user
+      await plantationInvRepo.save(existingRampTonnage)
+
+      await generateTransactionHistory(
+        dailyLoadingDetail.block,
+        domain,
+        dailyLoadingDetail.ramp,
+        newDailyLoading.id,
+        newDailyLoading.name,
+        TRANSACTION_TYPE.LOADING,
+        newDailyLoading.loadingDate,
+        0,
+        dailyLoadingDetail.totalBunchWeight,
+        user,
+        tx
+      )
+    } else {
+      let plantationInventory: PlantationInventory = new PlantationInventory()
+      plantationInventory.domain = domain
+      plantationInventory.name = NoGenerator.rampTonnageName()
+      plantationInventory.block = dailyLoadingDetail.block
+      plantationInventory.type = INVENTORY_TYPE.RAMP_TONNAGE
+      plantationInventory.totalTonnage = dailyLoadingDetail.totalBunchWeight
+      plantationInventory.status = INVENTORY_STATUS.STORED
+      plantationInventory.ramp = dailyLoadingDetail.ramp
+      plantationInventory.creator = user
+      plantationInventory = await plantationInvRepo.save(plantationInventory)
+
+      await generateTransactionHistory(
+        dailyLoadingDetail.block,
+        domain,
+        dailyLoadingDetail.ramp,
+        newDailyLoading.id,
+        newDailyLoading.name,
+        TRANSACTION_TYPE.LOADING,
+        newDailyLoading.loadingDate,
+        0,
+        dailyLoadingDetail.totalBunchWeight,
+        user,
+        tx
+      )
+    }
+
+    await generateRampBlockHistories(
+      dailyLoadingDetail.block,
+      domain,
+      dailyLoadingDetail.ramp,
+      'LOADING',
+      newDailyLoading.loadingDate,
+      dailyLoadingDetail.totalBunchWeight,
+      user,
+      null,
+      null,
+      tx
+    )
+  }
 }

package/server/utils/transaction-util.ts

@@ -1,7 +1,15 @@
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
 import { INVENTORY_STATUS, RAMP_STATUS, TRANSACTION_TYPE } from '../constants'
-import { PlantationInventory, RecordTransaction, Ramp, Block } from '../entities'
+import {
+  DailyDispatch,
+  DailyLoading,
+  PlantationInventory,
+  RecordTransaction,
+  Ramp,
+  Block,
+  RampBlockHistory
+} from '../entities'
 import { NoGenerator } from '../utils'
 import { EntityManager, getRepository, Repository } from 'typeorm'
 
@@ -53,6 +61,92 @@ export async function generateTransactionHistory(
   return recTransactionHistory
 }
 
+/**
+ * @description It will insert new record into transaction table.
+ * seq will be calculated based on number of records for one specific plantation inventory
+ */
+
+export async function generateRampBlockHistories(
+  block: Block,
+  domain: Domain,
+  ramp: Ramp,
+  transactionType: string,
+  transactionDate: string,
+  rampWeight: number,
+  user: User,
+  deletedAt?: any,
+  dailyDispatch?: DailyDispatch,
+  trxMgr?: EntityManager
+): Promise<RampBlockHistory> {
+  console.log(block, domain, ramp, user)
+  const rampBlockHistoryRepo: Repository<RampBlockHistory> =
+    trxMgr?.getRepository(RampBlockHistory) || getRepository(RampBlockHistory)
+
+  if (!ramp?.id) throw new Error(`Can't find a matching ramp.`)
+
+  const lastRampBlockHistory: RampBlockHistory = await rampBlockHistoryRepo.findOne({
+    where: { domain, ramp, block },
+    order: { seq: 'DESC' }
+  })
+
+  let res: any
+
+  if (!lastRampBlockHistory) {
+    res = await rampBlockHistoryRepo
+      .createQueryBuilder()
+      .insert()
+      .into(RampBlockHistory)
+      .values([
+        {
+          transactionDate,
+          transactionType,
+          seq: 0,
+          domain,
+          block,
+          ramp,
+          weight: rampWeight,
+          previousWeight: 0,
+          currentWeight: rampWeight,
+          dailyDispatch,
+          deletedAt: deletedAt ? deletedAt : null,
+          creator: user,
+          updater: user
+        }
+      ])
+      .returning('*')
+      .execute()
+  } else {
+    const previousWeight: number = lastRampBlockHistory.currentWeight
+
+    res = await rampBlockHistoryRepo
+      .createQueryBuilder()
+      .insert()
+      .into(RampBlockHistory)
+      .values([
+        {
+          domain,
+          block,
+          ramp,
+          transactionType,
+          transactionDate,
+          weight: rampWeight,
+          previousWeight,
+          currentWeight: parseFloat((previousWeight + rampWeight).toFixed(4)),
+          creator: user,
+          updater: user,
+          seq: () =>
+            `(select seq from ramp_block_histories where ramp_id = '${ramp.id}' and block_id = '${block.id}' and domain_id = '${domain.id}' order by seq desc limit 1) + 1`
+        }
+      ])
+      .returning('*')
+      .execute()
+  }
+
+  let newRampBlockHistory: RampBlockHistory = res.generatedMaps[0]
+
+  return newRampBlockHistory
+}
+
 /**
  * @description: Check ramp emptiness and update status of ramp
  * @param domain

package/translations/en.json

@@ -31,6 +31,7 @@
   "field.estimated_ffb": "estimated ffb",
   "field.estimated_last_ffb": "estimated last ffb",
   "field.field_bunches": "field bunches",
+  "field.from": "from",
   "field.harvest_date": "harvest date",
   "field.harvested_today": "harvested today",
   "field.harvesting_rd": "harvesting rd",
@@ -66,6 +67,7 @@
   "field.staff": "staff",
   "field.status": "status",
   "field.task_no": "task no",
+  "field.to": "to",
   "field.to_date_bunch_harvest": "to date bunch harvest",
   "field.to_date_out_turn": "to date out turn",
   "field.to_date_weight_dispatch": "to date weight dispatch",

package/translations/ja.json

@@ -30,10 +30,10 @@
   "field.total_no_of_bunches": "total no of bunches",
   "field.total_stand": "total stand",
   "field.total_tonnage": "total tonnage",
-  "field.total_tonnage_estimated": "total tonnage (estimated)",
   "field.total_weight_loaded": "total weight loaded",
   "field.total_weight": "total weight",
   "field.trip": "trip",
+  "field.total_tonnage_estimated": "total tonnage (estimated)",
   "field.type": "type",
   "field.valid_from": "valid from",
   "field.year_planted": "year planted",
@@ -41,7 +41,7 @@
   "label.block": "block",
   "label.chit_no": "chit no",
   "label.collected_bunch": "collected bunch",
-  "label.contractor": "[jp] contractor",
+  "label.contractor": "kontraktor",
   "label.coverage": "coverage",
   "label.date": "date",
   "label.harvesting_round": "harvesting round",
@@ -55,7 +55,7 @@
   "label.total_task_covered": "total task covered",
   "label.total_tonnage": "total tonnage",
   "label.yesterday_balance_bunch": "yesterday balance bunch",
-  "text.code-management": "[jp] code management",
+  "text.code-management": "[ms] code management",
   "text.create_harvesting_record": "create harvesting record",
   "text.create_loading_record": "create loading record",
   "text.destination_is_not_selected": "destination is not selected",
@@ -64,8 +64,8 @@
   "text.harvesting_record_invalid": "harvesting record invalid",
   "text.loading_record_created": "loading record created",
   "text.loading_record_invalid": "loading record invalid",
-  "text.invalid_percentage_value": "invalid percentage value",
   "text.no_records": "no records",
+  "text.invalid_percentage_value": "invalid percentage value",
   "text.there_is_duplicated_staff_in_record": "there is duplicated staff in this record",
   "text.total_bunch_weight_should_be_positive": "total bunch weight should be positive",
   "text.total_bunches_loaded_should_be_positive": "total bunches loaded should be positive",
@@ -75,16 +75,16 @@
   "text.x_has_invalid_value": "{x} has invalid value",
   "text.x_should_be_positive": "{x} should be positive",
   "text.you_wont_be_able_to_revert_this": "you wont be able to revert this",
-  "title.are_you_sure": "are you sure",
-  "title.block_details": "block details",
-  "title.block": "block",
-  "title.company": "company",
+  "title.are_you_sure": "adakah anda pasti",
+  "title.block_details": "butiran blok",
+  "title.block": "blok",
+  "title.company": "syarikat",
   "title.create_harvesting_record": "create harvesting record",
   "title.create_loading_record": "create loading record",
   "title.daily_ffb_dispatch_and_production": "daily FFB dispatch and production",
   "title.daily_loading_record": "daily loading record",
   "title.daily_production_report": "daily production report",
-  "title.global_plantation_setting": "[jp] global plantation setting",
+  "title.global_plantation_setting": "[ms] global plantation setting",
   "title.harvest_data": "harvest data",
   "title.harvest_list": "harvesting list",
   "title.harvest_no": "harvest no",

package/translations/ko.json

@@ -30,10 +30,10 @@
   "field.total_no_of_bunches": "total no of bunches",
   "field.total_stand": "total stand",
   "field.total_tonnage": "total tonnage",
-  "field.total_tonnage_estimated": "total tonnage (estimated)",
   "field.total_weight_loaded": "total weight loaded",
   "field.total_weight": "total weight",
   "field.trip": "trip",
+  "field.total_tonnage_estimated": "total tonnage (estimated)",
   "field.type": "type",
   "field.valid_from": "valid from",
   "field.year_planted": "year planted",
@@ -41,7 +41,7 @@
   "label.block": "block",
   "label.chit_no": "chit no",
   "label.collected_bunch": "collected bunch",
-  "label.contractor": "[ko] contractor",
+  "label.contractor": "kontraktor",
   "label.coverage": "coverage",
   "label.date": "date",
   "label.harvesting_round": "harvesting round",
@@ -55,7 +55,7 @@
   "label.total_task_covered": "total task covered",
   "label.total_tonnage": "total tonnage",
   "label.yesterday_balance_bunch": "yesterday balance bunch",
-  "text.code-management": "[ko] code management",
+  "text.code-management": "[ms] code management",
   "text.create_harvesting_record": "create harvesting record",
   "text.create_loading_record": "create loading record",
   "text.destination_is_not_selected": "destination is not selected",
@@ -64,8 +64,8 @@
   "text.harvesting_record_invalid": "harvesting record invalid",
   "text.loading_record_created": "loading record created",
   "text.loading_record_invalid": "loading record invalid",
-  "text.invalid_percentage_value": "invalid percentage value",
   "text.no_records": "no records",
+  "text.invalid_percentage_value": "invalid percentage value",
   "text.there_is_duplicated_staff_in_record": "there is duplicated staff in this record",
   "text.total_bunch_weight_should_be_positive": "total bunch weight should be positive",
   "text.total_bunches_loaded_should_be_positive": "total bunches loaded should be positive",
@@ -75,16 +75,16 @@
   "text.x_has_invalid_value": "{x} has invalid value",
   "text.x_should_be_positive": "{x} should be positive",
   "text.you_wont_be_able_to_revert_this": "you wont be able to revert this",
-  "title.are_you_sure": "are you sure",
-  "title.block_details": "block details",
-  "title.block": "block",
-  "title.company": "company",
+  "title.are_you_sure": "adakah anda pasti",
+  "title.block_details": "butiran blok",
+  "title.block": "blok",
+  "title.company": "syarikat",
   "title.create_harvesting_record": "create harvesting record",
   "title.create_loading_record": "create loading record",
   "title.daily_ffb_dispatch_and_production": "daily FFB dispatch and production",
   "title.daily_loading_record": "daily loading record",
   "title.daily_production_report": "daily production report",
-  "title.global_plantation_setting": "[ko] global plantation setting",
+  "title.global_plantation_setting": "[ms] global plantation setting",
   "title.harvest_data": "harvest data",
   "title.harvest_list": "harvesting list",
   "title.harvest_no": "harvest no",