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

package/server/service/kpi-statistic/kpi-statistic-calculation.service.ts

@@ -1,410 +0,0 @@
-import { getRepository } from '@things-factory/shell'
-import type ResolverContext from '@things-factory/auth-base'
-import { KpiStatistic } from './kpi-statistic'
-import { KpiValue } from '../kpi-value/kpi-value'
-import { Kpi, KpiPeriodType } from '../kpi/kpi'
-import { KpiOrgScope } from '../kpi-org-scope/kpi-org-scope'
-import { KpiScope } from '../kpi-scope/kpi-scope'
-
-/**
- * KPI 통계 계산 서비스
- * KpiValue 데이터로부터 통계값을 계산하여 KpiStatistic에 저장
- */
-export class KpiStatisticCalculationService {
-  /**
-   * 전체 KPI에 대해 통계를 계산
-   */
-  static async calculateAllStatistics(
-    periodType: KpiPeriodType,
-    valueDate: string,
-    context: ResolverContext
-  ): Promise<KpiStatistic[]> {
-    const { domain } = context.state
-
-    // Leaf KPI들만 대상으로 함 (실제 값을 가진 KPI)
-    const leafKpis = await getRepository(Kpi).find({
-      where: { domain: { id: domain.id }, isLeaf: true }
-    })
-
-    const results: KpiStatistic[] = []
-
-    for (const kpi of leafKpis) {
-      // 1. 전체 통계 (scope 없음)
-      const overallStats = await this.calculateKpiStatistics(
-        kpi.id,
-        periodType,
-        valueDate,
-        null, // kpiOrgScope 없음 = 전체 통계
-        context
-      )
-      if (overallStats) results.push(overallStats)
-
-      // 2. 스코프별 통계
-      const scopedStats = await this.calculateScopedStatistics(kpi.id, periodType, valueDate, context)
-      results.push(...scopedStats)
-    }
-
-    return results
-  }
-
-  /**
-   * 특정 KPI의 통계를 계산
-   */
-  static async calculateKpiStatistics(
-    kpiId: string,
-    periodType: KpiPeriodType,
-    valueDate: string,
-    kpiOrgScope: KpiOrgScope | null,
-    context: ResolverContext
-  ): Promise<KpiStatistic | null> {
-    const { domain, user, tx } = context.state
-
-    // KPI 값들 조회
-    const whereCondition: any = {
-      kpi: { id: kpiId },
-      domain: { id: domain.id },
-      valueDate: this.buildDateFilter(valueDate, periodType)
-    }
-
-    if (kpiOrgScope) {
-      whereCondition.kpiOrgScope = { id: kpiOrgScope.id }
-    }
-
-    const kpiValues = await getRepository(KpiValue, tx).find({
-      where: whereCondition,
-      relations: ['kpi', 'kpiOrgScope']
-    })
-
-    if (kpiValues.length === 0) {
-      return null
-    }
-
-    // 통계 계산
-    const statistics = this.calculateStatistics(kpiValues.map(v => v.value).filter(v => v !== null))
-
-    // KpiStatistic 엔티티 생성/업데이트
-    const kpiStatisticRepo = getRepository(KpiStatistic, tx)
-
-    // 기존 통계 조회
-    const existingWhere: any = {
-      kpi: { id: kpiId },
-      domain: { id: domain.id },
-      periodType,
-      valueDate
-    }
-
-    if (kpiOrgScope) {
-      existingWhere.kpiOrgScope = { id: kpiOrgScope.id }
-    } else {
-      existingWhere.kpiOrgScope = null
-    }
-
-    let kpiStatistic = await kpiStatisticRepo.findOne({ where: existingWhere })
-
-    if (!kpiStatistic) {
-      kpiStatistic = kpiStatisticRepo.create()
-      kpiStatistic.kpi = kpiValues[0].kpi
-      kpiStatistic.kpiId = kpiId
-      kpiStatistic.domain = { id: domain.id } as any
-      kpiStatistic.periodType = periodType
-      kpiStatistic.valueDate = valueDate
-      kpiStatistic.creator = user
-      kpiStatistic.kpiOrgScope = kpiOrgScope
-      kpiStatistic.kpiOrgScopeId = kpiOrgScope?.id
-    }
-
-    // 통계값 적용
-    Object.assign(kpiStatistic, statistics)
-    kpiStatistic.updater = user
-    kpiStatistic.metadata = {
-      ...kpiStatistic.metadata,
-      calculationMethod: 'auto-calculated',
-      lastCalculated: new Date(),
-      dataCount: kpiValues.length,
-      calculatedFrom: 'kpi-values'
-    }
-
-    return await kpiStatisticRepo.save(kpiStatistic)
-  }
-
-  /**
-   * 스코프별 통계 계산 (KpiScope 기반)
-   */
-  static async calculateScopedStatistics(
-    kpiId: string,
-    periodType: KpiPeriodType,
-    valueDate: string,
-    context: ResolverContext
-  ): Promise<KpiStatistic[]> {
-    const { domain } = context.state
-
-    // 통계 계산에 사용할 스코프 정의 조회
-    const kpiScopes = await getRepository(KpiScope).find({
-      where: {
-        domain: { id: domain.id },
-        active: true,
-        includeInStatistics: true
-      },
-      order: { displayOrder: 'ASC' }
-    })
-
-    const results: KpiStatistic[] = []
-
-    for (const kpiScope of kpiScopes) {
-      const scopedStats = await this.calculateStatisticsByScope(kpiId, periodType, valueDate, kpiScope, context)
-      results.push(...scopedStats)
-    }
-
-    return results
-  }
-
-  /**
-   * 특정 스코프 차원별 통계 계산
-   */
-  static async calculateStatisticsByScope(
-    kpiId: string,
-    periodType: KpiPeriodType,
-    valueDate: string,
-    kpiScope: KpiScope,
-    context: ResolverContext
-  ): Promise<KpiStatistic[]> {
-    const { domain } = context.state
-    const scopeLevel = kpiScope.level
-    const fieldName = `scope${scopeLevel.toString().padStart(2, '0')}`
-
-    // 해당 스코프 레벨의 유니크한 값들 조회
-    const scopeValues = kpiScope.validValues || (await this.getDistinctScopeValues(fieldName, domain.id))
-
-    const results: KpiStatistic[] = []
-
-    for (const scopeValue of scopeValues) {
-      // 해당 스코프 값을 가진 KpiOrgScope들 조회
-      const kpiOrgScopes = await getRepository(KpiOrgScope).find({
-        where: {
-          domain: { id: domain.id },
-          [fieldName]: scopeValue
-        }
-      })
-
-      // 각 KpiOrgScope에 대해 통계 계산
-      for (const orgScope of kpiOrgScopes) {
-        const statistic = await this.calculateKpiStatistics(kpiId, periodType, valueDate, orgScope, context)
-        if (statistic) {
-          results.push(statistic)
-        }
-      }
-
-      // 스코프 값별 집계 통계도 생성 (선택적)
-      if (kpiOrgScopes.length > 1) {
-        const aggregatedStats = await this.calculateAggregatedScopeStatistics(
-          kpiId,
-          periodType,
-          valueDate,
-          kpiScope,
-          scopeValue,
-          kpiOrgScopes,
-          context
-        )
-        if (aggregatedStats) {
-          results.push(aggregatedStats)
-        }
-      }
-    }
-
-    return results
-  }
-
-  /**
-   * 스코프 값별 집계 통계 계산 (예: 서울 전체 평균)
-   */
-  private static async calculateAggregatedScopeStatistics(
-    kpiId: string,
-    periodType: KpiPeriodType,
-    valueDate: string,
-    kpiScope: KpiScope,
-    scopeValue: string,
-    kpiOrgScopes: KpiOrgScope[],
-    context: ResolverContext
-  ): Promise<KpiStatistic | null> {
-    const { domain, user, tx } = context.state
-
-    // 모든 KpiOrgScope에서 KpiValue들 수집
-    const allValues: number[] = []
-    for (const orgScope of kpiOrgScopes) {
-      const kpiValues = await getRepository(KpiValue, tx).find({
-        where: {
-          kpi: { id: kpiId },
-          domain: { id: domain.id },
-          kpiOrgScope: { id: orgScope.id },
-          valueDate: this.buildDateFilter(valueDate, periodType)
-        }
-      })
-      allValues.push(...kpiValues.map(v => v.value).filter(v => v !== null))
-    }
-
-    if (allValues.length === 0) return null
-
-    // 집계 통계 계산
-    const statistics = this.calculateStatistics(allValues)
-
-    // 가상의 KpiOrgScope 생성 (집계용)
-    const aggregatedOrgScope = {
-      id: `aggregated-${kpiScope.level}-${scopeValue}`,
-      entityType: 'AGGREGATED',
-      entityName: `${kpiScope.name}: ${scopeValue}`,
-      org: scopeValue,
-      [`scope${kpiScope.level.toString().padStart(2, '0')}`]: scopeValue
-    }
-
-    // KpiStatistic 생성
-    const kpiStatisticRepo = getRepository(KpiStatistic, tx)
-    const kpiStatistic = kpiStatisticRepo.create()
-
-    const kpi = await getRepository(Kpi).findOneBy({ id: kpiId })
-    kpiStatistic.kpi = kpi
-    kpiStatistic.kpiId = kpiId
-    kpiStatistic.domain = { id: domain.id } as any
-    kpiStatistic.periodType = periodType
-    kpiStatistic.valueDate = valueDate
-    kpiStatistic.creator = user
-    kpiStatistic.updater = user
-
-    // 통계값 적용
-    Object.assign(kpiStatistic, statistics)
-    kpiStatistic.metadata = {
-      ...kpiStatistic.metadata,
-      calculationMethod: 'scope-aggregated',
-      lastCalculated: new Date(),
-      dataCount: allValues.length,
-      kpiScope: {
-        id: kpiScope.id,
-        name: kpiScope.name,
-        level: kpiScope.level,
-        scopeType: kpiScope.scopeType
-      },
-      aggregatedScopeValue: scopeValue,
-      orgScopeCount: kpiOrgScopes.length
-    }
-
-    return await kpiStatisticRepo.save(kpiStatistic)
-  }
-
-  /**
-   * 특정 스코프 필드의 유니크한 값들 조회
-   */
-  private static async getDistinctScopeValues(fieldName: string, domainId: string): Promise<string[]> {
-    const query = `
-      SELECT DISTINCT ${fieldName} as value 
-      FROM kpi_org_scope 
-      WHERE domainId = ? AND ${fieldName} IS NOT NULL 
-      ORDER BY ${fieldName}
-    `
-
-    const results = await getRepository(KpiOrgScope).query(query, [domainId])
-    return results.map((r: any) => r.value).filter(Boolean)
-  }
-
-  /**
-   * 통계값 계산 로직
-   */
-  private static calculateStatistics(values: number[]) {
-    if (values.length === 0) return {}
-
-    const sortedValues = [...values].sort((a, b) => a - b)
-    const count = values.length
-    const sum = values.reduce((acc, val) => acc + val, 0)
-    const mean = sum / count
-
-    // 중앙값
-    const median =
-      count % 2 === 0
-        ? (sortedValues[Math.floor(count / 2) - 1] + sortedValues[Math.floor(count / 2)]) / 2
-        : sortedValues[Math.floor(count / 2)]
-
-    // 분산 및 표준편차
-    const variance = values.reduce((acc, val) => acc + Math.pow(val - mean, 2), 0) / count
-    const standardDeviation = Math.sqrt(variance)
-
-    // 최소/최대값 및 범위
-    const minimum = Math.min(...values)
-    const maximum = Math.max(...values)
-    const range = maximum - minimum
-
-    // 분위수 계산
-    const q1Index = Math.floor(count * 0.25)
-    const q3Index = Math.floor(count * 0.75)
-    const percentile25 = sortedValues[q1Index]
-    const percentile75 = sortedValues[q3Index]
-    const iqr = percentile75 - percentile25
-
-    // 이상치 감지를 위한 fence
-    const lowerFence = percentile25 - 1.5 * iqr
-    const upperFence = percentile75 + 1.5 * iqr
-
-    return {
-      count,
-      sum,
-      range,
-      mean,
-      median,
-      minimum,
-      maximum,
-      standardDeviation,
-      variance,
-      percentile25,
-      percentile75,
-      iqr,
-      lowerFence,
-      upperFence,
-      additionalStatistics: {
-        coefficientOfVariation: standardDeviation / mean,
-        skewness: this.calculateSkewness(values, mean, standardDeviation),
-        kurtosis: this.calculateKurtosis(values, mean, standardDeviation)
-      }
-    }
-  }
-
-  /**
-   * 왜도 계산
-   */
-  private static calculateSkewness(values: number[], mean: number, stdDev: number): number {
-    if (stdDev === 0) return 0
-    const n = values.length
-    const sum = values.reduce((acc, val) => acc + Math.pow((val - mean) / stdDev, 3), 0)
-    return (n / ((n - 1) * (n - 2))) * sum
-  }
-
-  /**
-   * 첨도 계산
-   */
-  private static calculateKurtosis(values: number[], mean: number, stdDev: number): number {
-    if (stdDev === 0) return 0
-    const n = values.length
-    const sum = values.reduce((acc, val) => acc + Math.pow((val - mean) / stdDev, 4), 0)
-    const kurtosis = ((n * (n + 1)) / ((n - 1) * (n - 2) * (n - 3))) * sum
-    const adjustment = (3 * Math.pow(n - 1, 2)) / ((n - 2) * (n - 3))
-    return kurtosis - adjustment
-  }
-
-  /**
-   * 기간 타입에 따른 날짜 필터 생성
-   */
-  private static buildDateFilter(valueDate: string, periodType: KpiPeriodType): string {
-    switch (periodType) {
-      case KpiPeriodType.DAY:
-        return valueDate // 정확한 날짜 매치
-      case KpiPeriodType.WEEK:
-        return `${valueDate.substring(0, 8)}%` // YYYY-MM-DD% -> 주 단위
-      case KpiPeriodType.MONTH:
-        return `${valueDate.substring(0, 7)}%` // YYYY-MM%
-      case KpiPeriodType.QUARTER:
-        const year = valueDate.substring(0, 4)
-        const quarter = valueDate.substring(5, 7) // Q1, Q2, Q3, Q4
-        return `${year}-${quarter}%`
-      case KpiPeriodType.YEAR:
-        return `${valueDate.substring(0, 4)}%` // YYYY%
-      default:
-        return valueDate
-    }
-  }
-}

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

@@ -1,291 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-import { getRepository } from '@things-factory/shell'
-import type ResolverContext from '@things-factory/auth-base'
-
-import { KpiStatistic } from './kpi-statistic.js'
-import { NewKpiStatistic, KpiStatisticPatch } from './kpi-statistic-type.js'
-import { KpiStatisticCalculationService } from './kpi-statistic-calculation.service.js'
-import { KpiPeriodType } from '../kpi/kpi.js'
-
-@Resolver(KpiStatistic)
-export class KpiStatisticMutation {
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => KpiStatistic, { description: 'To create new KpiStatistic' })
-  async createKpiStatistic(
-    @Arg('kpiStatistic') kpiStatistic: NewKpiStatistic,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiStatistic> {
-    const { domain, user, tx } = context.state
-
-    // 메타데이터 자동 설정
-    const enrichedKpiStatistic = {
-      ...kpiStatistic,
-      metadata: {
-        calculationMethod: kpiStatistic.metadata?.calculationMethod || 'manual',
-        lastCalculated: new Date(),
-        dataCount: kpiStatistic.count || 0
-      }
-    }
-
-    const result = await getRepository(KpiStatistic, tx).save({
-      ...enrichedKpiStatistic,
-      domain,
-      creator: user,
-      updater: user
-    })
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => KpiStatistic, { description: 'To modify KpiStatistic information' })
-  async updateKpiStatistic(
-    @Arg('id') id: string,
-    @Arg('patch') patch: KpiStatisticPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiStatistic> {
-    const { domain, user, tx } = context.state
-
-    const repository = getRepository(KpiStatistic, tx)
-    const kpiStatistic = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    // 메타데이터 업데이트
-    const updatedMetadata = {
-      ...kpiStatistic.metadata,
-      ...patch.metadata,
-      lastCalculated: new Date()
-    }
-
-    const result = await repository.save({
-      ...kpiStatistic,
-      ...patch,
-      metadata: updatedMetadata,
-      updater: user
-    })
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => [KpiStatistic], { description: "To modify multiple KpiStatistics' information" })
-  async updateMultipleKpiStatistic(
-    @Arg('patches', type => [KpiStatisticPatch]) patches: KpiStatisticPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<KpiStatistic[]> {
-    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 kpiStatisticRepo = getRepository(KpiStatistic, tx)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        // 메타데이터 자동 설정
-        const enrichedRecord = {
-          ...newRecord,
-          metadata: {
-            calculationMethod: newRecord.metadata?.calculationMethod || 'manual',
-            lastCalculated: new Date(),
-            dataCount: newRecord.count || 0
-          }
-        }
-
-        const result = await kpiStatisticRepo.save({
-          ...enrichedRecord,
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const updateRecord = _updateRecords[i]
-        const kpiStatistic = await kpiStatisticRepo.findOneBy({ id: updateRecord.id })
-
-        // 메타데이터 업데이트
-        const updatedMetadata = {
-          ...kpiStatistic.metadata,
-          ...updateRecord.metadata,
-          lastCalculated: new Date()
-        }
-
-        const result = await kpiStatisticRepo.save({
-          ...kpiStatistic,
-          ...updateRecord,
-          metadata: updatedMetadata,
-          updater: user
-        })
-
-        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 KpiStatistic' })
-  async deleteKpiStatistic(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await getRepository(KpiStatistic, 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 KpiStatistics' })
-  async deleteKpiStatistics(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await getRepository(KpiStatistic, 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 KpiStatistics' })
-  async importKpiStatistics(
-    @Arg('kpiStatistics', type => [KpiStatisticPatch]) kpiStatistics: KpiStatisticPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, user, tx } = context.state
-
-    for (const kpiStatistic of kpiStatistics) {
-      // 메타데이터 자동 설정
-      const enrichedKpiStatistic = {
-        ...kpiStatistic,
-        metadata: {
-          calculationMethod: kpiStatistic.metadata?.calculationMethod || 'import',
-          lastCalculated: new Date(),
-          dataCount: kpiStatistic.count || 0
-        }
-      }
-
-      await getRepository(KpiStatistic, tx).save({
-        ...enrichedKpiStatistic,
-        domain,
-        creator: user,
-        updater: user
-      })
-    }
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => [KpiStatistic], { 
-    description: 'Calculate statistics for a specific KPI and period from KpiValue data' 
-  })
-  async calculateKpiStatistics(
-    @Arg('kpiId') kpiId: string,
-    @Arg('periodType', type => KpiPeriodType) periodType: KpiPeriodType,
-    @Arg('valueDate') valueDate: string,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiStatistic[]> {
-    const overallStats = await KpiStatisticCalculationService.calculateKpiStatistics(
-      kpiId,
-      periodType,
-      valueDate,
-      null, // 전체 통계
-      context
-    )
-
-    const scopedStats = await KpiStatisticCalculationService.calculateScopedStatistics(
-      kpiId,
-      periodType,
-      valueDate,
-      context
-    )
-
-    return [overallStats, ...scopedStats].filter(Boolean)
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => [KpiStatistic], { 
-    description: 'Calculate statistics for all KPIs in a specific period from KpiValue data' 
-  })
-  async calculateAllKpiStatistics(
-    @Arg('periodType', type => KpiPeriodType) periodType: KpiPeriodType,
-    @Arg('valueDate') valueDate: string,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiStatistic[]> {
-    return await KpiStatisticCalculationService.calculateAllStatistics(
-      periodType,
-      valueDate,
-      context
-    )
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => [KpiStatistic], { 
-    description: 'Recalculate statistics for dashboard regions (scope02-based statistics)' 
-  })
-  async calculateRegionalStatistics(
-    @Arg('periodType', type => KpiPeriodType, { defaultValue: KpiPeriodType.MONTH }) periodType: KpiPeriodType,
-    @Arg('valueDate') valueDate: string,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiStatistic[]> {
-    const { domain, user, tx } = context.state
-    
-    // 지역별(scope02) 통계만 계산
-    const kpiStatistics = await getRepository(KpiStatistic, tx)
-      .createQueryBuilder('stat')
-      .leftJoinAndSelect('stat.kpiOrgScope', 'orgScope')
-      .leftJoinAndSelect('stat.kpi', 'kpi')
-      .where('stat.domain = :domainId', { domainId: domain.id })
-      .andWhere('stat.periodType = :periodType', { periodType })
-      .andWhere('stat.valueDate = :valueDate', { valueDate })
-      .andWhere('orgScope.scope02 IS NOT NULL') // 지역 정보가 있는 것만
-      .getMany()
-
-    // 계산 결과가 없으면 새로 계산
-    if (kpiStatistics.length === 0) {
-      return await KpiStatisticCalculationService.calculateAllStatistics(
-        periodType,
-        valueDate,
-        context
-      )
-    }
-
-    // 기존 통계 재계산
-    const results: KpiStatistic[] = []
-    for (const stat of kpiStatistics) {
-      const recalculated = await KpiStatisticCalculationService.calculateKpiStatistics(
-        stat.kpiId,
-        periodType,
-        valueDate,
-        stat.kpiOrgScope,
-        context
-      )
-      if (recalculated) results.push(recalculated)
-    }
-
-    return results
-  }
-}