@things-factory/kpi 9.0.13 → 9.0.15

package/server/migrations/1752191090459-SeedKpiGrade.ts

@@ -1,270 +0,0 @@
-import { MigrationInterface, QueryRunner } from 'typeorm'
-import { Domain, getRepository } from '@things-factory/shell'
-import { KpiGrade } from '../service/kpi-grade/kpi-grade.js'
-import { Kpi } from '../service/kpi/kpi.js'
-
-const GRADE_SEED = [
-  {
-    kpiName: '일정성과 수준 평가',
-    version: 1,
-    grades: [
-      {
-        name: '1점',
-        minValue: 1,
-        maxValue: 1,
-        score: 1,
-        description: '달성상황(기후, 일반변화 등)과 인근주민 민원 등이 발생하여 공기가 지연됨.'
-      },
-      {
-        name: '2점',
-        minValue: 2,
-        maxValue: 2,
-        score: 2,
-        description: '달성상황(기후, 일반변화 등)과 인근주민 민원 등이 발생하여 공기를 맞춤.'
-      },
-      {
-        name: '3점',
-        minValue: 3,
-        maxValue: 3,
-        score: 3,
-        description: '달성상황(기후, 일반변화 등)과 인근주민 민원 등이 발생하지 않으나 공기를 맞춤.'
-      },
-      {
-        name: '4점',
-        minValue: 4,
-        maxValue: 4,
-        score: 4,
-        description: '달성상황(기후, 일반변화 등)과 인근주민 민원 등이 발생하지 않으며 공기를 단축함.'
-      },
-      {
-        name: '5점',
-        minValue: 5,
-        maxValue: 5,
-        score: 5,
-        description: '달성상황(기후, 일반변화 등)과 인근주민 민원 등이 발생하지 않으며 공기를 단축함.'
-      }
-    ]
-  },
-  {
-    kpiName: '비용성과 수준 평가',
-    version: 1,
-    grades: [
-      {
-        name: '1점',
-        minValue: 1,
-        maxValue: 1,
-        score: 1,
-        description: '공사비 변동과 민원 등이 발생하여 공사비 관리가 미흡함.'
-      },
-      {
-        name: '2점',
-        minValue: 2,
-        maxValue: 2,
-        score: 2,
-        description: '공사비 변동과 민원 등이 발생하여 공사비 관리가 미흡함.'
-      },
-      {
-        name: '3점',
-        minValue: 3,
-        maxValue: 3,
-        score: 3,
-        description: '공사비 변동과 민원 등이 발생하였으나 공사비 관리를 적정하게 수행함.'
-      },
-      {
-        name: '4점',
-        minValue: 4,
-        maxValue: 4,
-        score: 4,
-        description: '공사비 변동과 민원 등이 발생하지 않으며 공사비 관리를 적정하게 수행함.'
-      },
-      {
-        name: '5점',
-        minValue: 5,
-        maxValue: 5,
-        score: 5,
-        description: '공사비 변동과 민원 등이 발생하지 않으며 매우 훌륭하게 수행함.'
-      }
-    ]
-  },
-  {
-    kpiName: '품질성과 수준 평가',
-    version: 1,
-    grades: [
-      {
-        name: '1점',
-        minValue: 1,
-        maxValue: 1,
-        score: 1,
-        description: '법적 요구 수준에 못 미치거나 공사 완성도의 개선이 매우 필요한 경우'
-      },
-      {
-        name: '2점',
-        minValue: 2,
-        maxValue: 2,
-        score: 2,
-        description: '법적 요구 수준을 일부 만족하나, 공사 완성도의 개선이 일부 필요한 경우'
-      },
-      { name: '3점', minValue: 3, maxValue: 3, score: 3, description: '법적 요구 수준을 충족하는 수준' },
-      {
-        name: '4점',
-        minValue: 4,
-        maxValue: 4,
-        score: 4,
-        description: '법적 요구 수준을 만족하며, 품질관리 활동이 능동적인 경우'
-      },
-      {
-        name: '5점',
-        minValue: 5,
-        maxValue: 5,
-        score: 5,
-        description: '법적 요구 수준을 만족하며, 품질관리 활동이 매우 능동적인 경우'
-      }
-    ]
-  },
-  {
-    kpiName: '안전성과 수준 평가',
-    version: 1,
-    grades: [
-      {
-        name: '1점',
-        minValue: 1,
-        maxValue: 1,
-        score: 1,
-        description: '법적 요구 수준을 미달하거나 안전관리 활동이 미흡한 경우'
-      },
-      {
-        name: '2점',
-        minValue: 2,
-        maxValue: 2,
-        score: 2,
-        description: '법적 요구 수준을 일부 만족하나, 안전관리 활동이 다소 필요한 경우'
-      },
-      { name: '3점', minValue: 3, maxValue: 3, score: 3, description: '법적 요구 수준을 충족하는 수준' },
-      {
-        name: '4점',
-        minValue: 4,
-        maxValue: 4,
-        score: 4,
-        description: '법적 요구 수준을 만족하며, 안전관리 활동이 능동적인 경우'
-      },
-      {
-        name: '5점',
-        minValue: 5,
-        maxValue: 5,
-        score: 5,
-        description: '법적 요구 수준을 만족하며, 안전관리 활동이 매우 능동적인 경우'
-      }
-    ]
-  },
-  {
-    kpiName: '환경성과 수준 평가',
-    version: 1,
-    grades: [
-      {
-        name: '1점',
-        minValue: 1,
-        maxValue: 1,
-        score: 1,
-        description: '법적 요구 수준에 못 미치거나 환경관리 활동의 개선이 매우 필요한 경우'
-      },
-      {
-        name: '2점',
-        minValue: 2,
-        maxValue: 2,
-        score: 2,
-        description: '법적 요구 수준을 일부 만족하나, 환경관리 활동이 다소 필요한 경우'
-      },
-      { name: '3점', minValue: 3, maxValue: 3, score: 3, description: '법적 요구 수준을 충족하는 수준' },
-      {
-        name: '4점',
-        minValue: 4,
-        maxValue: 4,
-        score: 4,
-        description: '법적 요구 수준을 만족하며, 환경관리 활동의 효율성을 다소 높은 수준'
-      },
-      {
-        name: '5점',
-        minValue: 5,
-        maxValue: 5,
-        score: 5,
-        description: '법적 요구 수준을 만족하며, 환경관리 활동의 효율성이 확연히 높은 수준'
-      }
-    ]
-  },
-  {
-    kpiName: '생산성과 수준 평가',
-    version: 1,
-    grades: [
-      {
-        name: '1점',
-        minValue: 1,
-        maxValue: 1,
-        score: 1,
-        description: '인력 및 장비 투입 규모에 대한 효율성이 매우 낮은 수준'
-      },
-      {
-        name: '2점',
-        minValue: 2,
-        maxValue: 2,
-        score: 2,
-        description: '인력 및 장비 투입 규모가 법적 요구 수준을 충족하나, 연계에 비해 미흡함.'
-      },
-      {
-        name: '3점',
-        minValue: 3,
-        maxValue: 3,
-        score: 3,
-        description: '인력 및 장비 투입 규모가 법적 요구 수준을 충족하는 수준'
-      },
-      {
-        name: '4점',
-        minValue: 4,
-        maxValue: 4,
-        score: 4,
-        description: '투입 규모가 법적 요구 수준을 충족하며, 효율성이 다소 높은 수준'
-      },
-      {
-        name: '5점',
-        minValue: 5,
-        maxValue: 5,
-        score: 5,
-        description: '투입 규모가 법적 요구 수준을 충족하며, 효율성이 확연히 높은 수준'
-      }
-    ]
-  }
-]
-
-export class SeedKpiGrade1752191090459 implements MigrationInterface {
-  public async up(queryRunner: QueryRunner): Promise<any> {
-    const repository = getRepository(KpiGrade)
-    const kpiRepository = getRepository(Kpi)
-    const domain: Domain = await getRepository(Domain).findOneBy({ name: 'SYSTEM' })
-
-    for (const seed of GRADE_SEED) {
-      const kpi = await kpiRepository.findOneBy({ name: seed.kpiName, domain: { id: domain.id } })
-      if (!kpi) continue
-      for (const grade of seed.grades) {
-        await repository.save({
-          ...grade,
-          version: seed.version,
-          kpi,
-          domain
-        })
-      }
-    }
-  }
-
-  public async down(queryRunner: QueryRunner): Promise<any> {
-    const repository = getRepository(KpiGrade)
-    const kpiRepository = getRepository(Kpi)
-    const domain: Domain = await getRepository(Domain).findOneBy({ name: 'SYSTEM' })
-
-    for (const seed of GRADE_SEED) {
-      const kpi = await kpiRepository.findOneBy({ name: seed.kpiName, domain: { id: domain.id } })
-      if (!kpi) continue
-      for (const grade of seed.grades.reverse()) {
-        await repository.delete({ name: grade.name, kpi: { id: kpi.id }, domain: { id: domain.id } })
-      }
-    }
-  }
-}

package/server/migrations/index.ts

@@ -1,9 +0,0 @@
-const glob = require('glob')
-const path = require('path')
-
-export var migrations = []
-
-glob.sync(path.resolve(__dirname, '.', '**', '*.js')).forEach(function(file) {
-  if (file.indexOf('index.js') !== -1) return
-  migrations = migrations.concat(Object.values(require(path.resolve(file))) || [])
-})

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

@@ -1,7 +0,0 @@
-import { KpiGrade } from './kpi-grade'
-import { KpiGradeQuery } from './kpi-grade-query'
-import { KpiGradeMutation } from './kpi-grade-mutation'
-
-export const entities = [KpiGrade]
-export const resolvers = [KpiGradeQuery, KpiGradeMutation]
-export const subscribers = []

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

@@ -1,146 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-import { getRepository } from '@things-factory/shell'
-
-import { KpiGrade } from './kpi-grade'
-import { NewKpiGrade, KpiGradePatch } from './kpi-grade-type'
-import { Kpi } from '../kpi/kpi'
-
-@Resolver(KpiGrade)
-export class KpiGradeMutation {
-  @Directive('@transaction')
-  @Mutation(returns => KpiGrade, { description: 'Create a new KPI grade with the provided details.' })
-  async createKpiGrade(
-    @Arg('grade', { description: 'Input object containing details for the new KPI grade.' }) grade: NewKpiGrade,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiGrade> {
-    const { domain, user, tx } = context.state
-
-    let kpi = grade.kpiId ? await getRepository(Kpi).findOne({ where: { id: grade.kpiId } }) : undefined
-
-    const result = await getRepository(KpiGrade, tx).save({
-      ...grade,
-      kpi,
-      domain,
-      creator: user,
-      updater: user
-    })
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => KpiGrade, { description: 'To modify KpiGrade information' })
-  async updateKpiGrade(
-    @Arg('id') id: string,
-    @Arg('patch') patch: KpiGradePatch,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiGrade> {
-    const { domain, user, tx } = context.state
-
-    const repository = getRepository(KpiGrade, tx)
-    const kpiGrade = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    let kpi = patch.kpiId ? await getRepository(Kpi).findOne({ where: { id: patch.kpiId } }) : kpiGrade.kpi
-
-    const result = await repository.save({
-      ...kpiGrade,
-      ...patch,
-      kpi,
-      updater: user
-    })
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [KpiGrade], { description: "To modify multiple KpiGrades' information" })
-  async updateMultipleKpiGrade(
-    @Arg('patches', type => [KpiGradePatch]) patches: KpiGradePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<KpiGrade[]> {
-    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 kpiGradeRepo = getRepository(KpiGrade, tx)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await kpiGradeRepo.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 kpiGrade = await kpiGradeRepo.findOneBy({ id: updateRecord.id })
-
-        const result = await kpiGradeRepo.save({
-          ...kpiGrade,
-          ...updateRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete KpiGrade' })
-  async deleteKpiGrade(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await getRepository(KpiGrade, tx).delete({ domain: { id: domain.id }, id })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple KpiGrades' })
-  async deleteKpiGrades(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await getRepository(KpiGrade, tx).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To import multiple KpiGrades' })
-  async importKpiGrades(
-    @Arg('kpiGrades', type => [KpiGradePatch]) kpiGrades: KpiGradePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await Promise.all(
-      kpiGrades.map(async (kpiGrade: KpiGradePatch) => {
-        const createdKpiGrade: KpiGrade = await getRepository(KpiGrade, tx).save({ domain, ...kpiGrade })
-      })
-    )
-
-    return true
-  }
-}

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

@@ -1,58 +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 { KpiGrade } from './kpi-grade'
-import { KpiGradeList } from './kpi-grade-type'
-import { Kpi } from '../kpi/kpi'
-
-@Resolver(KpiGrade)
-export class KpiGradeQuery {
-  @Query(returns => KpiGrade!, { nullable: true, description: 'Fetch a single KPI grade by its unique identifier.' })
-  async kpiGrade(
-    @Arg('id', { description: 'Unique identifier of the KPI grade to fetch.' }) id: string,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiGrade> {
-    const { domain } = context.state
-
-    return await getRepository(KpiGrade).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => KpiGradeList, { description: 'To fetch multiple KpiGrades' })
-  async kpiGrades(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<KpiGradeList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(KpiGrade),
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() kpiGrade: KpiGrade): Promise<Domain> {
-    return kpiGrade.domainId && (await getRepository(Domain).findOneBy({ id: kpiGrade.domainId }))
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() kpiGrade: KpiGrade): Promise<User> {
-    return kpiGrade.updaterId && (await getRepository(User).findOneBy({ id: kpiGrade.updaterId }))
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() kpiGrade: KpiGrade): Promise<User> {
-    return kpiGrade.creatorId && (await getRepository(User).findOneBy({ id: kpiGrade.creatorId }))
-  }
-
-  @FieldResolver(type => Kpi, { nullable: true })
-  async kpi(@Root() kpiGrade: KpiGrade): Promise<Kpi | null> {
-    if (!kpiGrade.kpiId) return null
-    return await getRepository(Kpi).findOneBy({ id: kpiGrade.kpiId })
-  }
-}

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

@@ -1,82 +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 { ObjectRef, ScalarObject } from '@things-factory/shell'
-
-import { KpiGrade } from './kpi-grade'
-
-@InputType({ description: 'Input type for creating a new KPI grade. Used in mutations to provide grade details.' })
-export class NewKpiGrade {
-  @Field({ description: 'Name of the grade or section for this KPI.' })
-  name: string
-
-  @Field({ nullable: true, description: 'Detailed description of this KPI grade.' })
-  description?: string
-
-  @Field(type => ID, { description: 'ID of the KPI to which this grade belongs.' })
-  kpiId: string
-
-  @Field(type => Int, { description: 'Version of the KPI definition to which this grade belongs.' })
-  version: number
-
-  @Field(type => Int, { description: 'Minimum value for this grade section.' })
-  minValue: number
-
-  @Field(type => Int, { description: 'Maximum value for this grade section.' })
-  maxValue: number
-
-  @Field(type => Int, { nullable: true, description: 'Score or weight for this grade (optional).' })
-  score?: number
-
-  @Field({ nullable: true, description: 'Color code for this grade (for visualization purposes).' })
-  color?: string
-
-  @Field({ nullable: true, description: 'Indicates whether this KPI grade is active and usable.' })
-  active?: boolean
-}
-
-@InputType({ description: 'Input type for updating an existing KPI grade. Used in mutations to patch grade details.' })
-export class KpiGradePatch {
-  @Field(type => ID, { nullable: true, description: 'ID of the KPI grade to update.' })
-  id?: string
-
-  @Field({ nullable: true, description: 'Name of the grade or section for this KPI.' })
-  name?: string
-
-  @Field({ nullable: true, description: 'Detailed description of this KPI grade.' })
-  description?: string
-
-  @Field(type => ID, { nullable: true, description: 'ID of the KPI to which this grade belongs.' })
-  kpiId?: string
-
-  @Field(type => Int, { nullable: true, description: 'Version of the KPI definition to which this grade belongs.' })
-  version?: number
-
-  @Field(type => Int, { nullable: true, description: 'Minimum value for this grade section.' })
-  minValue?: number
-
-  @Field(type => Int, { nullable: true, description: 'Maximum value for this grade section.' })
-  maxValue?: number
-
-  @Field(type => Int, { nullable: true, description: 'Score or weight for this grade (optional).' })
-  score?: number
-
-  @Field({ nullable: true, description: 'Color code for this grade (for visualization purposes).' })
-  color?: string
-
-  @Field({ nullable: true, description: 'Indicates whether this KPI grade is active and usable.' })
-  active?: boolean
-
-  @Field({ nullable: true, description: 'Custom flag for update operations (internal use).' })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class KpiGradeList {
-  @Field(type => [KpiGrade])
-  items: KpiGrade[]
-
-  @Field(type => Int)
-  total: number
-}

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

@@ -1,101 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  PrimaryGeneratedColumn
-} from 'typeorm'
-import { ObjectType, Field, Int, ID, registerEnumType, Float } from 'type-graphql'
-
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-import { Kpi } from '../kpi/kpi'
-
-@Entity()
-@Index('ix_kpi_grade_0', (kpiGrade: KpiGrade) => [kpiGrade.domain, kpiGrade.kpi, kpiGrade.version, kpiGrade.name], {
-  unique: true
-})
-@ObjectType({
-  description:
-    'KPI grade entity. Represents a grade/section for a KPI version, with value range, score, color, and description.'
-})
-export class KpiGrade {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID, { description: 'Unique identifier for this KPI grade.' })
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field({ nullable: true, description: 'Domain (tenant) to which this KPI grade belongs.' })
-  domain?: Domain
-
-  @RelationId((kpiGrade: KpiGrade) => kpiGrade.domain)
-  @Field({ nullable: true, description: 'ID of the domain (tenant) for this KPI grade.' })
-  domainId?: string
-
-  @Column()
-  @Field({ nullable: true, description: 'Name of the grade or section for this KPI.' })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Detailed description of this KPI grade.' })
-  description?: string
-
-  @Column({ nullable: false, default: false })
-  @Field({ nullable: true, description: 'Indicates whether this KPI grade is active and usable.' })
-  active?: boolean
-
-  @ManyToOne(() => Kpi)
-  @Field(type => Kpi, { description: 'Reference to the KPI to which this grade belongs.' })
-  kpi: Kpi
-
-  @RelationId((kpiGrade: KpiGrade) => kpiGrade.kpi)
-  @Field({ description: 'ID of the referenced KPI.' })
-  kpiId: string
-
-  @Column('int')
-  @Field(type => Int, { description: 'Version of the KPI definition to which this grade belongs.' })
-  version: number
-
-  @Column('float')
-  @Field(type => Float, { description: 'Minimum value for this grade section.' })
-  minValue: number
-
-  @Column('float')
-  @Field(type => Float, { description: 'Maximum value for this grade section.' })
-  maxValue: number
-
-  @Column({ nullable: true, type: 'float' })
-  @Field(type => Float, { nullable: true, description: 'Score or weight for this grade (optional).' })
-  score?: number
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Color code for this grade (for visualization purposes).' })
-  color?: string
-
-  @CreateDateColumn()
-  @Field({ nullable: true, description: 'Timestamp when this KPI grade was created.' })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true, description: 'Timestamp when this KPI grade was last updated.' })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true, description: 'User who created this KPI grade.' })
-  creator?: User
-
-  @RelationId((kpiGrade: KpiGrade) => kpiGrade.creator)
-  @Field({ nullable: true, description: 'ID of the user who created this KPI grade.' })
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true, description: 'User who last updated this KPI grade.' })
-  updater?: User
-
-  @RelationId((kpiGrade: KpiGrade) => kpiGrade.updater)
-  @Field({ nullable: true, description: 'ID of the user who last updated this KPI grade.' })
-  updaterId?: string
-}