@things-factory/kpi 9.1.19 → 10.0.0-beta.2

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

@@ -1,63 +0,0 @@
-import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import type ResolverContext from '@things-factory/auth-base'
-import { KpiScope } from './kpi-scope'
-import { KpiScopeList } from './kpi-scope-type'
-
-@Resolver(KpiScope)
-export class KpiScopeQuery {
-  @Directive('@privilege(category: "kpi", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
-  @Query(returns => KpiScope!, { nullable: true, description: 'Fetch a scope dimension definition by ID' })
-  async kpiScope(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<KpiScope> {
-    const { domain } = context.state
-
-    return await getRepository(KpiScope).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => KpiScopeList, { description: 'Fetch multiple scope dimension definitions' })
-  @Directive('@privilege(category: "kpi", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
-  async kpiScopes(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiScopeList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(KpiScope),
-      searchables: ['name', 'description'],
-      filtersMap: {
-        level: { columnName: 'level' },
-        scopeType: { columnName: 'scopeType' },
-        parentLevel: { columnName: 'parentLevel' },
-        active: { columnName: 'active' },
-        includeInStatistics: { columnName: 'includeInStatistics' },
-        showInDashboard: { columnName: 'showInDashboard' }
-      }
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() kpiScope: KpiScope): Promise<Domain> {
-    return kpiScope.domainId && (await getRepository(Domain).findOneBy({ id: kpiScope.domainId }))
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() kpiScope: KpiScope): Promise<User> {
-    return kpiScope.updaterId && (await getRepository(User).findOneBy({ id: kpiScope.updaterId }))
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() kpiScope: KpiScope): Promise<User> {
-    return kpiScope.creatorId && (await getRepository(User).findOneBy({ id: kpiScope.creatorId }))
-  }
-}

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

@@ -1,96 +0,0 @@
-import { ScalarObject } from '@things-factory/shell'
-import { ObjectType, Field, InputType, ID, Int } from 'type-graphql'
-import { KpiScope, ScopeType } from './kpi-scope'
-
-@InputType()
-export class NewKpiScope {
-  @Field(type => Int, { description: 'Scope level (1-5) corresponding to scope01-scope05 in KpiOrgScope' })
-  level: number
-
-  @Field({ description: 'Display name for this scope dimension (e.g., "지역", "회사", "프로젝트규모")' })
-  name: string
-
-  @Field({ nullable: true, description: 'Detailed description of what this scope dimension represents' })
-  description?: string
-
-  @Field(type => ScopeType, { description: 'Type category of this scope dimension' })
-  scopeType: ScopeType
-
-  @Field(type => Int, { nullable: true, description: 'Parent scope level if this forms a hierarchy' })
-  parentLevel?: number
-
-  @Field(type => Int, { description: 'Order/priority for display and processing', defaultValue: 1 })
-  displayOrder: number
-
-  @Field(type => [String], { nullable: true, description: 'List of valid values for this scope' })
-  validValues?: string[]
-
-  @Field({ nullable: true, description: 'Regex pattern for validating values in this scope dimension' })
-  validationPattern?: string
-
-  @Field({ description: 'Whether this scope definition is active and should be used', defaultValue: true })
-  active: boolean
-
-  @Field({ description: 'Whether this scope should be included in statistical calculations', defaultValue: true })
-  includeInStatistics: boolean
-
-  @Field({ description: 'Whether this scope should be displayed in dashboard visualizations', defaultValue: false })
-  showInDashboard: boolean
-
-  @Field(type => ScalarObject, { nullable: true, description: 'Additional metadata for this scope dimension' })
-  metadata?: any
-}
-
-@InputType()
-export class KpiScopePatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field(type => Int, { description: 'Scope level (1-5) corresponding to scope01-scope05 in KpiOrgScope' })
-  level: number
-
-  @Field({ description: 'Display name for this scope dimension (e.g., "지역", "회사", "프로젝트규모")' })
-  name: string
-
-  @Field({ nullable: true, description: 'Detailed description of what this scope dimension represents' })
-  description?: string
-
-  @Field(type => ScopeType, { description: 'Type category of this scope dimension' })
-  scopeType: ScopeType
-
-  @Field(type => Int, { nullable: true, description: 'Parent scope level if this forms a hierarchy' })
-  parentLevel?: number
-
-  @Field(type => Int, { description: 'Order/priority for display and processing', defaultValue: 1 })
-  displayOrder: number
-
-  @Field(type => [String], { nullable: true, description: 'List of valid values for this scope' })
-  validValues?: string[]
-
-  @Field({ nullable: true, description: 'Regex pattern for validating values in this scope dimension' })
-  validationPattern?: string
-
-  @Field({ description: 'Whether this scope definition is active and should be used', defaultValue: true })
-  active: boolean
-
-  @Field({ description: 'Whether this scope should be included in statistical calculations', defaultValue: true })
-  includeInStatistics: boolean
-
-  @Field({ description: 'Whether this scope should be displayed in dashboard visualizations', defaultValue: false })
-  showInDashboard: boolean
-
-  @Field(type => ScalarObject, { nullable: true, description: 'Additional metadata for this scope dimension' })
-  metadata?: any
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class KpiScopeList {
-  @Field(type => [KpiScope])
-  items: KpiScope[]
-
-  @Field()
-  total: number
-}

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

@@ -1,143 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  PrimaryGeneratedColumn
-} from 'typeorm'
-import { ObjectType, Field, ID, registerEnumType, Int } from 'type-graphql'
-
-import { Domain, ScalarObject } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-
-export enum ScopeType {
-  GEOGRAPHIC = 'GEOGRAPHIC', // 지리적 차원 (지역, 시도, 구군)
-  ORGANIZATIONAL = 'ORGANIZATIONAL', // 조직 차원 (회사, 부서, 팀)
-  BUSINESS = 'BUSINESS', // 비즈니스 차원 (규모, 유형, 등급)
-  TECHNICAL = 'TECHNICAL', // 기술적 차원 (공종, 기술, 방법)
-  TEMPORAL = 'TEMPORAL', // 시간적 차원 (분기, 년도, 기간)
-  CUSTOM = 'CUSTOM' // 사용자 정의
-}
-
-registerEnumType(ScopeType, {
-  name: 'ScopeType',
-  description: 'Types of organizational scope dimensions'
-})
-
-@Entity()
-@Index('ix_kpi_scope_domain', (kpiScope: KpiScope) => [kpiScope.domain])
-@Index('ix_kpi_scope_level', (kpiScope: KpiScope) => [kpiScope.domain, kpiScope.level])
-@ObjectType({
-  description: 'Defines the meaning and metadata for each scope level (scope01~05) in KpiOrgScope'
-})
-export class KpiScope {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  // 스코프 레벨 (1-5)
-  @Column({ type: 'int' })
-  @Field(type => Int, { description: 'Scope level (1-5) corresponding to scope01-scope05 in KpiOrgScope' })
-  level: number
-
-  // 스코프 차원 이름
-  @Column()
-  @Field({ description: 'Display name for this scope dimension (e.g., "지역", "회사", "프로젝트규모")' })
-  name: string
-
-  // 스코프 차원 설명
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Detailed description of what this scope dimension represents' })
-  description?: string
-
-  // 스코프 타입 (지리적, 조직적, 비즈니스 등)
-  @Column()
-  @Field(type => ScopeType, { description: 'Type category of this scope dimension' })
-  scopeType: ScopeType
-
-  // 계층 정보
-  @Column({ nullable: true })
-  @Field(type => Int, { nullable: true, description: 'Parent scope level if this forms a hierarchy' })
-  parentLevel?: number
-
-  @Column({ default: 1 })
-  @Field(type => Int, { description: 'Order/priority for display and processing' })
-  displayOrder: number
-
-  // 유효한 값들 (선택사항)
-  @Column('simple-json', { nullable: true })
-  @Field(type => ScalarObject, {
-    nullable: true,
-    description: 'List of valid values for this scope (e.g., ["서울", "부산", "대구"] for regions)'
-  })
-  validValues?: string[]
-
-  // 정규표현식 검증 (선택사항)
-  @Column({ nullable: true })
-  @Field({
-    nullable: true,
-    description: 'Regex pattern for validating values in this scope dimension'
-  })
-  validationPattern?: string
-
-  // 활성화 여부
-  @Column({ default: true })
-  @Field({ description: 'Whether this scope definition is active and should be used' })
-  active: boolean
-
-  // 통계 계산에 사용 여부
-  @Column({ default: true })
-  @Field({ description: 'Whether this scope should be included in statistical calculations' })
-  includeInStatistics: boolean
-
-  // 대시보드에 표시 여부
-  @Column({ default: false })
-  @Field({ description: 'Whether this scope should be displayed in dashboard visualizations' })
-  showInDashboard: boolean
-
-  // 메타데이터
-  @Column('simple-json', { nullable: true })
-  @Field(type => ScalarObject, {
-    nullable: true,
-    description: 'Additional metadata for this scope dimension (colors, icons, etc.)'
-  })
-  metadata?: {
-    color?: string
-    icon?: string
-    unit?: string
-    [key: string]: any
-  }
-
-  // === 표준 필드들 ===
-  @ManyToOne(type => Domain)
-  @Field({ nullable: true, description: 'Domain this scope definition belongs to' })
-  domain?: Domain
-
-  @RelationId((kpiScope: KpiScope) => kpiScope.domain)
-  domainId?: string
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((kpiScope: KpiScope) => kpiScope.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((kpiScope: KpiScope) => kpiScope.updater)
-  updaterId?: string
-}

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

@@ -1,7 +0,0 @@
-import { KpiStatistic } from './kpi-statistic.js'
-import { KpiStatisticQuery } from './kpi-statistic-query.js'
-import { KpiStatisticMutation } from './kpi-statistic-mutation.js'
-
-export const entities = [KpiStatistic]
-export const resolvers = [KpiStatisticQuery, KpiStatisticMutation]
-export const subscribers = []

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

@@ -1,231 +0,0 @@
-import { getRepository } from '@things-factory/shell'
-import type ResolverContext from '@things-factory/auth-base'
-import { KpiStatisticCalculationService } from './kpi-statistic-calculation.service'
-import { KpiPeriodType } from '../kpi/kpi'
-import { Domain } from '@things-factory/shell'
-
-/**
- * KPI 통계 배치 계산 서비스
- * 정기적으로 실행하여 KpiValue 데이터를 집계해서 KpiStatistic을 생성/업데이트
- */
-export class KpiStatisticBatchService {
-  
-  /**
-   * 일일 배치: 어제 날짜의 모든 통계 계산
-   */
-  static async runDailyBatch(domainId?: string): Promise<void> {
-    console.log('[KPI Statistics] Starting daily batch calculation...')
-    
-    const yesterday = new Date()
-    yesterday.setDate(yesterday.getDate() - 1)
-    const valueDate = yesterday.toISOString().split('T')[0] // YYYY-MM-DD
-    
-    await this.calculateForAllDomains(KpiPeriodType.DAY, valueDate, domainId)
-    
-    console.log(`[KPI Statistics] Daily batch completed for ${valueDate}`)
-  }
-  
-  /**
-   * 월간 배치: 지난 달의 모든 통계 계산
-   */
-  static async runMonthlyBatch(domainId?: string): Promise<void> {
-    console.log('[KPI Statistics] Starting monthly batch calculation...')
-    
-    const lastMonth = new Date()
-    lastMonth.setMonth(lastMonth.getMonth() - 1)
-    const valueDate = lastMonth.toISOString().substring(0, 7) // YYYY-MM
-    
-    await this.calculateForAllDomains(KpiPeriodType.MONTH, valueDate, domainId)
-    
-    console.log(`[KPI Statistics] Monthly batch completed for ${valueDate}`)
-  }
-  
-  /**
-   * 분기 배치: 지난 분기의 모든 통계 계산
-   */
-  static async runQuarterlyBatch(domainId?: string): Promise<void> {
-    console.log('[KPI Statistics] Starting quarterly batch calculation...')
-    
-    const now = new Date()
-    const currentQuarter = Math.floor(now.getMonth() / 3) + 1
-    const lastQuarter = currentQuarter === 1 ? 4 : currentQuarter - 1
-    const year = currentQuarter === 1 ? now.getFullYear() - 1 : now.getFullYear()
-    const valueDate = `${year}-Q${lastQuarter}`
-    
-    await this.calculateForAllDomains(KpiPeriodType.QUARTER, valueDate, domainId)
-    
-    console.log(`[KPI Statistics] Quarterly batch completed for ${valueDate}`)
-  }
-  
-  /**
-   * 연간 배치: 작년의 모든 통계 계산
-   */
-  static async runYearlyBatch(domainId?: string): Promise<void> {
-    console.log('[KPI Statistics] Starting yearly batch calculation...')
-    
-    const lastYear = new Date().getFullYear() - 1
-    const valueDate = lastYear.toString()
-    
-    await this.calculateForAllDomains(KpiPeriodType.YEAR, valueDate, domainId)
-    
-    console.log(`[KPI Statistics] Yearly batch completed for ${valueDate}`)
-  }
-  
-  /**
-   * 대시보드용 지역별 통계 계산
-   */
-  static async runDashboardBatch(
-    periodType: KpiPeriodType = KpiPeriodType.MONTH,
-    valueDate?: string,
-    domainId?: string
-  ): Promise<void> {
-    console.log('[KPI Statistics] Starting dashboard batch calculation...')
-    
-    if (!valueDate) {
-      const now = new Date()
-      if (periodType === KpiPeriodType.MONTH) {
-        now.setMonth(now.getMonth() - 1)
-        valueDate = now.toISOString().substring(0, 7) // YYYY-MM
-      } else {
-        now.setDate(now.getDate() - 1)
-        valueDate = now.toISOString().split('T')[0] // YYYY-MM-DD
-      }
-    }
-    
-    await this.calculateForAllDomains(periodType, valueDate, domainId)
-    
-    console.log(`[KPI Statistics] Dashboard batch completed for ${valueDate} (${periodType})`)
-  }
-  
-  /**
-   * 모든 도메인에 대해 통계 계산
-   */
-  private static async calculateForAllDomains(
-    periodType: KpiPeriodType,
-    valueDate: string,
-    domainId?: string
-  ): Promise<void> {
-    try {
-      const domains = domainId 
-        ? await getRepository(Domain).find({ where: { id: domainId } })
-        : await getRepository(Domain).find()
-      
-      for (const domain of domains) {
-        try {
-          await this.calculateForDomain(domain, periodType, valueDate)
-        } catch (error) {
-          console.error(`[KPI Statistics] Domain ${domain.name} calculation failed, continuing with next domain:`, error)
-          // 개별 도메인 실패가 전체 배치를 중단시키지 않도록 계속 진행
-          continue
-        }
-      }
-    } catch (error) {
-      console.error('[KPI Statistics] Batch calculation failed:', error)
-      throw error
-    }
-  }
-  
-  /**
-   * 특정 도메인에 대해 통계 계산
-   */
-  private static async calculateForDomain(
-    domain: Domain,
-    periodType: KpiPeriodType,
-    valueDate: string
-  ): Promise<void> {
-    console.log(`[KPI Statistics] Calculating for domain: ${domain.name} (${domain.id})`)
-    
-    // 가짜 ResolverContext 생성 (배치 작업용)
-    const context: ResolverContext = {
-      state: {
-        domain,
-        user: { id: 'system', name: 'System Batch' }, // 시스템 사용자
-        tx: null // 트랜잭션 없음 (각 계산마다 개별 트랜잭션)
-      }
-    } as any
-    
-    try {
-      const statistics = await KpiStatisticCalculationService.calculateAllStatistics(
-        periodType,
-        valueDate,
-        context
-      )
-      
-      console.log(`[KPI Statistics] Generated ${statistics.length} statistics for domain ${domain.name}`)
-      
-      // 성공 로깅
-      this.logBatchResult(domain.id, periodType, valueDate, statistics.length, 'SUCCESS')
-      
-    } catch (error) {
-      console.error(`[KPI Statistics] Failed to calculate for domain ${domain.name}:`, error)
-      
-      // 실패 로깅
-      this.logBatchResult(domain.id, periodType, valueDate, 0, 'FAILED', error.message)
-      
-      // 에러를 던져서 상위에서 처리
-      throw error
-    }
-  }
-  
-  /**
-   * 배치 실행 결과 로깅
-   */
-  private static logBatchResult(
-    domainId: string,
-    periodType: KpiPeriodType,
-    valueDate: string,
-    statisticsCount: number,
-    status: 'SUCCESS' | 'FAILED',
-    errorMessage?: string
-  ): void {
-    const logData = {
-      timestamp: new Date().toISOString(),
-      domainId,
-      periodType,
-      valueDate,
-      statisticsCount,
-      status,
-      errorMessage
-    }
-    
-    // 실제 운영에서는 로깅 시스템에 저장
-    console.log('[KPI Statistics Batch Log]', JSON.stringify(logData))
-  }
-  
-  /**
-   * 배치 작업 스케줄링 설정 예시
-   */
-  static setupBatchSchedule(): void {
-    // 실제 구현시에는 cron 등의 스케줄러 사용
-    console.log('[KPI Statistics] Batch schedule setup example:')
-    console.log('Daily batch: Run at 02:00 AM every day')
-    console.log('Monthly batch: Run at 03:00 AM on 1st of every month') 
-    console.log('Quarterly batch: Run at 04:00 AM on 1st of every quarter')
-    console.log('Yearly batch: Run at 05:00 AM on January 1st')
-    
-    /*
-    // Node-cron 사용 예시:
-    import cron from 'node-cron'
-    
-    // 매일 새벽 2시
-    cron.schedule('0 2 * * *', () => {
-      this.runDailyBatch()
-    })
-    
-    // 매월 1일 새벽 3시
-    cron.schedule('0 3 1 * *', () => {
-      this.runMonthlyBatch()
-    })
-    
-    // 매 분기 첫날 새벽 4시 (1, 4, 7, 10월)
-    cron.schedule('0 4 1 1,4,7,10 *', () => {
-      this.runQuarterlyBatch()
-    })
-    
-    // 매년 1월 1일 새벽 5시
-    cron.schedule('0 5 1 1 *', () => {
-      this.runYearlyBatch()
-    })
-    */
-  }
-}