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

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

@@ -1,20 +0,0 @@
-import { ObjectType, Field, ID } from 'type-graphql'
-import { Kpi } from '../kpi/kpi'
-
-@ObjectType({ description: 'KPI 경고/알림 엔티티. KPI 실적, 등급, 목표 미달 등 경고/알림 정보를 제공.' })
-export class KpiAlert {
-  @Field(type => ID)
-  id: string
-
-  @Field(type => Kpi, { nullable: true, description: '경고/알림이 발생한 KPI.' })
-  kpi?: Kpi
-
-  @Field({ description: '경고/알림 메시지.' })
-  message: string
-
-  @Field({ description: '경고 레벨(예: warning, critical, info 등).' })
-  level: string
-
-  @Field({ description: '경고/알림 발생 시각.' })
-  createdAt: Date
-}

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

@@ -1,132 +0,0 @@
-import { getRepository } from '@things-factory/shell'
-import type ResolverContext from '@things-factory/auth-base'
-import { DataSummary } from '@things-factory/dataset'
-import { finalizeLatestDataCollection } from '@things-factory/dataset/dist-server/controllers/finalize-data-collection'
-import { KpiMetric } from './kpi-metric'
-import { KpiValue, KpiValueInputType } from '../kpi-value/kpi-value'
-import { Kpi } from '../kpi/kpi'
-import { KpiOrgScope } from '../kpi-org-scope/kpi-org-scope'
-import { KpiFormulaService } from '../kpi/kpi-formula.service'
-
-/**
- * KPI-Metric 집계/자동화 서비스 함수 (formula 지원, KPI Value 저장)
- * @param metricId KPI-Metric ID
- * @param domainId 도메인 ID
- * @param context ResolverContext (state에 domain, user, tx 등 포함)
- * @returns 저장된 KPI Value 배열
- */
-export async function aggregateKpiMetricValue(metricId: string, domainId: string, context: ResolverContext) {
-  const tx = context.state?.tx || getRepository(KpiMetric).manager
-
-  // 1. metric 정보 조회
-  const metric = await getRepository(KpiMetric).findOne({
-    where: { id: metricId, domain: { id: domainId } }
-  })
-  if (!metric) throw new Error('Metric 정보 없음')
-  if (!metric.active) throw new Error('비활성화된 Metric')
-
-  // formula 분기 제거: metric은 항상 dataset 집계만 수행
-  let values: any[] = []
-  if (!metric.dataSetId || !metric.fieldName) throw new Error('Metric 매핑 정보 누락')
-  await finalizeLatestDataCollection(metric.dataSetId, context)
-  const summaries = await getRepository(DataSummary).find({
-    where: { dataSet: { id: metric.dataSetId }, domain: { id: domainId } },
-    order: { date: 'DESC', period: 'DESC' }
-  })
-  values = summaries
-    .map(summary => {
-      if (summary.summary && metric.fieldName in summary.summary) {
-        return {
-          date: summary.date,
-          period: summary.period,
-          value: summary.summary[metric.fieldName],
-          org: {
-            key01: summary.key01,
-            key02: summary.key02,
-            key03: summary.key03,
-            key04: summary.key04,
-            key05: summary.key05
-          }
-        }
-      }
-      return null
-    })
-    .filter(Boolean)
-
-  // 5. KPI Value로 저장 (metric 단위, KPI 단위 formula는 후속)
-  // metric이 속한 KPI 정보 조회 (여기서는 metric.name == kpi.name인 KPI를 임시로 매핑, 실제 연동 구조에 맞게 보완 필요)
-  const kpi = await getRepository(Kpi).findOne({ where: { name: metric.name, domain: { id: domainId } } })
-  if (!kpi) throw new Error('KPI 정보 없음 (metric.name과 동일한 KPI name 기준, 실제 연동 구조에 맞게 보완 필요)')
-
-  // KPI Value version, valueDate, org 등 매핑
-  const savedValues = []
-  const kpiOrgScopeRepo = getRepository(KpiOrgScope, context.state?.tx)
-  const kpiValueRepo = getRepository(KpiValue, context.state?.tx)
-
-  for (const v of values) {
-    const valueDate = v.date
-    const orgData = v.org
-    const version = kpi.version || 1
-    const value = v.value
-    if (value == null || isNaN(value)) continue
-
-    // KpiOrgScope 찾기 또는 생성
-    let kpiOrgScope: KpiOrgScope | null = null
-
-    // key들로 조합된 org 식별자 생성
-    const orgIdentifier =
-      [orgData.key01, orgData.key02, orgData.key03, orgData.key04, orgData.key05].filter(Boolean).join('-') ||
-      'unknown-org'
-
-    // 기존 KpiOrgScope 조회 (entityName 기준)
-    kpiOrgScope = await kpiOrgScopeRepo.findOne({
-      where: { entityName: orgIdentifier, domain: { id: domainId } }
-    })
-
-    // 없으면 새로 생성
-    if (!kpiOrgScope) {
-      kpiOrgScope = await kpiOrgScopeRepo.save({
-        entityType: 'DataSummary', // DataSummary에서 온 데이터임을 표시
-        entityId: `datasummary-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-        entityName: orgIdentifier,
-        org: orgIdentifier, // legacy field
-        scope01: orgData.key01,
-        scope02: orgData.key02,
-        scope03: orgData.key03,
-        scope04: orgData.key04,
-        scope05: orgData.key05,
-        domain: kpi.domain,
-        creator: context.state?.user,
-        updater: context.state?.user
-      })
-    }
-
-    // upsert KpiValue (동일 KPI, valueDate, kpiOrgScope, version 기준)
-    const existing = await kpiValueRepo.findOne({
-      where: {
-        kpi: { id: kpi.id },
-        valueDate,
-        kpiOrgScope: { id: kpiOrgScope.id },
-        version,
-        domain: { id: domainId }
-      }
-    })
-
-    let entity = existing || kpiValueRepo.create()
-    entity.kpi = kpi
-    entity.kpiId = kpi.id
-    entity.version = version
-    entity.valueDate = valueDate
-    entity.value = value
-    entity.kpiOrgScope = kpiOrgScope
-    entity.kpiOrgScopeId = kpiOrgScope.id
-    entity.inputType = KpiValueInputType.AUTO
-    entity.source = 'AUTO-AGGREGATE'
-    entity.domain = kpi.domain
-    entity.creator = context.state?.user
-    entity.updater = context.state?.user
-    entity = await kpiValueRepo.save(entity)
-    savedValues.push(entity)
-  }
-  return savedValues
-}

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

@@ -1,7 +0,0 @@
-import { KpiMetric } from './kpi-metric'
-import { KpiMetricQuery } from './kpi-metric-query'
-import { KpiMetricMutation } from './kpi-metric-mutation'
-
-export const entities = [KpiMetric]
-export const resolvers = [KpiMetricQuery, KpiMetricMutation]
-export const subscribers = []

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

@@ -1,309 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-import { getRepository } from '@things-factory/shell'
-import { DataSet } from '@things-factory/dataset'
-
-import { createAttachment, deleteAttachmentsByRef } from '@things-factory/attachment-base'
-import { KpiMetric } from './kpi-metric'
-import { NewKpiMetric, KpiMetricPatch } from './kpi-metric-type'
-import { KpiFormulaService } from '../kpi/kpi-formula.service'
-import { registerSchedule, unregisterSchedule, CallbackBase, Application } from '@things-factory/scheduler-client'
-
-@Resolver(KpiMetric)
-export class KpiMetricMutation {
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => KpiMetric, { description: 'Create a new KPI metric with the provided details.' })
-  async createKpiMetric(
-    @Arg('kpiMetric', { description: 'Input object containing details for the new KPI metric.' })
-    kpiMetric: NewKpiMetric,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiMetric> {
-    const { domain, user, tx } = context.state
-
-    let dataSet = kpiMetric.dataSetId
-      ? await getRepository(DataSet).findOne({ where: { id: kpiMetric.dataSetId } })
-      : undefined
-
-    // formula 관련 로직 완전 제거
-
-    const result = await getRepository(KpiMetric, tx).save({
-      ...kpiMetric,
-      dataSet,
-      domain,
-      creator: user,
-      updater: user
-    })
-
-    // 스케줄러 등록
-    if (kpiMetric.schedule) {
-      const handle = await registerSchedule({
-        name: kpiMetric.name,
-        client: {
-          application: Application,
-          group: `${domain.id}`,
-          type: 'kpi-metric',
-          key: result.id,
-          operation: 'aggregate'
-        },
-        type: 'cron',
-        schedule: kpiMetric.schedule,
-        timezone: kpiMetric.timezone,
-        task: {
-          type: 'rest',
-          connection: {
-            host: `${CallbackBase}/callback-schedule-for-kpi-metric`,
-            headers: {
-              'Content-Type': 'application/json',
-              accept: '*/*'
-            }
-          },
-          data: {
-            domainId: domain.id,
-            metricId: result.id
-          },
-          history_check: true,
-          failed_policy: 'retry_dlq',
-          max_retry_count: 3,
-          retry_period: 60
-        }
-      })
-      result.scheduleId = handle
-      result.timezone = kpiMetric.timezone
-      await getRepository(KpiMetric, tx).save(result)
-    }
-
-    if (kpiMetric.thumbnail) {
-      await createAttachment(
-        null,
-        {
-          attachment: {
-            file: kpiMetric.thumbnail,
-            refType: KpiMetric.name,
-            refBy: result.id
-          }
-        },
-        context
-      )
-    }
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => KpiMetric, { description: 'To modify KpiMetric information' })
-  async updateKpiMetric(
-    @Arg('id') id: string,
-    @Arg('patch') patch: KpiMetricPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiMetric> {
-    const { domain, user, tx } = context.state
-
-    const repository = getRepository(KpiMetric, tx)
-    const kpiMetric = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    let dataSet = patch.dataSetId
-      ? await getRepository(DataSet).findOne({ where: { id: patch.dataSetId } })
-      : kpiMetric.dataSet
-
-    // formula 관련 로직 완전 제거
-
-    const result = await repository.save({
-      ...kpiMetric,
-      ...patch,
-      dataSet,
-      updater: user
-    })
-
-    // 스케줄러 해제/등록 (변경 시)
-    if (kpiMetric.scheduleId && (patch.scheduleId !== kpiMetric.scheduleId || !patch.scheduleId)) {
-      await unregisterSchedule(kpiMetric.scheduleId)
-      result.scheduleId = null
-    }
-    if (patch.schedule) {
-      const handle = await registerSchedule({
-        name: patch.name || kpiMetric.name,
-        client: {
-          application: Application,
-          group: `${domain.id}`,
-          type: 'kpi-metric',
-          key: result.id,
-          operation: 'aggregate'
-        },
-        type: 'cron',
-        schedule: patch.schedule,
-        timezone: patch.timezone,
-        task: {
-          type: 'rest',
-          connection: {
-            host: `${CallbackBase}/callback-schedule-for-kpi-metric`,
-            headers: {
-              'Content-Type': 'application/json',
-              accept: '*/*'
-            }
-          },
-          data: {
-            domainId: domain.id,
-            metricId: result.id
-          },
-          history_check: true,
-          failed_policy: 'retry_dlq',
-          max_retry_count: 3,
-          retry_period: 60
-        }
-      })
-      result.scheduleId = handle
-      result.timezone = patch.timezone
-      await repository.save(result)
-    }
-
-    if (patch.thumbnail) {
-      await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
-      await createAttachment(
-        null,
-        {
-          attachment: {
-            file: patch.thumbnail,
-            refType: KpiMetric.name,
-            refBy: result.id
-          }
-        },
-        context
-      )
-    }
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => [KpiMetric], { description: "To modify multiple KpiMetrics' information" })
-  async updateMultipleKpiMetric(
-    @Arg('patches', type => [KpiMetricPatch]) patches: KpiMetricPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<KpiMetric[]> {
-    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 kpiMetricRepo = getRepository(KpiMetric, tx)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await kpiMetricRepo.save({
-          ...newRecord,
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        if (newRecord.thumbnail) {
-          await createAttachment(
-            null,
-            {
-              attachment: {
-                file: newRecord.thumbnail,
-                refType: KpiMetric.name,
-                refBy: result.id
-              }
-            },
-            context
-          )
-        }
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const updateRecord = _updateRecords[i]
-        const kpiMetric = await kpiMetricRepo.findOneBy({ id: updateRecord.id })
-
-        const result = await kpiMetricRepo.save({
-          ...kpiMetric,
-          ...updateRecord,
-          updater: user
-        })
-
-        if (updateRecord.thumbnail) {
-          await deleteAttachmentsByRef(null, { refBys: [result.id] }, context)
-          await createAttachment(
-            null,
-            {
-              attachment: {
-                file: updateRecord.thumbnail,
-                refType: KpiMetric.name,
-                refBy: result.id
-              }
-            },
-            context
-          )
-        }
-
-        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 KpiMetric' })
-  async deleteKpiMetric(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-    const repo = getRepository(KpiMetric, tx)
-    const metric = await repo.findOne({ where: { domain: { id: domain.id }, id } })
-    if (metric?.scheduleId) {
-      await unregisterSchedule(metric.scheduleId)
-    }
-    await repo.delete({ domain: { id: domain.id }, id })
-    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To delete multiple KpiMetrics' })
-  async deleteKpiMetrics(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await getRepository(KpiMetric, tx).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    await deleteAttachmentsByRef(null, { refBys: ids }, context)
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To import multiple KpiMetrics' })
-  async importKpiMetrics(
-    @Arg('kpiMetrics', type => [KpiMetricPatch]) kpiMetrics: KpiMetricPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await Promise.all(
-      kpiMetrics.map(async (kpiMetric: KpiMetricPatch) => {
-        const createdKpiMetric: KpiMetric = await getRepository(KpiMetric, tx).save({ domain, ...kpiMetric })
-      })
-    )
-
-    return true
-  }
-}

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

@@ -1,70 +0,0 @@
-import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
-import { Attachment } from '@things-factory/attachment-base'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { KpiMetric } from './kpi-metric'
-import { KpiMetricList } from './kpi-metric-type'
-
-@Resolver(KpiMetric)
-export class KpiMetricQuery {
-  @Directive('@privilege(category: "kpi", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
-  @Query(returns => KpiMetric!, { nullable: true, description: 'Fetch a single KPI metric by its unique identifier.' })
-  async kpiMetric(
-    @Arg('id', { description: 'Unique identifier of the KPI metric to fetch.' }) id: string,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiMetric> {
-    const { domain } = context.state
-
-    return await getRepository(KpiMetric).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Directive('@privilege(category: "kpi", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
-  @Query(returns => KpiMetricList, { description: 'To fetch multiple KpiMetrics' })
-  async kpiMetrics(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiMetricList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(KpiMetric),
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => String)
-  async thumbnail(@Root() kpiMetric: KpiMetric): Promise<string | undefined> {
-    const attachment: Attachment = await getRepository(Attachment).findOne({
-      where: {
-        domain: { id: kpiMetric.domainId },
-        refType: KpiMetric.name,
-        refBy: kpiMetric.id
-      }
-    })
-
-    return attachment?.fullpath
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() kpiMetric: KpiMetric): Promise<Domain> {
-    return kpiMetric.domainId && (await getRepository(Domain).findOneBy({ id: kpiMetric.domainId }))
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() kpiMetric: KpiMetric): Promise<User> {
-    return kpiMetric.updaterId && (await getRepository(User).findOneBy({ id: kpiMetric.updaterId }))
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() kpiMetric: KpiMetric): Promise<User> {
-    return kpiMetric.creatorId && (await getRepository(User).findOneBy({ id: kpiMetric.creatorId }))
-  }
-}

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

@@ -1,111 +0,0 @@
-import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
-import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
-import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
-
-import { KpiPeriodType } from '../kpi/kpi'
-import { KpiMetricCollectType } from './kpi-metric'
-import { KpiMetric } from './kpi-metric'
-
-@InputType({ description: 'Input type for creating a new KPI metric. Used in mutations to provide metric details.' })
-export class NewKpiMetric {
-  @Field({ description: 'Metric code, unique within the domain, used in KPI formulas.' })
-  name: string
-
-  @Field({ nullable: true, description: 'User-friendly name or description of the metric.' })
-  description?: string
-
-  @Field({ nullable: true, description: 'Unit of measurement for this metric (e.g., %, count, hours).' })
-  unit?: string
-
-  @Field({ nullable: true, description: 'Source of the metric data (e.g., system, method, dataset).' })
-  source?: string
-
-  @Field(type => ID, { nullable: true, description: 'ID of the source dataset for this metric.' })
-  dataSetId?: string
-
-  @Field({ nullable: true, description: 'Name of the field in the dataset this metric maps to.' })
-  fieldName?: string
-
-  @Field({ nullable: true, description: 'Indicates whether this metric is active and usable.' })
-  active?: boolean
-
-  @Field({
-    nullable: true,
-    description: 'Cron schedule string for periodic KPI value aggregation (e.g., "0 0 * * *" for daily).'
-  })
-  schedule?: string
-
-  @Field(type => GraphQLUpload, { nullable: true, description: 'Thumbnail image or file for this metric.' })
-  thumbnail?: FileUpload
-
-  @Field({ nullable: true, description: 'Timezone for the schedule.' })
-  timezone?: string
-  @Field({ nullable: true, description: 'Schedule ID for the registered cron job.' })
-  scheduleId?: string
-
-  @Field(type => KpiPeriodType, { nullable: true, description: 'Aggregation period type for this metric.' })
-  periodType?: KpiPeriodType
-
-  @Field(type => KpiMetricCollectType, { nullable: true, description: '데이터 수집 방식' })
-  collectType?: KpiMetricCollectType
-}
-
-@InputType()
-export class KpiMetricPatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  unit?: string
-
-  @Field({ nullable: true })
-  source?: string
-
-  @Field(type => ID, { nullable: true })
-  dataSetId?: string
-
-  @Field({ nullable: true })
-  fieldName?: string
-
-  @Field({ nullable: true })
-  active?: boolean
-
-  @Field({
-    nullable: true,
-    description: 'Cron schedule string for periodic KPI value aggregation (e.g., "0 0 * * *" for daily).'
-  })
-  schedule?: string
-
-  @Field(type => GraphQLUpload, { nullable: true })
-  thumbnail?: FileUpload
-
-  @Field({ nullable: true, description: 'Timezone for the schedule.' })
-  timezone?: string
-
-  @Field({ nullable: true, description: 'Schedule ID for the registered cron job.' })
-  scheduleId?: string
-
-  @Field(type => KpiPeriodType, { nullable: true, description: 'Aggregation period type for this metric.' })
-  periodType?: KpiPeriodType
-
-  @Field({ nullable: true })
-  cuFlag?: string
-
-  @Field(type => KpiMetricCollectType, { nullable: true, description: '데이터 수집 방식' })
-  collectType?: KpiMetricCollectType
-}
-
-@ObjectType()
-export class KpiMetricList {
-  @Field(type => [KpiMetric])
-  items: KpiMetric[]
-
-  @Field(type => Int)
-  total: number
-}