@things-factory/kpi 9.0.31 → 9.0.33

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

@@ -0,0 +1,123 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  EntityManager
+} from 'typeorm'
+import { ObjectType, Field, ID } from 'type-graphql'
+
+import { Domain } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+
+@Entity()
+@Index('ix_kpi_org_scope_0', (orgScope: KpiOrgScope) => [orgScope.domain, orgScope.entityType, orgScope.entityId], {
+  unique: true
+})
+@ObjectType({
+  description:
+    'KPI organization scope mapping entity. Maps business entities to various scope dimensions for KPI analysis using generic reference pattern.'
+})
+export class KpiOrgScope {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID, { description: 'Unique identifier for this org-scope mapping.' })
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true, description: 'Domain (tenant) to which this org-scope mapping belongs.' })
+  domain?: Domain
+
+  @RelationId((orgScope: KpiOrgScope) => orgScope.domain)
+  @Field({ nullable: true, description: 'ID of the domain (tenant) for this org-scope mapping.' })
+  domainId?: string
+
+  @Column()
+  @Field({ description: 'Type of the referenced business entity (e.g., Project, Department, Company, Employee)' })
+  entityType: string
+
+  @Column()
+  @Field({ description: 'ID of the referenced business entity' })
+  entityId: string
+
+  @Column()
+  @Field({ description: 'Name of the referenced business entity (denormalized for performance and convenience)' })
+  entityName: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'Legacy org field for backward compatibility' })
+  org?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'First scope dimension (e.g., geographical region, business unit)' })
+  scope01?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'Second scope dimension (e.g., product line, customer segment)' })
+  scope02?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'Third scope dimension (e.g., process type, technology stack)' })
+  scope03?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'Fourth scope dimension (e.g., cost center, profit center)' })
+  scope04?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true, description: 'Fifth scope dimension (e.g., risk level, priority tier)' })
+  scope05?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true, description: 'Timestamp when this org-scope mapping was created.' })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true, description: 'Timestamp when this org-scope mapping was last updated.' })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true, description: 'User who created this org-scope mapping.' })
+  creator?: User
+
+  @RelationId((orgScope: KpiOrgScope) => orgScope.creator)
+  @Field({ nullable: true, description: 'ID of the user who created this org-scope mapping.' })
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true, description: 'User who last updated this org-scope mapping.' })
+  updater?: User
+
+  @RelationId((orgScope: KpiOrgScope) => orgScope.updater)
+  @Field({ nullable: true, description: 'ID of the user who last updated this org-scope mapping.' })
+  updaterId?: string
+
+  // Helper methods for Generic Reference Pattern
+  async getReferencedEntity(entityManager: EntityManager): Promise<any> {
+    try {
+      const repository = entityManager.getRepository(this.entityType)
+      return await repository.findOne({ where: { id: this.entityId } })
+    } catch (error) {
+      console.warn(`Failed to get referenced entity ${this.entityType}:${this.entityId}`, error)
+      return null
+    }
+  }
+
+  async validateEntityReference(entityManager: EntityManager): Promise<boolean> {
+    try {
+      const entity = await this.getReferencedEntity(entityManager)
+      return !!entity
+    } catch {
+      return false
+    }
+  }
+
+  // Convenience getter for display purposes
+  get displayName(): string {
+    return this.entityName || `${this.entityType}:${this.entityId}` || this.org || 'Unknown'
+  }
+}

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

@@ -0,0 +1,11 @@
+import { KpiScope } from './kpi-scope'
+import { KpiScopeQuery } from './kpi-scope-query'
+import { KpiScopeMutation } from './kpi-scope-mutation'
+
+export const entities = [KpiScope]
+export const resolvers = [KpiScopeQuery, KpiScopeMutation]
+
+export * from './kpi-scope'
+export * from './kpi-scope-query'
+export * from './kpi-scope-mutation'
+export * from './kpi-scope-type'

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

@@ -0,0 +1,129 @@
+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 { KpiScope } from './kpi-scope'
+import { NewKpiScope, KpiScopePatch } from './kpi-scope-type'
+
+@Resolver(KpiScope)
+export class KpiScopeMutation {
+  @Directive('@transaction')
+  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
+  @Mutation(returns => KpiScope, { description: 'Create a new scope dimension definition' })
+  async createKpiScope(
+    @Arg('kpiScope') kpiScope: NewKpiScope,
+    @Ctx() context: ResolverContext
+  ): Promise<KpiScope> {
+    const { domain, user, tx } = context.state
+
+    const result = await getRepository(KpiScope, tx).save({
+      ...kpiScope,
+      domain,
+      creator: user,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
+  @Mutation(returns => KpiScope, { description: 'Update a scope dimension definition' })
+  async updateKpiScope(
+    @Arg('id') id: string,
+    @Arg('patch') patch: KpiScopePatch,
+    @Ctx() context: ResolverContext
+  ): Promise<KpiScope> {
+    const { domain, user, tx } = context.state
+
+    const repository = getRepository(KpiScope, tx)
+    const kpiScope = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    const result = await repository.save({
+      ...kpiScope,
+      ...patch,
+      updater: user
+    })
+
+    return result
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
+  @Mutation(returns => [KpiScope], { description: "Update multiple scope dimension definitions" })
+  async updateMultipleKpiScope(
+    @Arg('patches', type => [KpiScopePatch]) patches: KpiScopePatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<KpiScope[]> {
+    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 kpiScopeRepo = getRepository(KpiScope, tx)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await kpiScopeRepo.save({
+          ...newRecord,
+          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 kpiScope = await kpiScopeRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await kpiScopeRepo.save({
+          ...kpiScope,
+          ...updateRecord,
+          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: 'Delete a scope dimension definition' })
+  async deleteKpiScope(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await getRepository(KpiScope, 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: 'Delete multiple scope dimension definitions' })
+  async deleteKpiScopes(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await getRepository(KpiScope, tx).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    return true
+  }
+
+}

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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,96 @@
+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

@@ -0,0 +1,143 @@
+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
+}