@dssp/dkpi 1.0.0-alpha.7 → 1.0.0-alpha.70

package/dist-server/service/kpi-metric-value/kpi-metric-value-mutation.js

@@ -0,0 +1,687 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KpiMetricValueMutation = void 0;
+const tslib_1 = require("tslib");
+const type_graphql_1 = require("type-graphql");
+const shell_1 = require("@things-factory/shell");
+const typeorm_1 = require("typeorm");
+const kpi_1 = require("@things-factory/kpi");
+const attachment_base_1 = require("@things-factory/attachment-base");
+const project_1 = require("@dssp/project");
+const moment_timezone_1 = tslib_1.__importDefault(require("moment-timezone"));
+const form_data_1 = tslib_1.__importDefault(require("form-data"));
+const node_fetch_1 = tslib_1.__importDefault(require("node-fetch"));
+const https_1 = tslib_1.__importDefault(require("https"));
+const http_1 = tslib_1.__importDefault(require("http"));
+let KpiMetricValueMutation = class KpiMetricValueMutation {
+    /* 프로젝트 수행과정 중에 (시간, 비용, 발생 건수 등) 누적된 값을 반영하여 KPI Metric Value 값을 수정 - 예를 들면, 총 설계 변경 건수, 총 건설 폐기물 발생량, 공사비, 공사기간, 재해 건수 등 */
+    async updateKpiMetricValuesCumulative(patches, context) {
+        const { domain, user, tx } = context.state;
+        const metricValueRepo = (0, shell_1.getRepository)(kpi_1.KpiMetricValue, tx);
+        const metricRepo = (0, shell_1.getRepository)(kpi_1.KpiMetric, tx);
+        const results = [];
+        for (const patch of patches) {
+            const metric = await metricRepo.findOne({ where: { id: patch.metricId } });
+            if (!metric) {
+                throw new Error(`Metric not found: ${patch.metricId}`);
+            }
+            const result = await metricValueRepo.save(Object.assign(Object.assign({ domain }, patch), { metric, updater: user }));
+            results.push(result);
+        }
+        return results;
+    }
+    /* 전문 감리사에 의해서 평가된 별점을 반영하여 KPI Metric Value 값을 수정 */
+    async updateKpiMetricValuesAssessment(patches, context) {
+        const { domain, user, tx } = context.state;
+        const metricValueRepo = (0, shell_1.getRepository)(kpi_1.KpiMetricValue, tx);
+        const metricRepo = (0, shell_1.getRepository)(kpi_1.KpiMetric, tx);
+        const results = [];
+        for (const patch of patches) {
+            const metric = await metricRepo.findOne({ where: { id: patch.metricId } });
+            if (!metric) {
+                throw new Error(`Metric not found: ${patch.metricId}`);
+            }
+            const result = await metricValueRepo.save(Object.assign(Object.assign({ domain }, patch), { metric, updater: user }));
+            results.push(result);
+        }
+        return results;
+    }
+    /* 전문 감리사에 의 감리 최종 평가서의 긍부정을 텍스트 분석하는 감정 분석 기반 평가값을 수정 */
+    async updateKpiMetricValuesSentiment(attachment, context) {
+        const { domain, user, tx } = context.state;
+        const projectRepo = (0, shell_1.getRepository)(project_1.Project, tx);
+        const projectId = attachment.refBy;
+        const attachmentRepo = (0, shell_1.getRepository)(attachment_base_1.Attachment, tx);
+        const metricValueRepo = (0, shell_1.getRepository)(kpi_1.KpiMetricValue, tx);
+        const metricRepo = (0, shell_1.getRepository)(kpi_1.KpiMetric, tx);
+        // 1. 기존 파일 삭제
+        projectRepo.update(projectId, { completeReport: null });
+        await attachmentRepo.delete({ refBy: projectId, refType: attachment.refType });
+        // 2. 새 파일 없으면 끝
+        if (!attachment.file) {
+            return null;
+        }
+        // 3. 먼저 파일을 버퍼로 읽기 (스트림은 한 번만 읽을 수 있으므로)
+        const uploadedFile = await attachment.file;
+        const { filename } = uploadedFile;
+        const fileBuffer = await this.readFileToBuffer(uploadedFile);
+        console.log(`Processing PDF file: ${filename}, size: ${fileBuffer.length} bytes`);
+        // 4. 새 파일 저장 (버퍼를 사용하여 attachment 생성)
+        const recreatedFile = this.createFileUploadFromBuffer(fileBuffer, filename, 'application/pdf');
+        const { id: resultId } = await (0, attachment_base_1.createAttachment)(null, { attachment: Object.assign(Object.assign({}, attachment), { file: recreatedFile }) }, context);
+        const result = await attachmentRepo.findOne({ where: { id: resultId } });
+        projectRepo.update(projectId, { completeReport: result });
+        // 5. pdf 파일을 operator-runner 서비스에 업로드하여 분석
+        let safetyScore = 0;
+        let qualityScore = 0;
+        try {
+            const operatorRunnerUrl = process.env.OPERATOR_RUNNER_URL || 'https://hatiolab-korea-uni.ettisoft.com';
+            // sl-pa-safety 서비스 호출
+            safetyScore = await this.callOperatorRunnerServiceWithBuffer(operatorRunnerUrl, 'sl-pa-safety', fileBuffer, filename);
+            // sl-pa-quality 서비스 호출
+            qualityScore = await this.callOperatorRunnerServiceWithBuffer(operatorRunnerUrl, 'sl-pa-quality', fileBuffer, filename);
+        }
+        catch (error) {
+            console.error('Failed to analyze PDF with operator-runner:', error);
+        }
+        // 5. 메트릭 점수 저장
+        await this.saveMetricValue(metricValueRepo, metricRepo, projectId, 'SL-PA 안전 평가', safetyScore, domain, user);
+        await this.saveMetricValue(metricValueRepo, metricRepo, projectId, 'SL-PA 품질 평가', qualityScore, domain, user);
+        return result;
+    }
+    /**
+     * FileUpload 스트림을 버퍼로 읽기
+     */
+    async readFileToBuffer(fileUpload) {
+        const { createReadStream } = fileUpload;
+        const chunks = [];
+        return new Promise((resolve, reject) => {
+            const stream = createReadStream();
+            stream.on('data', (chunk) => chunks.push(chunk));
+            stream.on('end', () => resolve(Buffer.concat(chunks)));
+            stream.on('error', (error) => reject(error));
+        });
+    }
+    /**
+     * Buffer로부터 FileUpload 객체 생성
+     */
+    createFileUploadFromBuffer(buffer, filename, mimetype) {
+        const { Readable } = require('stream');
+        return {
+            filename,
+            mimetype,
+            encoding: '7bit',
+            createReadStream: () => {
+                const readable = new Readable();
+                readable.push(buffer);
+                readable.push(null);
+                return readable;
+            }
+        };
+    }
+    /**
+     * operator-runner 서비스 호출 (Buffer 사용)
+     */
+    async callOperatorRunnerServiceWithBuffer(baseUrl, serviceName, fileBuffer, filename) {
+        var _a;
+        console.log(`Calling operator-runner service: ${serviceName}`);
+        console.log(`Base URL: ${baseUrl}`);
+        console.log(`Filename: ${filename}`);
+        console.log(`Buffer size: ${fileBuffer.length} bytes`);
+        const formData = new form_data_1.default();
+        // Buffer를 스트림으로 변환하여 추가
+        const { Readable } = require('stream');
+        const bufferStream = Readable.from(fileBuffer);
+        formData.append('files', bufferStream, {
+            filename,
+            contentType: 'application/pdf'
+        });
+        const url = `${baseUrl}/api/run/${serviceName}`;
+        console.log(`Request URL: ${url}`);
+        // HTTP/HTTPS agent 설정
+        const isHttps = url.startsWith('https');
+        const agent = isHttps
+            ? new https_1.default.Agent({
+                keepAlive: false,
+                timeout: 120000,
+                rejectUnauthorized: false
+            })
+            : new http_1.default.Agent({
+                keepAlive: false,
+                timeout: 120000
+            });
+        try {
+            const response = await (0, node_fetch_1.default)(url, {
+                method: 'POST',
+                body: formData,
+                headers: Object.assign(Object.assign({}, formData.getHeaders()), { Authorization: `Basic ${Buffer.from('admin:admin1234').toString('base64')}` }),
+                agent,
+                timeout: 120000
+            });
+            console.log(`Response status: ${response.status}`);
+            if (!response.ok) {
+                const errorText = await response.text();
+                console.error(`Service ${serviceName} error response:`, errorText);
+                throw new Error(`Service ${serviceName} failed (${response.status}): ${errorText}`);
+            }
+            const data = await response.json();
+            console.log(`Service ${serviceName} response:`, JSON.stringify(data));
+            const score = ((_a = data === null || data === void 0 ? void 0 : data.result) === null || _a === void 0 ? void 0 : _a.score) || (data === null || data === void 0 ? void 0 : data.score) || 0;
+            console.log(`Extracted score: ${score}`);
+            return score;
+        }
+        catch (error) {
+            console.error(`Error calling ${serviceName}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * 메트릭 값 저장
+     */
+    async saveMetricValue(metricValueRepo, metricRepo, projectId, metricName, value, domain, user) {
+        const metricValue = await metricValueRepo.findOne({
+            where: { org: projectId, metric: { name: metricName } }
+        });
+        if (metricValue) {
+            await metricValueRepo.save(Object.assign(Object.assign({}, metricValue), { value, updater: user }));
+        }
+        else {
+            const originMetric = await metricRepo.findOne({ where: { name: metricName } });
+            if (originMetric) {
+                await metricValueRepo.save({
+                    metric: { id: originMetric.id },
+                    unit: originMetric.unit || '',
+                    org: projectId,
+                    periodType: originMetric.periodType,
+                    valueDate: (0, moment_timezone_1.default)().tz('Asia/Seoul').format('YYYY-MM-DD'),
+                    value,
+                    domain,
+                    updater: user
+                });
+            }
+        }
+    }
+    async finalizeProjectWithKpiRecalculation(projectId, context) {
+        const { domain, user, tx } = context.state;
+        const projectRepo = (0, shell_1.getRepository)(project_1.Project, tx);
+        const project = await projectRepo.findOne({ where: { id: projectId } });
+        console.log('project :', project);
+        if (!project) {
+            throw new Error(`Project not found: ${projectId}`);
+        }
+        // 이지점에서 프로젝트 KPI Value 계산을 다시 할 것이다.
+        await this.recalculateProjectKpiValues(projectId, context);
+        projectRepo.save(Object.assign(Object.assign({}, project), { state: project_1.ProjectState.COMPLETED }));
+        return true;
+    }
+    /**
+     * 프로젝트의 모든 KPI Value들을 계층적으로 재계산합니다.
+     * 1. 기존 KPI Value 삭제 (중복 방지)
+     * 2. Leaf KPIs (자식이 없는 KPI): formula 기반 계산
+     * 3. Parent KPIs (자식이 있는 KPI): 자식 KPI scores의 weighted average 계산
+     */
+    async recalculateProjectKpiValues(projectId, context) {
+        const { domain, user, tx } = context.state;
+        const kpiValueRepo = (0, shell_1.getRepository)(kpi_1.KpiValue, tx);
+        const kpiRepo = (0, shell_1.getRepository)(kpi_1.Kpi, tx);
+        try {
+            // 1. 기존 KPI Value 삭제 (재계산으로 인한 중복 방지)
+            const existingKpiValues = await kpiValueRepo.find({
+                where: {
+                    group: projectId,
+                    domain: { id: domain.id }
+                }
+            });
+            if (existingKpiValues.length > 0) {
+                await kpiValueRepo.remove(existingKpiValues);
+                console.log(`Deleted ${existingKpiValues.length} existing KPI values for project ${projectId}`);
+            }
+            // 2. 모든 KPI들을 조회 (계층 구조 포함)
+            const allKpis = await kpiRepo.find({
+                where: { domain: { id: domain.id } },
+                relations: ['parent', 'children']
+            });
+            console.log(`Found ${allKpis.length} KPIs total for domain`);
+            // 3. Leaf KPIs (자식이 없는 KPI)와 Parent KPIs 구분
+            const leafKpis = allKpis.filter(kpi => kpi.isLeaf || !kpi.children || kpi.children.length === 0);
+            const parentKpis = allKpis.filter(kpi => !kpi.isLeaf && kpi.children && kpi.children.length > 0);
+            console.log(`Processing ${leafKpis.length} leaf KPIs and ${parentKpis.length} parent KPIs`);
+            // 4. 먼저 Leaf KPIs를 formula로 계산
+            for (const leafKpi of leafKpis) {
+                try {
+                    await this.recalculateLeafKpiValue(leafKpi, projectId, context);
+                    console.log(`Successfully calculated leaf KPI: ${leafKpi.name}`);
+                }
+                catch (error) {
+                    console.error(`Failed to calculate leaf KPI ${leafKpi.name}:`, error.message);
+                    // 개별 KPI 계산 실패는 전체 프로세스를 중단하지 않음
+                }
+            }
+            // 5. Parent KPIs를 계층 레벨순으로 정렬 (깊은 레벨부터)
+            const sortedParentKpis = this.sortKpisByLevel(parentKpis, allKpis);
+            // 6. Parent KPIs를 weighted average로 계산
+            for (const parentKpi of sortedParentKpis) {
+                try {
+                    await this.recalculateParentKpiValue(parentKpi, projectId, allKpis, context);
+                    console.log(`Successfully calculated parent KPI: ${parentKpi.name}`);
+                }
+                catch (error) {
+                    console.error(`Failed to calculate parent KPI ${parentKpi.name}:`, error.message);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error recalculating KPI values for project ${projectId}:`, error);
+            throw error;
+        }
+    }
+    /**
+     * 개별 KPI Value를 재계산합니다.
+     * 항상 최신 버전의 KPI를 사용하여 계산합니다.
+     */
+    async recalculateKpiValue(kpiValue, context) {
+        var _a;
+        const { domain, user, tx } = context.state;
+        const kpiValueRepo = (0, shell_1.getRepository)(kpi_1.KpiValue, tx);
+        const kpiRepo = (0, shell_1.getRepository)(kpi_1.Kpi, tx);
+        const metricRepo = (0, shell_1.getRepository)(kpi_1.KpiMetric, tx);
+        const metricValueRepo = (0, shell_1.getRepository)(kpi_1.KpiMetricValue, tx);
+        // 항상 최신 버전의 KPI를 조회하여 사용
+        // kpiValue.kpi가 이미 로드되어 있으면 사용하고, 없으면 DB에서 최신 버전 조회
+        const kpi = kpiValue.kpi ||
+            (await kpiRepo.findOne({
+                where: { id: kpiValue.kpiId, domain: { id: domain.id } },
+                order: { version: 'DESC' }
+            }));
+        if (!kpi)
+            throw new Error('KPI 정보 없음');
+        if (!kpi.formula) {
+            console.log(`KPI ${kpi.name} has no formula, skipping recalculation`);
+            return kpiValue;
+        }
+        const periodType = kpi.periodType || kpi_1.KpiPeriodType.DAY;
+        const valueDate = null; // kpiValue.valueDate
+        const org = kpiValue.group || 'unknown'; // project ID를 org로 사용
+        // things-factory calculator 기반 formula 계산
+        let kpiValueResult;
+        try {
+            const ast = (0, kpi_1.parseFormula)(kpi.formula);
+            const provider = new kpi_1.KpiMetricValueProvider({
+                valueDate,
+                org,
+                domainId: domain.id,
+                tx
+            });
+            const evalContext = { functions: kpi_1.builtinFunctions, provider };
+            kpiValueResult = await (0, kpi_1.evaluateFormula)(ast, evalContext);
+            if (kpiValueResult == null || isNaN(kpiValueResult)) {
+                throw new Error('KPI formula 결과값 없음');
+            }
+        }
+        catch (error) {
+            console.error(`Formula evaluation failed for KPI ${kpi.name}: ${kpi.formula}`, error);
+            return kpiValue; // 계산 실패시 기존 값 유지
+        }
+        // KPI Value 업데이트 (최신 버전으로)
+        kpiValue.value = kpiValueResult;
+        kpiValue.version = kpi.version || 1;
+        kpiValue.updater = user;
+        // 성과 점수 자동 계산 및 저장
+        try {
+            // 2D lookup KPI (X13 등)인 경우 project의 totalProgress 조회
+            let scoreContext;
+            const gradesData = kpi.grades;
+            if (gradesData && !Array.isArray(gradesData) && gradesData.type === 'PROGRESS_DEVIATION_LOOKUP') {
+                const projectId = kpiValue.group || org;
+                const projectRepo = (0, shell_1.getRepository)(project_1.Project, tx);
+                const project = await projectRepo.findOne({ where: { id: projectId } });
+                scoreContext = { progressRate: (_a = project === null || project === void 0 ? void 0 : project.totalProgress) !== null && _a !== void 0 ? _a : 50 };
+                console.log(`2D lookup KPI ${kpi.name}: progressRate=${scoreContext.progressRate}%`);
+            }
+            await this.calculateAndSaveScore(kpiValue, kpi, scoreContext);
+            console.log(`Successfully calculated score for KPI value ${kpiValue.id}`);
+        }
+        catch (scoreError) {
+            console.error(`Failed to calculate score for KPI value ${kpiValue.id}:`, scoreError.message);
+            // 성과 점수 계산 실패는 KPI Value 저장을 막지 않음
+        }
+        return await kpiValueRepo.save(kpiValue);
+    }
+    /**
+     * scoreFormula를 사용한 성과 점수 계산
+     */
+    async calculateScoreFromFormula(kpi, value) {
+        if (!kpi.scoreFormula) {
+            return null;
+        }
+        try {
+            const ast = (0, kpi_1.parseFormula)(kpi.scoreFormula);
+            const provider = {
+                get: async (name) => {
+                    if (name === 'value')
+                        return value;
+                    return null;
+                }
+            };
+            const evalContext = { functions: kpi_1.builtinFunctions, provider };
+            const result = await (0, kpi_1.evaluateFormula)(ast, evalContext);
+            if (result !== null && result !== undefined && !isNaN(result)) {
+                const performanceScore = Number(result);
+                return {
+                    score: performanceScore,
+                    calculationMethod: 'formula'
+                };
+            }
+        }
+        catch (error) {
+            console.error(`Score formula evaluation for '${kpi.name}: ${kpi.scoreFormula}' error:`, error);
+        }
+        return null;
+    }
+    /**
+     * KPI의 grades lookup table을 이용한 성과 점수 변환
+     * 1D (기존 배열) 및 2D (X13 공정률×편차) lookup 모두 지원
+     */
+    calculateScoreFromLookup(kpi, value, context) {
+        if (!kpi.grades) {
+            return null;
+        }
+        // 2D lookup table 처리 (X13: 공정률 × 편차 → 점수)
+        const grades = kpi.grades;
+        if (!Array.isArray(grades) && grades.type === 'PROGRESS_DEVIATION_LOOKUP') {
+            return this.calculateScoreFrom2DLookup(value, grades, context === null || context === void 0 ? void 0 : context.progressRate);
+        }
+        // 1D lookup table 처리 (기존)
+        if (!Array.isArray(grades) || grades.length === 0) {
+            return null;
+        }
+        const grade = grades.find((g) => value >= g.minValue && value <= g.maxValue);
+        if (!grade) {
+            return null;
+        }
+        return {
+            score: grade.score,
+            calculationMethod: 'lookup'
+        };
+    }
+    /**
+     * 2D lookup table에서 점수 계산 (X13: 공정률 × 편차 → 점수 1~5)
+     */
+    calculateScoreFrom2DLookup(deviationValue, grades, progressRate) {
+        if (!grades.rows || !Array.isArray(grades.rows))
+            return null;
+        const progress = progressRate !== null && progressRate !== void 0 ? progressRate : 50;
+        const progressIndex = Math.min(99, Math.max(0, Math.floor(progress)));
+        const row = grades.rows.find((r) => r.progressRate === progressIndex);
+        if (!row)
+            return null;
+        let score;
+        if (deviationValue < row.boundary5to4) {
+            score = 5;
+        }
+        else if (deviationValue < row.boundary4to3) {
+            score = 4;
+        }
+        else if (deviationValue < row.boundary3to2) {
+            score = 3;
+        }
+        else if (deviationValue < row.boundary2to1) {
+            score = 2;
+        }
+        else {
+            score = 1;
+        }
+        return { score, calculationMethod: 'PROGRESS_DEVIATION_LOOKUP' };
+    }
+    /**
+     * KpiValue의 성과 점수 계산 및 저장
+     * @param context.progressRate X13 등 2D lookup KPI에 필요한 공정률 (0~100)
+     */
+    async calculateAndSaveScore(kpiValue, kpi, context) {
+        // 1. scoreFormula 우선 시도
+        let scoreResult = await this.calculateScoreFromFormula(kpi, kpiValue.value);
+        // 2. scoreFormula가 없거나 실패하면 grades lookup table 사용
+        if (!scoreResult) {
+            scoreResult = this.calculateScoreFromLookup(kpi, kpiValue.value, context);
+        }
+        if (scoreResult) {
+            // KpiValue의 score 필드에 성과 점수 저장
+            kpiValue.score = scoreResult.score;
+            console.log(`Calculated score ${scoreResult.score} for KPI ${kpi.name} with method ${scoreResult.calculationMethod}`);
+        }
+        else {
+            console.log(`No score calculation method available for KPI ${kpi.name}`);
+        }
+    }
+    /**
+     * Leaf KPI Value를 formula로 계산합니다.
+     * 참고: recalculateProjectKpiValues에서 호출 시 기존 값이 이미 삭제되었으므로 항상 새로 생성됩니다.
+     */
+    async recalculateLeafKpiValue(kpi, projectId, context) {
+        const { domain, user, tx } = context.state;
+        const kpiValueRepo = (0, shell_1.getRepository)(kpi_1.KpiValue, tx);
+        // 기존 KPI Value 조회 또는 생성 (프로젝트 재계산 시에는 이미 삭제되어 항상 새로 생성됨)
+        let kpiValue = await kpiValueRepo.findOne({
+            where: {
+                kpi: { id: kpi.id },
+                group: projectId,
+                domain: { id: domain.id }
+            }
+        });
+        if (!kpiValue) {
+            // 새 KPI Value 생성
+            kpiValue = kpiValueRepo.create({
+                kpi,
+                version: kpi.version || 1,
+                group: projectId,
+                domain,
+                valueDate: new Date().toISOString().slice(0, 10),
+                value: 0,
+                score: 0,
+                updater: user
+            });
+        }
+        // formula 기반 계산
+        await this.recalculateKpiValue(kpiValue, context);
+    }
+    /**
+     * Parent KPI Value를 계산합니다.
+     * 1. formula가 있으면 자식 KPI 값들을 변수로 사용하여 formula 계산
+     * 2. formula가 없으면 자식 KPI scores의 weighted average로 계산
+     * 참고: recalculateProjectKpiValues에서 호출 시 기존 값이 이미 삭제되었으므로 항상 새로 생성됩니다.
+     */
+    async recalculateParentKpiValue(parentKpi, projectId, allKpis, context) {
+        const { domain, user, tx } = context.state;
+        const kpiValueRepo = (0, shell_1.getRepository)(kpi_1.KpiValue, tx);
+        // 자식 KPIs 조회
+        const childKpis = allKpis.filter(kpi => { var _a; return ((_a = kpi.parent) === null || _a === void 0 ? void 0 : _a.id) === parentKpi.id; });
+        if (childKpis.length === 0) {
+            console.log(`No child KPIs found for parent KPI: ${parentKpi.name}`);
+            return;
+        }
+        // 자식 KPI Values 조회
+        const childKpiIds = childKpis.map(kpi => kpi.id);
+        const childKpiValues = await kpiValueRepo.find({
+            where: {
+                kpi: { id: (0, typeorm_1.In)(childKpiIds) },
+                group: projectId,
+                domain: { id: domain.id }
+            },
+            relations: ['kpi']
+        });
+        if (childKpiValues.length === 0) {
+            console.log(`No child KPI values found for parent KPI: ${parentKpi.name}`);
+            return;
+        }
+        let calculatedValue;
+        let calculatedScore;
+        // 1. formula가 있으면 formula로 계산
+        if (parentKpi.formula) {
+            try {
+                const ast = (0, kpi_1.parseFormula)(parentKpi.formula);
+                // 자식 KPI 이름 -> score 값 매핑을 위한 provider
+                const childKpiScoreMap = {};
+                childKpiValues.forEach(kpiValue => {
+                    var _a;
+                    const childKpi = childKpis.find(k => k.id === kpiValue.kpi.id);
+                    if (childKpi) {
+                        childKpiScoreMap[childKpi.name] = (_a = kpiValue.score) !== null && _a !== void 0 ? _a : 0;
+                    }
+                });
+                const provider = {
+                    get: async (name) => {
+                        const value = childKpiScoreMap[name];
+                        if (value === undefined) {
+                            throw new Error(`Child KPI '${name}' not found in parent KPI formula`);
+                        }
+                        return value;
+                    }
+                };
+                const evalContext = { functions: kpi_1.builtinFunctions, provider };
+                const result = await (0, kpi_1.evaluateFormula)(ast, evalContext);
+                calculatedValue = result;
+                calculatedScore = result;
+                console.log(`Calculated parent KPI ${parentKpi.name} using formula: value=${calculatedValue.toFixed(4)}`);
+            }
+            catch (error) {
+                console.error(`Failed to evaluate formula for parent KPI ${parentKpi.name}:`, error);
+                // formula 계산 실패 시 가중치 평균으로 대체
+                const { weightedValue, weightedScore } = this.calculateWeightedAverage(childKpiValues, childKpis);
+                calculatedValue = weightedValue;
+                calculatedScore = weightedScore;
+                console.log(`Fallback to weighted average for parent KPI ${parentKpi.name}`);
+            }
+        }
+        else {
+            // 2. formula가 없으면 가중치 평균 계산
+            const { weightedValue, weightedScore } = this.calculateWeightedAverage(childKpiValues, childKpis);
+            calculatedValue = weightedValue;
+            calculatedScore = weightedScore;
+            console.log(`Calculated parent KPI ${parentKpi.name} using weighted average`);
+        }
+        // 기존 Parent KPI Value 조회 또는 생성 (프로젝트 재계산 시에는 이미 삭제되어 항상 새로 생성됨)
+        let parentKpiValue = await kpiValueRepo.findOne({
+            where: {
+                kpi: { id: parentKpi.id },
+                group: projectId,
+                domain: { id: domain.id }
+            }
+        });
+        if (parentKpiValue) {
+            // 기존 값 업데이트 (최신 버전으로)
+            parentKpiValue.value = calculatedValue;
+            parentKpiValue.score = calculatedScore;
+            parentKpiValue.version = parentKpi.version || 1;
+            parentKpiValue.updater = user;
+        }
+        else {
+            // 새 값 생성
+            parentKpiValue = kpiValueRepo.create({
+                kpi: parentKpi,
+                group: projectId,
+                version: parentKpi.version || 1,
+                domain,
+                valueDate: new Date().toISOString().slice(0, 10),
+                value: calculatedValue,
+                score: calculatedScore,
+                updater: user
+            });
+        }
+        await kpiValueRepo.save(parentKpiValue);
+        console.log(`Updated parent KPI ${parentKpi.name}: value=${calculatedValue.toFixed(4)}, score=${calculatedScore.toFixed(4)}`);
+    }
+    /**
+     * KPIs를 계층 레벨순으로 정렬합니다 (깊은 레벨부터)
+     */
+    sortKpisByLevel(parentKpis, allKpis) {
+        const kpiLevels = new Map();
+        const calculateLevel = (kpi) => {
+            if (kpiLevels.has(kpi.id)) {
+                return kpiLevels.get(kpi.id);
+            }
+            if (!kpi.parent) {
+                kpiLevels.set(kpi.id, 0);
+                return 0;
+            }
+            const parentKpi = allKpis.find(k => { var _a; return k.id === ((_a = kpi.parent) === null || _a === void 0 ? void 0 : _a.id); });
+            if (!parentKpi) {
+                kpiLevels.set(kpi.id, 1);
+                return 1;
+            }
+            const level = calculateLevel(parentKpi) + 1;
+            kpiLevels.set(kpi.id, level);
+            return level;
+        };
+        // 각 parent KPI의 레벨 계산
+        parentKpis.forEach(kpi => calculateLevel(kpi));
+        // 레벨 순으로 정렬 (깊은 레벨부터)
+        return parentKpis.sort((a, b) => (kpiLevels.get(b.id) || 0) - (kpiLevels.get(a.id) || 0));
+    }
+    /**
+     * 자식 KPI values의 weighted average를 계산합니다.
+     */
+    calculateWeightedAverage(childValues, childKpis) {
+        let totalWeightedValue = 0;
+        let totalWeightedScore = 0;
+        let totalWeight = 0;
+        for (const value of childValues) {
+            const childKpi = childKpis.find(kpi => kpi.id === value.kpi.id);
+            const weight = (childKpi === null || childKpi === void 0 ? void 0 : childKpi.weight) || 1;
+            totalWeightedValue += value.score * weight; /* value.score 가 value 역할을 value.value 가 아니라 value.score 가 맞다. */
+            totalWeightedScore += value.score * weight;
+            totalWeight += weight;
+        }
+        if (totalWeight === 0) {
+            return { weightedValue: 0, weightedScore: 0 };
+        }
+        return {
+            weightedValue: totalWeightedValue / totalWeight,
+            weightedScore: totalWeightedScore / totalWeight
+        };
+    }
+};
+exports.KpiMetricValueMutation = KpiMetricValueMutation;
+tslib_1.__decorate([
+    (0, type_graphql_1.Directive)('@transaction'),
+    (0, type_graphql_1.Directive)('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)'),
+    (0, type_graphql_1.Mutation)(returns => [kpi_1.KpiMetricValue], { description: "To modify multiple cumulative KpiMetricValues' value" }),
+    tslib_1.__param(0, (0, type_graphql_1.Arg)('patches', type => [kpi_1.KpiMetricValuePatch])),
+    tslib_1.__param(1, (0, type_graphql_1.Ctx)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Array, Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], KpiMetricValueMutation.prototype, "updateKpiMetricValuesCumulative", null);
+tslib_1.__decorate([
+    (0, type_graphql_1.Directive)('@transaction'),
+    (0, type_graphql_1.Directive)('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)'),
+    (0, type_graphql_1.Mutation)(returns => [kpi_1.KpiMetricValue], { description: "To modify multiple assessment KpiMetricValues' value" }),
+    tslib_1.__param(0, (0, type_graphql_1.Arg)('patches', type => [kpi_1.KpiMetricValuePatch])),
+    tslib_1.__param(1, (0, type_graphql_1.Ctx)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [Array, Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], KpiMetricValueMutation.prototype, "updateKpiMetricValuesAssessment", null);
+tslib_1.__decorate([
+    (0, type_graphql_1.Directive)('@transaction'),
+    (0, type_graphql_1.Directive)('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)'),
+    (0, type_graphql_1.Mutation)(returns => attachment_base_1.Attachment, { nullable: true, description: "To modify multiple sentiment KpiMetricValues' value" }),
+    tslib_1.__param(0, (0, type_graphql_1.Arg)('attachment', type => attachment_base_1.NewAttachment)),
+    tslib_1.__param(1, (0, type_graphql_1.Ctx)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [attachment_base_1.NewAttachment, Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], KpiMetricValueMutation.prototype, "updateKpiMetricValuesSentiment", null);
+tslib_1.__decorate([
+    (0, type_graphql_1.Directive)('@transaction'),
+    (0, type_graphql_1.Directive)('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)'),
+    (0, type_graphql_1.Mutation)(returns => Boolean, { description: 'To finalize project with KPI recalculation' }),
+    tslib_1.__param(0, (0, type_graphql_1.Arg)('projectId')),
+    tslib_1.__param(1, (0, type_graphql_1.Ctx)()),
+    tslib_1.__metadata("design:type", Function),
+    tslib_1.__metadata("design:paramtypes", [String, Object]),
+    tslib_1.__metadata("design:returntype", Promise)
+], KpiMetricValueMutation.prototype, "finalizeProjectWithKpiRecalculation", null);
+exports.KpiMetricValueMutation = KpiMetricValueMutation = tslib_1.__decorate([
+    (0, type_graphql_1.Resolver)(kpi_1.KpiMetricValue)
+], KpiMetricValueMutation);
+//# sourceMappingURL=kpi-metric-value-mutation.js.map