@things-factory/kpi 9.0.18 → 9.0.19

package/server/service/kpi-metric-value/kpi-metric-value-mutation.ts

@@ -0,0 +1,215 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+import { getRepository } from '@things-factory/shell'
+import { Float } from 'type-graphql'
+import { KpiPeriodType } from '../kpi/kpi'
+
+import { KpiMetricValue } from './kpi-metric-value'
+import { NewKpiMetricValue, KpiMetricValuePatch } from './kpi-metric-value-type'
+import { KpiMetric } from '../kpi-metric/kpi-metric'
+import { ScalarObject } from '@things-factory/shell'
+
+function getISOWeek(date: Date): number {
+  const tmp = new Date(date.getTime())
+  tmp.setHours(0, 0, 0, 0)
+  tmp.setDate(tmp.getDate() + 4 - (tmp.getDay() || 7))
+  const yearStart = new Date(tmp.getFullYear(), 0, 1)
+  const weekNo = Math.ceil(((tmp.getTime() - yearStart.getTime()) / 86400000 + 1) / 7)
+  return weekNo
+}
+
+function getDefaultValueDate(periodType: KpiPeriodType): string {
+  const now = new Date()
+  switch (periodType) {
+    case KpiPeriodType.DAY:
+      return now.toISOString().slice(0, 10)
+    case KpiPeriodType.MONTH:
+      return now.toISOString().slice(0, 7)
+    case KpiPeriodType.QUARTER: {
+      const year = now.getFullYear()
+      const quarter = Math.floor(now.getMonth() / 3) + 1
+      return `${year}-Q${quarter}`
+    }
+    case KpiPeriodType.WEEK: {
+      const year = now.getFullYear()
+      const week = getISOWeek(now)
+      return `${year}-W${week}`
+    }
+    default:
+      return now.toISOString().slice(0, 10)
+  }
+}
+
+@Resolver(KpiMetricValue)
+export class KpiMetricValueMutation {
+  @Directive('@transaction')
+  @Mutation(returns => KpiMetricValue, { description: 'Create a new metric value with the provided details.' })
+  async createKpiMetricValue(
+    @Arg('metricValue', { description: 'Input object containing details for the new metric value.' })
+    metricValue: NewKpiMetricValue,
+    @Ctx() context: ResolverContext
+  ): Promise<KpiMetricValue> {
+    const { domain, user, tx } = context.state
+
+    let metric = metricValue.metricId
+      ? await getRepository(KpiMetric).findOne({ where: { id: metricValue.metricId } })
+      : undefined
+
+    const entity: Partial<KpiMetricValue> = {
+      metric,
+      metricId: metricValue.metricId,
+      valueDate: metricValue.valueDate,
+      periodType: metricValue.periodType,
+      value: metricValue.value,
+      group: metricValue.group,
+      unit: metricValue.unit,
+      meta: metricValue.meta,
+      domain: domain,
+      creator: user,
+      updater: user
+    }
+
+    return await getRepository(KpiMetricValue, tx).save(entity)
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => KpiMetricValue, { description: 'Record a metric value by metric name, value, meta, and group.' })
+  async recordKpiMetricValue(
+    @Arg('metricName', { description: 'Metric code/name.' }) metricName: string,
+    @Arg('value', type => Float, { nullable: true, description: 'Metric value (number).' }) value: number | null,
+    @Arg('meta', type => ScalarObject, { nullable: true, description: 'Extended or non-numeric information (JSON).' })
+    meta: any,
+    @Arg('group', { nullable: true, description: 'Group key for this value (organization, line, user, etc.)' })
+    group: string | null,
+    @Ctx() context: ResolverContext
+  ): Promise<KpiMetricValue> {
+    const { domain, user, tx } = context.state
+    const metric = await getRepository(KpiMetric).findOne({ where: { name: metricName, domain: { id: domain.id } } })
+    if (!metric) throw new Error(`Metric not found: ${metricName}`)
+    const periodType = (metric.periodType as unknown as KpiPeriodType) || KpiPeriodType.DAY
+    const valueDateToUse = getDefaultValueDate(periodType)
+    if (value == null && meta == null) {
+      throw new Error('Either value or meta must be provided.')
+    }
+    const entity: Partial<KpiMetricValue> = {
+      metric,
+      metricId: metric.id,
+      value,
+      meta,
+      valueDate: valueDateToUse,
+      periodType,
+      group,
+      domain,
+      creator: user,
+      updater: user
+    }
+    return await getRepository(KpiMetricValue, tx).save(entity)
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => KpiMetricValue, { description: 'To modify KpiMetricValue information' })
+  async updateKpiMetricValue(
+    @Arg('id') id: string,
+    @Arg('patch') patch: KpiMetricValuePatch,
+    @Ctx() context: ResolverContext
+  ): Promise<KpiMetricValue> {
+    const { domain, user, tx } = context.state
+
+    const repository = getRepository(KpiMetricValue, tx)
+    const metricValue = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    let metric = patch.metricId
+      ? await getRepository(KpiMetric).findOne({ where: { id: patch.metricId } })
+      : metricValue.metric
+
+    const entity: any = {
+      ...metricValue,
+      ...patch,
+      metric,
+      updater: user
+    }
+
+    return await repository.save(entity)
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [KpiMetricValue], { description: "To modify multiple KpiMetricValues' information" })
+  async updateMultipleKpiMetricValue(
+    @Arg('patches', type => [KpiMetricValuePatch]) patches: KpiMetricValuePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<KpiMetricValue[]> {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag && patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag && patch.cuFlag.toUpperCase() === 'M')
+    const metricValueRepo = getRepository(KpiMetricValue, tx)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+        const result = await metricValueRepo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        } as any)
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const updateRecord = _updateRecords[i]
+        const metricValue = await metricValueRepo.findOneBy({ id: updateRecord.id })
+        const result = await metricValueRepo.save({
+          ...metricValue,
+          ...updateRecord,
+          updater: user
+        } as any)
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete KpiMetricValue' })
+  async deleteKpiMetricValue(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+    await getRepository(KpiMetricValue, tx).delete({ domain: { id: domain.id }, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple KpiMetricValues' })
+  async deleteKpiMetricValues(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+    await getRepository(KpiMetricValue, tx).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To import multiple KpiMetricValues' })
+  async importKpiMetricValues(
+    @Arg('metricValues', type => [KpiMetricValuePatch]) metricValues: KpiMetricValuePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+    await Promise.all(
+      metricValues.map(async (metricValue: KpiMetricValuePatch) => {
+        await getRepository(KpiMetricValue, tx).save({ domain, ...metricValue } as any)
+      })
+    )
+    return true
+  }
+}

package/server/service/kpi-metric-value/kpi-metric-value-query.ts

@@ -0,0 +1,60 @@
+import { Resolver, Query, Args, Arg, Ctx, FieldResolver, Root } from 'type-graphql'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { KpiMetricValue } from './kpi-metric-value'
+import { KpiMetricValueList } from './kpi-metric-value-type'
+import { KpiMetric } from '../kpi-metric/kpi-metric'
+
+@Resolver(KpiMetricValue)
+export class KpiMetricValueQuery {
+  @Query(returns => KpiMetricValueList, { description: 'To fetch multiple KpiMetricValues' })
+  async kpiMetricValues(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<KpiMetricValueList> {
+    const { domain } = context.state
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(KpiMetricValue),
+      searchables: ['metricId', 'group', 'valueDate']
+    })
+    const [items, total] = await queryBuilder.getManyAndCount()
+    return { items, total }
+  }
+
+  @Query(returns => KpiMetricValue, {
+    nullable: true,
+    description: 'Fetch a single metric value by its unique identifier.'
+  })
+  async kpiMetricValue(
+    @Arg('id', { description: 'Unique identifier of the metric value to fetch.' }) id: string,
+    @Ctx() context: ResolverContext
+  ): Promise<KpiMetricValue | null> {
+    const { domain } = context.state
+    return await getRepository(KpiMetricValue).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() metricValue: KpiMetricValue): Promise<Domain> {
+    return metricValue.domainId && (await getRepository(Domain).findOneBy({ id: metricValue.domainId }))
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() metricValue: KpiMetricValue): Promise<User> {
+    return metricValue.updaterId && (await getRepository(User).findOneBy({ id: metricValue.updaterId }))
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() metricValue: KpiMetricValue): Promise<User> {
+    return metricValue.creatorId && (await getRepository(User).findOneBy({ id: metricValue.creatorId }))
+  }
+
+  @FieldResolver(type => KpiMetric)
+  async metric(@Root() metricValue: KpiMetricValue): Promise<KpiMetric | null> {
+    if (!metricValue.metricId) return null
+    return await getRepository(KpiMetric).findOneBy({ id: metricValue.metricId })
+  }
+}

package/server/service/kpi-metric-value/kpi-metric-value-type.ts

@@ -0,0 +1,82 @@
+import { ObjectType, Field, ID, Float, InputType, Int } from 'type-graphql'
+import { ScalarObject } from '@things-factory/shell'
+import { KpiMetricValue } from './kpi-metric-value'
+import { KpiPeriodType } from '../kpi/kpi'
+
+@InputType({
+  description: 'Input type for creating a new metric value. Used in mutations to provide metric value details.'
+})
+export class NewKpiMetricValue {
+  @Field(type => ID, { description: 'ID of the metric to which this value belongs.' })
+  metricId: string
+
+  @Field({ description: 'Date or period for which this metric value is recorded (e.g., day, month, quarter, range).' })
+  valueDate: string
+
+  @Field(type => KpiPeriodType, { description: 'Aggregation period type for this metric value.' })
+  periodType: KpiPeriodType
+
+  @Field(type => Float, { description: 'The value for this metric and period.' })
+  value: number
+
+  @Field({ nullable: true, description: 'Unit of measurement for this metric value.' })
+  unit?: string
+
+  @Field(type => ScalarObject, {
+    nullable: true,
+    description:
+      'Extended or non-numeric information related to this metric value, stored as JSON. Can include status, comments, or other metadata.'
+  })
+  meta?: any
+
+  @Field({ nullable: true, description: 'Group key for this value (organization, line, user, etc.)' })
+  group?: string
+}
+
+@InputType({
+  description: 'Input type for updating an existing metric value. Used in mutations to patch metric value details.'
+})
+export class KpiMetricValuePatch {
+  @Field(type => ID, { nullable: true, description: 'ID of the metric value to update.' })
+  id?: string
+
+  @Field(type => ID, { nullable: true, description: 'ID of the metric to which this value belongs.' })
+  metricId?: string
+
+  @Field({
+    nullable: true,
+    description: 'Date or period for which this metric value is recorded (e.g., day, month, quarter, range).'
+  })
+  valueDate?: string
+
+  @Field(type => KpiPeriodType, { nullable: true, description: 'Aggregation period type for this metric value.' })
+  periodType?: KpiPeriodType
+
+  @Field(type => Float, { nullable: true, description: 'The value for this metric and period.' })
+  value?: number
+
+  @Field({ nullable: true, description: 'Unit of measurement for this metric value.' })
+  unit?: string
+
+  @Field(type => ScalarObject, {
+    nullable: true,
+    description:
+      'Extended or non-numeric information related to this metric value, stored as JSON. Can include status, comments, or other metadata.'
+  })
+  meta?: any
+
+  @Field({ nullable: true, description: 'Group key for this value (organization, line, user, etc.)' })
+  group?: string
+
+  @Field({ nullable: true, description: 'Custom flag for update operations (internal use).' })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class KpiMetricValueList {
+  @Field(type => [KpiMetricValue])
+  items: KpiMetricValue[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/kpi-metric-value/kpi-metric-value.ts

@@ -0,0 +1,91 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  ManyToOne,
+  JoinColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  RelationId
+} from 'typeorm'
+import { ObjectType, Field, ID, Float } from 'type-graphql'
+import { Domain, ScalarObject } from '@things-factory/shell'
+import { KpiMetric } from '../kpi-metric/kpi-metric'
+import { KpiPeriodType } from '../kpi/kpi'
+import { User } from '@things-factory/auth-base'
+
+@Entity()
+@ObjectType({ description: 'Current value for each KPI metric (can be used for both state and history).' })
+export class KpiMetricValue {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  id: string
+
+  @ManyToOne(() => Domain)
+  @Field(type => Domain, { nullable: true })
+  domain?: Domain
+
+  @RelationId((entity: KpiMetricValue) => entity.domain)
+  @Field({ nullable: true })
+  domainId?: string
+
+  @ManyToOne(() => KpiMetric, { nullable: false, onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'metricId' })
+  @Field(type => KpiMetric)
+  metric: KpiMetric
+
+  @RelationId((entity: KpiMetricValue) => entity.metric)
+  @Field()
+  metricId: string
+
+  @Column('float')
+  @Field(type => Float)
+  value: number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  unit?: string
+
+  @Column({ type: 'varchar', length: 20 })
+  @Field({
+    description:
+      'Date or period for which this metric value is recorded (e.g., day: YYYY-MM-DD, month: YYYY-MM, range: YYYY-MM-DD~YYYY-MM-DD).'
+  })
+  valueDate: string
+
+  @Column({ default: 'DAY' })
+  @Field(type => KpiPeriodType)
+  periodType: KpiPeriodType
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'Group key for this value (organization, line, user, etc.)' })
+  group?: string
+
+  @Column({ type: 'simple-json', nullable: true })
+  @Field(type => ScalarObject, { nullable: true })
+  meta?: any
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(() => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((entity: KpiMetricValue) => entity.creator)
+  @Field({ nullable: true })
+  creatorId?: string
+
+  @ManyToOne(() => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((entity: KpiMetricValue) => entity.updater)
+  @Field({ nullable: true })
+  updaterId?: string
+}

package/server/service/kpi-value/kpi-value-mutation.ts

@@ -35,8 +35,7 @@ export class KpiValueMutation {
       version: kpiValue.version,
       valueDate: kpiValue.valueDate,
       value: kpiValue.value,
-      groupId: kpiValue.groupId,
-      groupType: kpiValue.groupType,
+      group: kpiValue.group,
       source: kpiValue.source,
       domain: domain,
       creator: user,

package/server/service/kpi-value/kpi-value-query.ts

@@ -28,7 +28,7 @@ export class KpiValueQuery {
       domain,
       params,
       repository: await getRepository(KpiValue),
-      searchables: ['name', 'description']
+      searchables: ['kpi', 'group', 'valueDate']
     })
 
     const [items, total] = await queryBuilder.getManyAndCount()

package/server/service/kpi-value/kpi-value-type.ts

@@ -27,14 +27,8 @@ export class NewKpiValue {
   })
   meta?: any
 
-  @Field({
-    nullable: true,
-    description: 'ID of the group (organization, department, project, etc.) this value is associated with.'
-  })
-  groupId?: string
-
-  @Field({ nullable: true, description: 'Type of the group (e.g., USER, DEPT, PROJECT) for this value.' })
-  groupType?: string
+  @Field({ nullable: true, description: 'Group key for this value (organization, line, user, etc.)' })
+  group?: string
 
   @Field(type => KpiValueInputType, {
     nullable: true,
@@ -78,14 +72,8 @@ export class KpiValuePatch {
   })
   meta?: any
 
-  @Field({
-    nullable: true,
-    description: 'ID of the group (organization, department, project, etc.) this value is associated with.'
-  })
-  groupId?: string
-
-  @Field({ nullable: true, description: 'Type of the group (e.g., USER, DEPT, PROJECT) for this value.' })
-  groupType?: string
+  @Field({ nullable: true, description: 'Group key for this value (organization, line, user, etc.)' })
+  group?: string
 
   @Field(type => KpiValueInputType, {
     nullable: true,

package/server/service/kpi-value/kpi-value.ts

@@ -13,7 +13,7 @@ import { ObjectType, Field, Int, ID, registerEnumType, Float } from 'type-graphq
 import { User } from '@things-factory/auth-base'
 import { Domain, ScalarObject, json5Transformer } from '@things-factory/shell'
 import { config } from '@things-factory/env'
-import { Kpi } from '../kpi/kpi'
+import { Kpi, KpiPeriodType } from '../kpi/kpi'
 
 const ORMCONFIG = config.get('ormconfig', {})
 const DATABASE_TYPE = ORMCONFIG.type
@@ -29,8 +29,8 @@ registerEnumType(KpiValueInputType, {
 })
 
 @Entity()
-@Index('ix_kpi_value_latest', ['domain', 'kpi', 'valueDate', 'groupId', 'groupType', 'version'], { unique: true })
-@Index('ix_kpi_value_latest_for_query', ['domain', 'kpi', 'valueDate', 'groupId', 'groupType'], { unique: false })
+@Index('ix_kpi_value_latest', ['domain', 'kpi', 'valueDate', 'group', 'version'], { unique: true })
+@Index('ix_kpi_value_latest_for_query', ['domain', 'kpi', 'valueDate', 'group'], { unique: false })
 @ObjectType({ description: 'Entity for KpiValue' })
 export class KpiValue {
   @PrimaryGeneratedColumn('uuid')
@@ -60,8 +60,11 @@ export class KpiValue {
   @Field(type => Int, { description: 'Version of the KPI definition at the time this value was calculated.' })
   version: number
 
-  @Column({ type: 'date' })
-  @Field({ description: 'Date or period for which this KPI value is recorded (e.g., day, month, quarter).' })
+  @Column()
+  @Field({
+    description:
+      'Date or period for which this KPI value is recorded (e.g., day: YYYY-MM-DD, month: YYYY-MM, quarter: YYYY-Qn, range: YYYY-MM-DD~YYYY-MM-DD).'
+  })
   valueDate: string
 
   @Column('float')
@@ -69,15 +72,8 @@ export class KpiValue {
   value: number
 
   @Column({ nullable: true })
-  @Field({
-    nullable: true,
-    description: 'ID of the group (organization, department, project, etc.) this value is associated with.'
-  })
-  groupId?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Type of the group (e.g., USER, DEPT, PROJECT) for this value.' })
-  groupType?: string
+  @Field({ nullable: true, description: 'Group key for this value (organization, line, user, etc.)' })
+  group?: string
 
   @Column({ nullable: true })
   @Field({
@@ -110,6 +106,10 @@ export class KpiValue {
   })
   meta?: any
 
+  @Column({ default: 'DAY' })
+  @Field(type => KpiPeriodType, { description: 'Aggregation period type for this KPI value.' })
+  periodType: KpiPeriodType
+
   @CreateDateColumn()
   @Field({ nullable: true, description: 'Timestamp when this KPI value record was created.' })
   createdAt?: Date

package/things-factory.config.js

@@ -1,5 +1,5 @@
 import route from './dist-client/route'
-// import bootstrap from './dist-client/bootstrap'
+import bootstrap from './dist-client/bootstrap'
 
 export default {
   route,
@@ -10,8 +10,10 @@ export default {
     { tagname: 'kpi-category-list-page', page: 'kpi-category-list' },
     { tagname: 'kpi-metric-list-page', page: 'kpi-metric-list' },
     { tagname: 'kpi-value-list-page', page: 'kpi-value-list' },
+    { tagname: 'kpi-metric-value-list-page', page: 'kpi-metric-value-list' },
     { tagname: 'kpi-value-manual-entry-page', page: 'kpi-value-manual-entry' },
+    { tagname: 'kpi-metric-value-manual-entry-page', page: 'kpi-metric-value-manual-entry' },
     { tagname: 'kpi-history-list-page', page: 'kpi-history-list' }
-  ]
-  // bootstrap
+  ],
+  bootstrap
 }

package/translations/en.json

@@ -1,12 +1,19 @@
 {
+  "label.formula": "formula",
+  "label.available-variables": "available variables",
+  "label.operators": "operators",
+  "label.functions": "functions",
   "title.kpi list": "KPI List",
   "title.kpi category list": "KPI Catogory List",
   "title.kpi grade list": "KPI Grade List",
   "title.kpi metric list": "KPI Metric List",
   "title.kpi value list": "KPI Value List",
+  "title.kpi metric value list": "KPI Metric Value List",
   "title.kpi performance board": "KPI Performance Board",
   "title.kpi management center": "KPI Management Center",
   "title.kpi overview": "KPI Overview",
   "title.kpi value manual entry": "KPI Value Manual Entry",
-  "button.enter-kpi-value": "Enter KPI Value"
+  "title.kpi metric value manual entry": "KPI Metric Value Manual Entry",
+  "button.enter-kpi-value": "Enter KPI Value",
+  "button.enter-kpi-metric-value": "Enter KPI Metric Value"
 }

package/translations/ja.json

@@ -1,12 +1,19 @@
 {
+  "label.formula": "산식",
+  "label.available-variables": "사용 가능한 변수",
+  "label.operators": "연산자",
+  "label.functions": "함수",
   "title.kpi list": "KPI リスト",
   "title.kpi category list": "KPI カテゴリ リスト",
   "title.kpi grade list": "KPI グレード リスト",
   "title.kpi metric list": "KPI メトリック リスト",
   "title.kpi value list": "KPI 値 リスト",
+  "title.kpi metric value list": "KPI メトリック 値 リスト",
   "title.kpi performance board": "KPI パフォーマンス ボード",
   "title.kpi management center": "KPI 管理 センター",
   "title.kpi overview": "KPI 概要",
   "title.kpi value manual entry": "KPI 値 手入力",
-  "button.enter-kpi-value": "KPI 値 入力"
+  "title.kpi metric value manual entry": "KPI メトリック 値 手入力",
+  "button.enter-kpi-value": "KPI 値 入力",
+  "button.enter-kpi-metric-value": "KPI メトリック 値 入力"
 }

package/translations/ko.json

@@ -1,12 +1,19 @@
 {
+  "label.formula": "산식",
+  "label.available-variables": "사용 가능한 변수",
+  "label.operators": "연산자",
+  "label.functions": "함수",
   "title.kpi list": "KPI 목록",
   "title.kpi category list": "KPI 카테고리 목록",
   "title.kpi grade list": "KPI 등급 목록",
-  "title.kpi metric list": "KPI 지표 목록",
+  "title.kpi metric list": "KPI 메트릭 목록",
   "title.kpi value list": "KPI 값 목록",
+  "title.kpi metric value list": "KPI 메트릭 값 목록",
   "title.kpi performance board": "KPI 성과 보드",
   "title.kpi management center": "KPI 관리 센터",
   "title.kpi overview": "KPI 개요",
   "title.kpi value manual entry": "KPI 값 수기 입력",
-  "button.enter-kpi-value": "KPI 값 입력"
+  "title.kpi metric value manual entry": "KPI 메트릭 값 수기 입력",
+  "button.enter-kpi-value": "KPI 값 입력",
+  "button.enter-kpi-metric-value": "KPI 메트릭 값 입력"
 }

package/translations/ms.json

@@ -1,12 +1,19 @@
 {
+  "label.formula": "formula",
+  "label.available-variables": "available variables",
+  "label.operators": "operators",
+  "label.functions": "functions",
   "title.kpi list": "Senarai KPI",
   "title.kpi category list": "Senarai Kategori KPI",
   "title.kpi grade list": "Senarai Gred KPI",
   "title.kpi metric list": "Senarai Metrik KPI",
   "title.kpi value list": "Senarai Nilai KPI",
+  "title.kpi metric value list": "Senarai Metrik KPI",
   "title.kpi performance board": "Papan KPI",
   "title.kpi management center": "Pusat Pengurusan KPI",
   "title.kpi overview": "Pengenalan KPI",
-  "title.kpi value manual entry": "KPI 値 手入力",
-  "button.enter-kpi-value": "KPI 値 入力"
+  "title.kpi value manual entry": "KPI Nilai Manual",
+  "title.kpi metric value manual entry": "KPI Metrik Manual",
+  "button.enter-kpi-value": "KPI Nilai Manual",
+  "button.enter-kpi-metric-value": "KPI Metrik Manual"
 }