@things-factory/kpi 9.2.5 → 10.0.0-beta.10

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

@@ -1,432 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In, Between } from 'typeorm'
-import { getRepository } from '@things-factory/shell'
-
-import { KpiValue } from './kpi-value'
-import { NewKpiValue, KpiValuePatch } from './kpi-value-type'
-import { Kpi } from '../kpi/kpi'
-import { KpiMetric } from '../kpi-metric/kpi-metric'
-import { KpiOrgScope } from '../kpi-org-scope/kpi-org-scope'
-import { KpiMetricValue } from '../kpi-metric-value/kpi-metric-value'
-import { KpiPeriodType } from '../kpi/kpi'
-import { getDefaultValueDate } from '../utils/value-date-util'
-import { KpiValueInputType } from './kpi-value'
-import { KpiValueScoreService } from './kpi-value-score.service'
-import { parseFormula } from '../../calculator/parser'
-import { evaluateFormula } from '../../calculator/evaluator'
-import { builtinFunctions } from '../../calculator/functions'
-import { KpiMetricValueProvider } from '../../controllers/kpi-metric-value-provider'
-
-@Resolver(KpiValue)
-export class KpiValueMutation {
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Directive('@transaction')
-  @Mutation(returns => KpiValue, { description: 'Create a new KPI value with the provided details.' })
-  async createKpiValue(
-    @Arg('kpiValue', { description: 'Input object containing details for the new KPI value.' }) kpiValue: NewKpiValue,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiValue> {
-    const { domain, user, tx } = context.state
-
-    let kpi = kpiValue.kpiId ? await getRepository(Kpi).findOne({ where: { id: kpiValue.kpiId } }) : undefined
-
-    let inputType: KpiValueInputType | undefined = undefined
-    if (kpiValue.inputType) {
-      if (typeof kpiValue.inputType === 'string') {
-        inputType = KpiValueInputType[kpiValue.inputType as keyof typeof KpiValueInputType]
-      } else {
-        inputType = kpiValue.inputType
-      }
-    }
-
-    // KpiOrgScope 처리
-    let kpiOrgScope: KpiOrgScope | undefined
-    if (kpiValue.kpiOrgScopeId) {
-      kpiOrgScope = await getRepository(KpiOrgScope, context.state?.tx).findOne({
-        where: { id: kpiValue.kpiOrgScopeId, domain: { id: domain.id } }
-      })
-      if (!kpiOrgScope) {
-        throw new Error(`KpiOrgScope not found: ${kpiValue.kpiOrgScopeId}`)
-      }
-    } else if (kpiValue.org) {
-      // Legacy org 처리 - org 문자열로 KpiOrgScope 찾기 또는 생성
-      kpiOrgScope = await getRepository(KpiOrgScope, context.state?.tx).findOne({
-        where: { org: kpiValue.org, domain: { id: domain.id } }
-      })
-      if (!kpiOrgScope) {
-        // 새 KpiOrgScope 생성
-        kpiOrgScope = await getRepository(KpiOrgScope, context.state?.tx).save({
-          entityType: 'Manual',
-          entityId: `manual-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-          entityName: kpiValue.org,
-          org: kpiValue.org,
-          domain,
-          creator: user,
-          updater: user
-        })
-      }
-    }
-
-    const entity: Partial<KpiValue> = {
-      kpi,
-      kpiId: kpiValue.kpiId,
-      version: kpiValue.version,
-      valueDate: kpiValue.valueDate,
-      value: kpiValue.value,
-      source: kpiValue.source,
-      domain: domain,
-      creator: user,
-      updater: user
-    }
-    
-    if (kpiOrgScope) {
-      entity.kpiOrgScope = kpiOrgScope
-      entity.kpiOrgScopeId = kpiOrgScope.id
-    }
-    if (inputType) entity.inputType = inputType
-
-    return await getRepository(KpiValue, tx).save(entity)
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => [KpiValue], { description: 'Create multiple KPI values with the provided details.' })
-  async createMultipleKpiValue(
-    @Arg('values', type => [NewKpiValue], {
-      description: 'Array of input objects containing details for the new KPI values.'
-    })
-    values: NewKpiValue[],
-    @Ctx() context: ResolverContext
-  ): Promise<KpiValue[]> {
-    const { domain, user, tx } = context.state
-    const repository = getRepository(KpiValue, tx)
-    const scoreService = new KpiValueScoreService()
-
-    const entities: KpiValue[] = []
-
-    for (const kpiValue of values) {
-      let kpi = kpiValue.kpiId ? await getRepository(Kpi).findOne({ where: { id: kpiValue.kpiId } }) : undefined
-
-      let inputType: KpiValueInputType | undefined = undefined
-      if (kpiValue.inputType) {
-        if (typeof kpiValue.inputType === 'string') {
-          inputType = KpiValueInputType[kpiValue.inputType as keyof typeof KpiValueInputType]
-        } else {
-          inputType = kpiValue.inputType
-        }
-      }
-
-      // KpiOrgScope 처리
-      let kpiOrgScope: KpiOrgScope | undefined
-      if (kpiValue.kpiOrgScopeId) {
-        kpiOrgScope = await getRepository(KpiOrgScope, context.state?.tx).findOne({
-          where: { id: kpiValue.kpiOrgScopeId, domain: { id: domain.id } }
-        })
-        if (!kpiOrgScope) {
-          throw new Error(`KpiOrgScope not found: ${kpiValue.kpiOrgScopeId}`)
-        }
-      } else if (kpiValue.org) {
-        // Legacy org 처리
-        kpiOrgScope = await getRepository(KpiOrgScope, context.state?.tx).findOne({
-          where: { org: kpiValue.org, domain: { id: domain.id } }
-        })
-        if (!kpiOrgScope) {
-          // 새 KpiOrgScope 생성
-          kpiOrgScope = await getRepository(KpiOrgScope, context.state?.tx).save({
-            entityType: 'Manual',
-            entityId: `manual-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-            entityName: kpiValue.org,
-            org: kpiValue.org,
-            domain,
-            creator: user,
-            updater: user
-          })
-        }
-      }
-
-      const entity: Partial<KpiValue> = {
-        kpi,
-        kpiId: kpiValue.kpiId,
-        version: kpiValue.version || 1,
-        valueDate: kpiValue.valueDate,
-        value: kpiValue.value,
-        source: kpiValue.source || 'MANUAL',
-        domain: domain,
-        creator: user,
-        updater: user
-      }
-
-      if (kpiOrgScope) {
-        entity.kpiOrgScope = kpiOrgScope
-        entity.kpiOrgScopeId = kpiOrgScope.id
-      }
-      if (inputType) entity.inputType = inputType
-
-      const savedEntity = await repository.save(entity)
-
-      // 성과 점수 자동 계산 및 저장
-      if (kpi) {
-        await scoreService.calculateAndSaveScore(savedEntity, kpi)
-      }
-
-      entities.push(savedEntity)
-    }
-
-    return entities
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => KpiValue, { description: 'To modify KpiValue information' })
-  async updateKpiValue(
-    @Arg('id') id: string,
-    @Arg('patch') patch: KpiValuePatch,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiValue> {
-    const { domain, user, tx } = context.state
-
-    const repository = getRepository(KpiValue, tx)
-    const kpiValue = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    let kpi = patch.kpiId ? await getRepository(Kpi).findOne({ where: { id: patch.kpiId } }) : kpiValue.kpi
-
-    let inputType: KpiValueInputType | undefined = undefined
-    if (patch.inputType) {
-      if (typeof patch.inputType === 'string') {
-        inputType = KpiValueInputType[patch.inputType as keyof typeof KpiValueInputType]
-      } else {
-        inputType = patch.inputType
-      }
-    } else {
-      inputType = kpiValue.inputType
-    }
-
-    const entity: any = {
-      ...kpiValue,
-      ...patch,
-      kpi,
-      updater: user
-    }
-    if (inputType) entity.inputType = inputType
-
-    return await repository.save(entity)
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => [KpiValue], { description: "To modify multiple KpiValues' information" })
-  async updateMultipleKpiValue(
-    @Arg('patches', type => [KpiValuePatch]) patches: KpiValuePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<KpiValue[]> {
-    const { domain, user, tx } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const kpiValueRepo = getRepository(KpiValue, tx)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const kpi = await getRepository(Kpi, tx).findOne({
-          where: { domain: { id: domain.id }, id: newRecord.kpiId }
-        })
-
-        const result = await kpiValueRepo.save({
-          ...newRecord,
-          kpi,
-          version: newRecord.version || kpi.version,
-          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 kpiValue = await kpiValueRepo.findOneBy({ id: updateRecord.id })
-
-        const kpi = await getRepository(Kpi, tx).findOne({
-          where: { domain: { id: domain.id }, id: updateRecord.kpiId }
-        })
-
-        const result = await kpiValueRepo.save({
-          ...kpiValue,
-          ...updateRecord,
-          kpi,
-          version: updateRecord.version || kpi.version,
-          updater: user
-        } as any)
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To delete KpiValue' })
-  async deleteKpiValue(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await getRepository(KpiValue, tx).delete({ domain: { id: domain.id }, id })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To delete multiple KpiValues' })
-  async deleteKpiValues(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await getRepository(KpiValue, tx).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To import multiple KpiValues' })
-  async importKpiValues(
-    @Arg('kpiValues', type => [KpiValuePatch]) kpiValues: KpiValuePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await Promise.all(
-      kpiValues.map(async (kpiValue: KpiValuePatch) => {
-        const createdKpiValue: KpiValue = await getRepository(KpiValue, tx).save({ domain, ...kpiValue } as any)
-      })
-    )
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => Boolean, { description: 'Recalculate scores for all KpiValues of a specific KPI' })
-  async recalculateScoresForKpi(@Arg('kpiId') kpiId: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const scoreService = new KpiValueScoreService()
-    await scoreService.recalculateScoresForKpi(kpiId, context)
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => KpiValue, { description: '기존 KPI Value 인스턴스를 현재 formula/metric 값으로 재계산' })
-  async recalculateKpiValue(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<KpiValue> {
-    const { domain, user, tx } = context.state
-    const kpiValueRepo = getRepository(KpiValue, tx)
-    const kpiRepo = getRepository(Kpi, tx)
-    const metricRepo = getRepository(KpiMetric, tx)
-    const metricValueRepo = getRepository(KpiMetricValue, tx)
-
-    // 1. 기존 KPI Value 인스턴스 조회
-    const kpiValue = await kpiValueRepo.findOne({
-      where: { id, domain: { id: domain.id } },
-      relations: ['kpi', 'kpiOrgScope']
-    })
-    if (!kpiValue) throw new Error('KPI Value not found')
-    // 항상 최신 버전의 KPI를 조회하여 사용
-    const kpi = await kpiRepo.findOne({
-      where: { id: kpiValue.kpiId, domain: { id: domain.id } },
-      order: { version: 'DESC' }
-    })
-    if (!kpi) throw new Error('KPI 정보 없음')
-    if (!kpi.formula) throw new Error('KPI formula 없음')
-    const periodType = kpi.periodType || KpiPeriodType.DAY
-    const valueDate = kpiValue.valueDate
-    const kpiOrgScope = kpiValue.kpiOrgScope
-    const org = kpiOrgScope?.entityName || kpiOrgScope?.org || 'unknown' // KpiOrgScope에서 org 정보 추출
-
-    // 2. formula에서 metric code 추출
-    const metricCodes = (kpi.formula.match(/[a-zA-Z_][a-zA-Z0-9_]*/g) || []).filter(
-      code => code !== 'null' && code !== 'undefined'
-    )
-    const metricMap: Record<string, KpiMetric> = {}
-    for (const code of metricCodes) {
-      const metric = await metricRepo.findOne({ where: { name: code, domain: { id: domain.id } } })
-      if (!metric) throw new Error(`KPI formula metric '${code}' not found`)
-      metricMap[code] = metric
-    }
-
-    // 3. metric 값 집계 (periodType 변환/집계)
-    const metricValues: Record<string, number> = {}
-    for (const code of metricCodes) {
-      const metric = metricMap[code]
-      let value = null
-      if (metric.periodType === periodType) {
-        const mv = await metricValueRepo.findOne({
-          where: {
-            metric: { id: metric.id },
-            valueDate,
-            periodType,
-            org: org ?? '',
-            domain: { id: domain.id }
-          }
-        })
-        value = mv?.value ?? null
-      } else {
-        let startDate: string, endDate: string
-        if (periodType === KpiPeriodType.MONTH && metric.periodType === KpiPeriodType.DAY) {
-          startDate = valueDate + '-01'
-          endDate = valueDate + '-31'
-          const mvs = await metricValueRepo.find({
-            where: {
-              metric: { id: metric.id },
-              valueDate: Between(startDate, endDate),
-              periodType: metric.periodType,
-              org: org ?? '',
-              domain: { id: domain.id }
-            }
-          })
-          value = mvs.reduce((sum, mv) => sum + (mv.value ?? 0), 0)
-        } else {
-          throw new Error('KPI/Metric periodType 조합 집계 미지원')
-        }
-      }
-      if (value == null) throw new Error(`Metric '${code}' 값 없음`)
-      metricValues[code] = value
-    }
-
-    // 4. formula 계산 (calculator 기반)
-    const ast = parseFormula(kpi.formula)
-    const provider = new KpiMetricValueProvider({
-      valueDate,
-      org,
-      domainId: domain.id,
-      tx
-    })
-    const evalContext = { functions: builtinFunctions, provider }
-    const kpiValueResult = await evaluateFormula(ast, evalContext)
-    if (kpiValueResult == null || isNaN(kpiValueResult)) throw new Error('KPI formula 결과값 없음')
-
-    // 5. KPI Value 업데이트 (최신 버전으로)
-    kpiValue.value = kpiValueResult
-    kpiValue.version = kpi.version || 1
-    kpiValue.updater = user
-
-    // 6. 성과 점수 자동 계산 및 저장
-    const scoreService = new KpiValueScoreService()
-    await scoreService.calculateAndSaveScore(kpiValue, kpi)
-
-    return await kpiValueRepo.save(kpiValue)
-  }
-}

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

@@ -1,61 +0,0 @@
-import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive, Float } from 'type-graphql'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { KpiValue } from './kpi-value'
-import { KpiValueList } from './kpi-value-type'
-import { Kpi } from '../kpi/kpi'
-import { KpiValueScoreService } from './kpi-value-score.service'
-
-@Resolver(KpiValue)
-export class KpiValueQuery {
-  @Directive('@privilege(category: "kpi", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
-  @Query(returns => KpiValue!, { nullable: true, description: 'Fetch a single KPI value by its unique identifier.' })
-  async kpiValue(
-    @Arg('id', { description: 'Unique identifier of the KPI value to fetch.' }) id: string,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiValue> {
-    const { domain } = context.state
-
-    return await getRepository(KpiValue).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Directive('@privilege(category: "kpi", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
-  @Query(returns => KpiValueList, { description: 'To fetch multiple KpiValues' })
-  async kpiValues(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<KpiValueList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(KpiValue),
-      searchables: ['kpi', 'group', 'valueDate']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() kpiValue: KpiValue): Promise<Domain> {
-    return kpiValue.domainId && (await getRepository(Domain).findOneBy({ id: kpiValue.domainId }))
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() kpiValue: KpiValue): Promise<User> {
-    return kpiValue.updaterId && (await getRepository(User).findOneBy({ id: kpiValue.updaterId }))
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() kpiValue: KpiValue): Promise<User> {
-    return kpiValue.creatorId && (await getRepository(User).findOneBy({ id: kpiValue.creatorId }))
-  }
-
-  @FieldResolver(type => Kpi)
-  async kpi(@Root() kpiValue: KpiValue): Promise<Kpi | null> {
-    if (!kpiValue.kpiId) return null
-    return await getRepository(Kpi).findOneBy({ id: kpiValue.kpiId })
-  }
-}

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

@@ -1,106 +0,0 @@
-import { getRepository } from '@things-factory/shell'
-import { Kpi } from '../kpi/kpi'
-import { KpiValue } from './kpi-value'
-import { parseFormula } from '../../calculator/parser'
-import { evaluateFormula } from '../../calculator/evaluator'
-import { builtinFunctions } from '../../calculator/functions'
-
-export interface ScoreResult {
-  score: number
-  calculationMethod?: 'formula' | 'lookup'
-}
-
-export class KpiValueScoreService {
-  /**
-   * scoreFormula를 사용한 성과 점수 계산
-   */
-  async calculateScoreFromFormula(kpi: Kpi, value: number): Promise<ScoreResult | null> {
-    if (!kpi.scoreFormula) {
-      return null
-    }
-
-    try {
-      const ast = parseFormula(kpi.scoreFormula)
-      const provider = {
-        get: async (name: string) => {
-          if (name === 'value') return value
-          return null
-        }
-      }
-      const evalContext = { functions: builtinFunctions, provider }
-      const result = await evaluateFormula(ast, evalContext)
-
-      if (result !== null && result !== undefined && !isNaN(result)) {
-        const performanceScore = Number(result)
-
-        return {
-          score: performanceScore,
-          calculationMethod: 'formula'
-        }
-      }
-    } catch (error) {
-      console.error(`Score formula evaluation for '${kpi.name}: ${kpi.scoreFormula}' error:`, error)
-    }
-
-    return null
-  }
-
-  /**
-   * KPI의 grades lookup table을 이용한 성과 점수 변환
-   * 복잡한 성과 점수 변환을 수식으로 표현하기 어려운 경우 사용
-   * @deprecated 향후 grades 필드 제거 예정. scoreFormula로 대체 권장
-   */
-  calculateScoreFromLookup(kpi: Kpi, value: number): ScoreResult | null {
-    if (!kpi.grades || kpi.grades.length === 0) {
-      return null
-    }
-
-    // grades lookup table에서 해당 값의 범위에 맞는 성과 점수 찾기
-    const grade = kpi.grades.find(g => value >= g.minValue && value <= g.maxValue)
-
-    if (!grade) {
-      return null
-    }
-
-    return {
-      score: grade.score,
-      calculationMethod: 'lookup'
-    }
-  }
-
-  /**
-   * KpiValue 생성/수정 시 성과 점수 자동 계산 및 저장
-   */
-  async calculateAndSaveScore(kpiValue: KpiValue, kpi: Kpi): Promise<void> {
-    // 1. scoreFormula 우선 시도
-    let scoreResult = await this.calculateScoreFromFormula(kpi, kpiValue.value)
-
-    // 2. scoreFormula가 없거나 실패하면 grades lookup table 사용 (deprecated)
-    if (!scoreResult) {
-      scoreResult = this.calculateScoreFromLookup(kpi, kpiValue.value)
-    }
-
-    if (scoreResult) {
-      // KpiValue의 score 필드에 성과 점수 저장
-      kpiValue.score = scoreResult.score
-    }
-  }
-
-  /**
-   * 기존 KpiValue들의 성과 점수 재계산 (배치 처리)
-   */
-  async recalculateScoresForKpi(kpiId: string, context: ResolverContext): Promise<void> {
-    const kpi = await getRepository(Kpi).findOne({ where: { id: kpiId } })
-    if (!kpi) return
-
-    const kpiValues = await getRepository(KpiValue).find({
-      where: { kpiId, version: kpi.version }
-    })
-
-    for (const kpiValue of kpiValues) {
-      await this.calculateAndSaveScore(kpiValue, kpi)
-    }
-
-    await getRepository(KpiValue).save(kpiValues)
-  }
-}