749 lines
26 KiB
JavaScript
749 lines
26 KiB
JavaScript
const xpath = require('xpath');
|
|
const { DOMParser } = require('xmldom');
|
|
const _ = require('lodash');
|
|
|
|
const findSimilarString = require('./findSimilarString');
|
|
|
|
module.exports = getGpdpScore;
|
|
|
|
function parseColorToHex(colorString) {
|
|
// 정규식을 사용하여 B, G, R, A 값 추출
|
|
const regex = /B:\s*(\d+),\s*G:\s*(\d+),\s*R:\s*(\d+),\s*A:\s*(\d+)/;
|
|
const matches = colorString.match(regex);
|
|
|
|
if (!matches) {
|
|
throw new Error('Invalid color string format');
|
|
}
|
|
|
|
// matches[1]은 B, matches[2]는 G, matches[3]은 R, matches[4]는 A
|
|
const [_, b, g, r, a] = matches;
|
|
|
|
// 각 값을 16진수로 변환하고 2자리로 패딩
|
|
const rHex = parseInt(r).toString(16).padStart(2, '0');
|
|
const gHex = parseInt(g).toString(16).padStart(2, '0');
|
|
const bHex = parseInt(b).toString(16).padStart(2, '0');
|
|
const aHex = parseInt(a).toString(16).padStart(2, '0');
|
|
|
|
// #RRGGBBAA 형식으로 반환
|
|
return `${rHex}${gHex}${bHex}`;
|
|
}
|
|
|
|
/**
|
|
* /Document/Layers/Layer/Shapes/Shape/draw_type 속성값
|
|
* > Interior: 내부 채우기 / Outline: 외곽선
|
|
* /Document/Layers/Layer/Shapes/Shape/interior_type 속성값
|
|
* > Fill: 채우기 / Gradient: 그라데이션
|
|
* @param {*} gpdpData
|
|
* @param {*} scoringJson
|
|
* @param {*} index
|
|
* @returns
|
|
*/
|
|
|
|
// xml 형식의 GPDP 파일을 읽어서 점수를 계산
|
|
// scoring.json 파일 내에 있는 ele 요소는 xpath 형식으로 접근하여 요소를 탐색하고 나오는 값을 value와 비교하여 점수를 계산
|
|
// scoring.json 파일 내에 있는 type은 비교할 값의 타입을 의미하며, boolean, array 등이 있음
|
|
// scoring.json 파일 내에 있는 type에 따라 비교하는 방식이 달라짐
|
|
// 채점 결과를 scoringResultList 배열에 저장
|
|
function getGpdpScore(gpdpData, scoringJson, index) {
|
|
function compareAndScore(user, right, point, key, scoringResult, options = {}) {
|
|
let score = 0;
|
|
let isEqual = false;
|
|
|
|
const {
|
|
tolerance = 0, // 숫자 비교 시 허용 오차
|
|
type = 'auto', // 'auto' | 'number[]' | 'string[]' | 'object' | 'primitive'
|
|
partial = false,
|
|
} = options;
|
|
|
|
if (type === 'force-correct') {
|
|
score = point;
|
|
}
|
|
// 객체 비교
|
|
else if (
|
|
(type === 'object' || (type === 'auto' && typeof right === 'object' && typeof user === 'object'))
|
|
&& !Array.isArray(right)
|
|
) {
|
|
if (partial) {
|
|
const keys = Object.keys(right);
|
|
const partialPoint = point / keys.length;
|
|
for (const k of keys) {
|
|
if (_.isEqual(user[k], right[k])) {
|
|
score += partialPoint;
|
|
}
|
|
}
|
|
} else {
|
|
if (_.isEqual(user, right)) {
|
|
score = point;
|
|
}
|
|
}
|
|
}
|
|
|
|
// 배열 비교
|
|
else if (Array.isArray(right) && Array.isArray(user)) {
|
|
if (right.length === user.length) {
|
|
if (type === 'number[]' || (type === 'auto' && typeof right[0] === 'number')) {
|
|
if (right.every((val, idx) => val === user[idx])) {
|
|
score = point;
|
|
}
|
|
} else if (type === 'string[]' || (type === 'auto' && typeof right[0] === 'string')) {
|
|
if (right.every((val, idx) => val === user[idx])) {
|
|
score = point;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 원시값 비교
|
|
else {
|
|
if (user == right) {
|
|
score = point;
|
|
}
|
|
}
|
|
|
|
console.log(`▶ 작성답안:`, user);
|
|
if (score > 0) {
|
|
if (partial)
|
|
console.log('⭕부분정답:', right, `(${score}/${point})`);
|
|
else
|
|
console.log('⭕ 정답 : ', right, `(${score}/${point})`);
|
|
}
|
|
else {
|
|
console.log(`❌ 오답:`, right);
|
|
}
|
|
|
|
scoringResult[key] = score;
|
|
return score;
|
|
}
|
|
|
|
const gpdpXmlDoc = gpdpData;
|
|
const scoringResult = {};
|
|
|
|
const scoringData = scoringJson[index];
|
|
// console.log(scoringData);
|
|
|
|
const layerList = xpath.select('/Document/Layers/Layer', gpdpXmlDoc);
|
|
|
|
layerList.forEach((layer, layerIndex) => {
|
|
const childNodes = Array.from(layer.childNodes);
|
|
childNodes.forEach(child => {
|
|
// console.log("🚀 ~ child node:", child);
|
|
});
|
|
});
|
|
|
|
let totalScore = 0;
|
|
|
|
// 15번 문항의 정답 여부를 추적할 상태 플래그를 선언합니다.
|
|
let hasClippingMask = false;
|
|
// 15번 문항에 종속적인 문항들의 키 목록을 정의합니다.
|
|
const clippingMaskKeys = ['16', '17', '18', '19', '20'];
|
|
|
|
// 채점기준표 문항별 분류
|
|
for (const key in scoringData) {
|
|
console.log(`❔❔ 문제번호 : [${index}-${key}]`)
|
|
|
|
if ( clippingMaskKeys.includes(key) && !hasClippingMask ) {
|
|
console.log("❌ 오답: 클리핑 마스크 미적용(15번 문항 오답)이므로 오답처리 ")
|
|
scoringResult[key] = 0;
|
|
continue; // 현재 문항 채점을 건너뛰고 다음 문항으로 넘어갑니다.
|
|
}
|
|
let ele = scoringData[key].ele;
|
|
let ele2 = scoringData[key].ele2;
|
|
const rightAnswer = scoringData[key].value;
|
|
const point = scoringData[key].point;
|
|
const type = scoringData[key].type;
|
|
let search = scoringData[key].search;
|
|
|
|
let userAnswer = null;
|
|
|
|
const layer = scoringData[key].layer;
|
|
const option = scoringData[key].option;
|
|
const style = scoringData[key].style;
|
|
|
|
ele = typeof ele === 'string' ? ele.replace(/{layer}/g, layer) : ele;
|
|
ele = typeof ele === 'string' ? ele.replace(/{option}/g, option) : ele;
|
|
ele = typeof ele === 'string' ? ele.replace(/{style}/g, style) : ele;
|
|
|
|
// search 값이 undefined 아니면 ele의 {search}부분을 search로 치환
|
|
/**
|
|
* JSON파일 곰믹스 5번문항/22번 문항
|
|
* type : "video" 인 항목들
|
|
* GPString태그 VID7속성 찾는 xpath구문
|
|
* CRCUnitArr태그 Name속성 찾는 구문으로 변환
|
|
* > 멀티라인 텍스트 유사도 판별하기 어려움
|
|
*/
|
|
if (search !== undefined) {
|
|
let result = findSimilarString(gpdpXmlDoc, search, 0.8);
|
|
if (result !== null) {
|
|
result = result.replace(/"/g, "'");
|
|
search = result;
|
|
ele = ele?.replace(/{search}/g, search);
|
|
}
|
|
else {
|
|
ele = ele?.includes('{search}') ? null : ele;
|
|
}
|
|
}
|
|
|
|
if (type === "none") {
|
|
console.log("⚠️ 채점하지 않음");
|
|
scoringResult[key] = "확인필요";
|
|
continue;
|
|
}
|
|
|
|
else if (type === "canvas.Size") {
|
|
const result = xpath.select(ele, gpdpXmlDoc);
|
|
const width = result[0].value;
|
|
const height = result[1].value;
|
|
|
|
userAnswer = [width, height];
|
|
totalScore += compareAndScore(userAnswer, rightAnswer, point, key, scoringResult, { type: 'number[]' });
|
|
|
|
continue;
|
|
}
|
|
|
|
// [1-4] 사진1 > 조정
|
|
else if (type === "layer.Effects") {
|
|
const effects = ele ? xpath.select(ele, gpdpXmlDoc) : [];
|
|
|
|
let isMatched = false;
|
|
for (const item of effects) {
|
|
const name = xpath.select1('Name/@value', item)?.value;
|
|
const effectData = xpath.select1(`EffectData`, item);
|
|
|
|
// 동일한 이펙트 요소만 검사
|
|
if (rightAnswer['name'] !== name) {
|
|
continue;
|
|
}
|
|
|
|
userAnswer = {
|
|
name: name,
|
|
option: {},
|
|
}
|
|
const optionKeys = Object.keys(rightAnswer['option']);
|
|
if (name === '흑백') {
|
|
const Intensity = xpath.select1('Intensity/@value', effectData)?.value;
|
|
if (optionKeys.includes('강도')) userAnswer['option']['강도'] = Intensity;
|
|
}
|
|
else if (name === '밝기/대비') {
|
|
const brightness = xpath.select1('brightness/@value', effectData)?.value;
|
|
const contrast = xpath.select1('contrast/@value', effectData)?.value;
|
|
if (optionKeys.includes('밝기')) userAnswer['option']['밝기'] = brightness;
|
|
if (optionKeys.includes('대비')) userAnswer['option']['대비'] = contrast;
|
|
}
|
|
else if (name === '노출') {
|
|
const ExposureValue = xpath.select1('ExposureValue/@value', effectData)?.value;
|
|
if (optionKeys.includes('노출')) userAnswer['option']['노출'] = ExposureValue;
|
|
}
|
|
else if (name === '색조/채도') {
|
|
const hue = xpath.select1('hue/@value', effectData)?.value;
|
|
const saturation = xpath.select1('saturation/@value', effectData)?.value;
|
|
const lightness = xpath.select1('lightness/@value', effectData)?.value;
|
|
if (optionKeys.includes('색조')) userAnswer['option']['색조'] = hue;
|
|
if (optionKeys.includes('채도')) userAnswer['option']['채도'] = saturation;
|
|
if (optionKeys.includes('명도')) userAnswer['option']['명도'] = lightness;
|
|
}
|
|
else if (name === '감마') {
|
|
const lift = xpath.select1('Lift/@value', effectData)?.value;
|
|
const gamma = xpath.select1('Gamma/@value', effectData)?.value;
|
|
const gain = xpath.select1('Gain/@value', effectData)?.value;
|
|
if (optionKeys.includes('리프트')) userAnswer['option']['리프트'] = lift;
|
|
if (optionKeys.includes('감마')) userAnswer['option']['감마'] = gamma;
|
|
if (optionKeys.includes('게인')) userAnswer['option']['게인'] = gain;
|
|
}
|
|
else if (name === '세피아') {
|
|
const u = xpath.select1('U/@value', effectData)?.value;
|
|
const v = xpath.select1('V/@value', effectData)?.value;
|
|
|
|
const optionKeys = Object.keys(rightAnswer['option']).map(key => key.toUpperCase());
|
|
if (optionKeys.includes('U')) userAnswer['option']['U'] = u;
|
|
if (optionKeys.includes('V')) userAnswer['option']['V'] = v;
|
|
}
|
|
else if (name === '생동감') {
|
|
const vibranceValue = xpath.select1('VibranceValue/@value', effectData)?.value;
|
|
// 생동감 옵션값이 프로그램에서 적용한 값에 오차가 발생하는 경우가 있음
|
|
// 곰픽>XML / 30>29 / 40>39
|
|
// 설정한 값 그대로 적용되는 경우도 있어서 오차범위 2로 설정
|
|
const userValue = parseInt(vibranceValue, 10);
|
|
const rightValue = parseInt(rightAnswer.option['생동감'], 10);
|
|
if (Math.abs(rightValue - userValue) <= 2) {
|
|
if (optionKeys.includes('생동감')) {
|
|
userAnswer['option']['생동감'] = rightValue.toString();
|
|
}
|
|
}
|
|
}
|
|
else if (name === '흐리게') {
|
|
const radius = xpath.select1('radius/@value', effectData)?.value;
|
|
if (optionKeys.includes('반경')) userAnswer['option']['반경'] = radius;
|
|
}
|
|
else if (name === '글로우') {
|
|
const radius = xpath.select1('radius/@value', effectData)?.value;
|
|
const brightness = xpath.select1('brightness/@value', effectData)?.value;
|
|
const contrast = xpath.select1('contrast/@value', effectData)?.value;
|
|
if (optionKeys.includes('반경')) userAnswer['option']['반경'] = radius;
|
|
if (optionKeys.includes('밝기')) userAnswer['option']['밝기'] = brightness;
|
|
if (optionKeys.includes('대비')) userAnswer['option']['대비'] = contrast;
|
|
}
|
|
else if (name === '픽셀효과') {
|
|
const cellSize = xpath.select1('cellSize/@value', effectData)?.value;
|
|
if (optionKeys.includes('셀크기')) userAnswer['option']['셀크기'] = cellSize;
|
|
}
|
|
else if (name === '선명하게') {
|
|
const amount = xpath.select1('amount/@value', effectData)?.value;
|
|
if (optionKeys.includes('양')) userAnswer['option']['양'] = amount;
|
|
}
|
|
|
|
for (const key in rightAnswer.option) {
|
|
// 속성값이 정답과 다른 경우가 있으면 오답처리
|
|
if (rightAnswer.option[key] !== userAnswer.option[key]) {
|
|
isMatched = false;
|
|
break;
|
|
}
|
|
else {
|
|
isMatched = true;
|
|
}
|
|
}
|
|
|
|
// 속성값이 하나라도 일치하지 않으면 오답
|
|
if (isMatched === false) {
|
|
break;
|
|
}
|
|
}
|
|
totalScore += compareAndScore(userAnswer, rightAnswer, point, key, scoringResult);
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// else if (type === "exists") {
|
|
else if (type.includes("exists")) {
|
|
const existsValues = xpath.select(ele, gpdpXmlDoc);
|
|
let isMatched = false;
|
|
|
|
for (const v of existsValues) {
|
|
userAnswer = v.value;
|
|
if (type.includes('layer') || type.includes('text')) {
|
|
|
|
// 공백, 대소문자 무시
|
|
const cleanUserAnswer = userAnswer.replace(/\s+/g, '').toLowerCase();
|
|
const cleanRightAnswer = rightAnswer.replace(/\s+/g, '').toLowerCase();
|
|
|
|
// 하나라도 일치하면 정답
|
|
if (cleanUserAnswer === cleanRightAnswer) {
|
|
isMatched = true;
|
|
break;
|
|
}
|
|
}
|
|
else {
|
|
if (userAnswer === rightAnswer) {
|
|
isMatched = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (isMatched) {
|
|
totalScore += compareAndScore(userAnswer, rightAnswer, point, key, scoringResult, {
|
|
type: 'force-correct'
|
|
});
|
|
}
|
|
else {
|
|
totalScore += compareAndScore(userAnswer, rightAnswer, point, key, scoringResult);
|
|
}
|
|
|
|
if ( type.includes('hasClippingMask') && scoringResult[key] > 0 ) {
|
|
hasClippingMask = true;
|
|
}
|
|
}
|
|
|
|
|
|
// else if (type === "shape.size") {
|
|
else if (type.includes("size")) {
|
|
const items = xpath.select(ele, gpdpXmlDoc);
|
|
let isMatched = false;
|
|
|
|
// 각 Item 요소별 x,y 좌표 시작점과 끝점의 거리를 계산해 정답과 비교
|
|
for (const item of items) {
|
|
const x1 = Number(xpath.select1('Item[1]/X/@value', item)?.value);
|
|
const y1 = Number(xpath.select1('Item[1]/Y/@value', item)?.value);
|
|
|
|
const x2 = Number(xpath.select1('Item[last()]/X/@value', item)?.value);
|
|
const y2 = Number(xpath.select1('Item[last()]/Y/@value', item)?.value);
|
|
|
|
const width = Math.round(Math.abs(x2 - x1));
|
|
const height = Math.round(Math.abs(y2 - y1));
|
|
|
|
userAnswer = {
|
|
width: width,
|
|
height: height,
|
|
};
|
|
|
|
// 하나라도 일치하면 정답
|
|
if (JSON.stringify(userAnswer) == JSON.stringify(rightAnswer)) {
|
|
isMatched = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
totalScore += compareAndScore(userAnswer, rightAnswer, point, key, scoringResult);
|
|
continue;
|
|
}
|
|
|
|
// [1-8]
|
|
else if (type.includes("color")) {
|
|
const items = xpath.select(ele, gpdpXmlDoc);
|
|
let normalizedAnswer = null;
|
|
let isMatched = false;
|
|
|
|
const isGradient = type.includes("gradient");
|
|
const isSingleColor =
|
|
type.includes("shape") || type.includes("text") || type.includes("clipping");
|
|
|
|
// 정답 색상 정규화
|
|
if (isGradient) {
|
|
normalizedAnswer = {
|
|
startColor: rightAnswer.startColor.toLowerCase(),
|
|
endColor: rightAnswer.endColor.toLowerCase(),
|
|
};
|
|
} else if (isSingleColor) {
|
|
normalizedAnswer = rightAnswer.toLowerCase?.();
|
|
}
|
|
|
|
// 각 항목 비교
|
|
for (const item of items) {
|
|
// 그라데이션 컬러의 채점
|
|
if (isGradient) {
|
|
// 시작점과 끝점의 컬러를 구할 xpath구문
|
|
const startColorXpath = scoringData[key].startColor;
|
|
const endColorXpath = scoringData[key].endColor;
|
|
|
|
// 해당 xpath를 이용 RGB값 추출
|
|
const startColorRGB = xpath.select1(startColorXpath, item)?.value;
|
|
const endColorRGB = xpath.select1(endColorXpath, item)?.value;
|
|
|
|
// RGB to HEX
|
|
const userStartColor = parseColorToHex(startColorRGB);
|
|
const userEndColor = parseColorToHex(endColorRGB);
|
|
|
|
userAnswer = {
|
|
startColor: userStartColor,
|
|
endColor: userEndColor,
|
|
};
|
|
|
|
if (JSON.stringify(userAnswer) === JSON.stringify(normalizedAnswer)) {
|
|
isMatched = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (isSingleColor) {
|
|
const color = parseColorToHex(item.value);
|
|
userAnswer = color;
|
|
|
|
if (userAnswer === normalizedAnswer) {
|
|
isMatched = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
totalScore += compareAndScore(userAnswer, normalizedAnswer, point, key, scoringResult);
|
|
}
|
|
|
|
else if (type === 'layer.blend.opacity') {
|
|
const layers = xpath.select(ele, gpdpXmlDoc);
|
|
let isMatched = false;
|
|
|
|
for (const layer of layers) {
|
|
const blendop = xpath.select1('BlendOp/@value', layer).value;
|
|
const opacity = xpath.select1('Opacity/@value', layer).value;
|
|
|
|
userAnswer = {
|
|
BlendOp: blendop,
|
|
Opacity: opacity,
|
|
}
|
|
|
|
// 하나라도 일치하면 정답
|
|
if (JSON.stringify(userAnswer) == JSON.stringify(rightAnswer)) {
|
|
isMatched = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
totalScore += compareAndScore(userAnswer, rightAnswer, point, key, scoringResult);
|
|
continue;
|
|
}
|
|
|
|
// [5-20]
|
|
else if (type === 'shadow') {
|
|
const shapes = xpath.select(ele, gpdpXmlDoc);
|
|
if (!(shapes?.length)) {
|
|
userAnswer = {
|
|
shadow: null,
|
|
width: null,
|
|
distance: null,
|
|
blur: null,
|
|
angle: null,
|
|
}
|
|
}
|
|
for (const shape of shapes) {
|
|
// 그림자 설정 여부
|
|
const shadowExists = xpath.select1('contains(draw_type/@value, "Shadow")', shape);
|
|
// Shadow 옵션이 있다면
|
|
if (shadowExists) {
|
|
// 두께
|
|
const width = xpath.select1('shadow_width/@value', shape).value;
|
|
// 거리
|
|
const distance = xpath.select1('shadow_distance/@value', shape).value;
|
|
// 분산도
|
|
const blur = xpath.select1('shadow_blur/@value', shape).value;
|
|
// 각도
|
|
const angle = xpath.select1('shadow_angle/@value', shape).value;
|
|
|
|
userAnswer = {
|
|
shadow: shadowExists,
|
|
width: width,
|
|
distance: distance,
|
|
blur: blur,
|
|
angle: angle,
|
|
}
|
|
}
|
|
else {
|
|
userAnswer = {
|
|
shadow: shadowExists,
|
|
width: null,
|
|
distance: null,
|
|
blur: null,
|
|
angle: null,
|
|
}
|
|
}
|
|
}
|
|
// console.log("🚀 ~ userAnswer:", userAnswer);
|
|
// console.log("🚀 ~ rightAnswer : ", rightAnswer)
|
|
totalScore += compareAndScore(userAnswer, rightAnswer, point, key, scoringResult, {
|
|
partial: true
|
|
})
|
|
continue;
|
|
}
|
|
|
|
else if (type == "boolean") {
|
|
const items = xpath.select(ele, gpdpXmlDoc);
|
|
|
|
// xpath 결과값을 반환하는 요소가 없을 경우
|
|
if (!items) {
|
|
scoringResult[key] = 0;
|
|
console.log("❌ 찾는 요소 없음");
|
|
}
|
|
else {
|
|
totalScore += point;
|
|
scoringResult[key] = point;
|
|
console.log("✅ 찾는 요소 존재함");
|
|
}
|
|
}
|
|
|
|
// 이펙트 효과의 이름과 속성값을 비교
|
|
else if (type == "effects") {
|
|
const items = xpath.select(ele, gpdpXmlDoc);
|
|
let matched = false;
|
|
|
|
// 각 Item 요소별 이름과 속성값을 구하고 정답과 비교
|
|
for (const item of items) {
|
|
const name = xpath.select1('Name/@value', item)?.value;
|
|
const attr = xpath.select1(`EffectData/${option?.replace(/"/g, '')}/@value`, item)?.value;
|
|
|
|
if (name === rightAnswer[0] && attr === rightAnswer[1]) {
|
|
totalScore += point;
|
|
scoringResult[key] = point;
|
|
matched = true;
|
|
console.log("✅ 정답 일치:", rightAnswer);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!matched) {
|
|
scoringResult[key] = 0;
|
|
console.log("❌ 정답 없음:", rightAnswer);
|
|
}
|
|
}
|
|
|
|
else if (type == "multiValue") {
|
|
if (Array.isArray(rightAnswer)) {
|
|
const result = ele ? xpath.select(ele, gpdpXmlDoc) : [];
|
|
const resultValues = Array.isArray(result) ? result.map(r => (typeof r === 'object' ? r.value : r)) : [result];
|
|
console.log("🚀 ~ getGpdpScore ~ resultValues:", resultValues)
|
|
|
|
const groupSize = rightAnswer.length;
|
|
const groupedResult = [];
|
|
for (let i = 0; i < resultValues.length; i += groupSize) {
|
|
groupedResult.push(resultValues.slice(i, i + groupSize));
|
|
}
|
|
console.log("🚀 ~ getGpdpScore ~ groupedResult:", groupedResult)
|
|
|
|
// 배열 비교 함수
|
|
function arraysEqual(arr1, arr2) {
|
|
if (arr1.length !== arr2.length) return false;
|
|
return arr1.every((value, index) => value === arr2[index]);
|
|
}
|
|
|
|
// groupedResult 내부 배열에서 rightAnswer와 일치하는 배열이 있는지 확인
|
|
const isMatch = groupedResult.some(group => arraysEqual(group, rightAnswer));
|
|
|
|
if (isMatch) {
|
|
totalScore += point;
|
|
scoringResult[key] = point;
|
|
console.log("🚀 ~ 정답 포함");
|
|
} else {
|
|
scoringResult[key] = 0;
|
|
console.log("🚀 ~ 오답");
|
|
}
|
|
}
|
|
}
|
|
|
|
else if (type == "exact") {
|
|
let result = xpath.select(ele, gpdpXmlDoc);
|
|
if (result.length == 0) {
|
|
scoringResult[key] = 0;
|
|
console.log('ele not found');
|
|
continue;
|
|
}
|
|
if (result[0].value === rightAnswer) {
|
|
totalScore += point;
|
|
scoringResult[key] = point;
|
|
} else {
|
|
scoringResult[key] = 0;
|
|
console.log('ele not matched, ' + result[0].value);
|
|
}
|
|
}
|
|
|
|
|
|
else if (type == "multi") {
|
|
try {
|
|
const result = xpath.select(ele, gpdpXmlDoc);
|
|
let isSame = true;
|
|
// console.log(`ele: ${ele}, value: ${value} result: ${result}`);
|
|
|
|
if (result.length == 0) {
|
|
console.log('result length 0');
|
|
scoringResult[key] = 0;
|
|
continue;
|
|
}
|
|
|
|
result.forEach((v, i) => {
|
|
// value[i] 값이 정수형인 경우에는 float로 변환하여 비교
|
|
// 정수형 v값을 float 형으로 변환하고 소수점 3자리까지 버림
|
|
let temp = v.value;
|
|
let answer = rightAnswer[i];
|
|
|
|
if (Number.isFinite(rightAnswer[i]) && !Number.isInteger(rightAnswer[i])) {
|
|
temp = parseFloat(v.value);
|
|
answer = parseFloat(rightAnswer[i]);
|
|
// 소수점 3자리까지 버림
|
|
temp = Math.floor(temp * 1000) / 1000;
|
|
}
|
|
// answer 문자열 중 : 가 포함되어 있다면 각각 분리하고 그 값의 차이를 구함
|
|
if (typeof answer == "string" && answer.indexOf(':') > -1) {
|
|
const [answerStart, answerEnd] = answer.split(':').map(Number);
|
|
const [tempStart, tempEnd] = temp.split(':').map(Number);
|
|
answer = answerEnd - answerStart;
|
|
temp = tempEnd - tempStart;
|
|
}
|
|
|
|
console.log(`temp: ${temp} answer: ${answer}`);
|
|
if (answer !== temp) {
|
|
console.log(`answer !== temp`);
|
|
isSame = false;
|
|
}
|
|
});
|
|
totalScore += isSame ? point : 0;
|
|
scoringResult[key] = isSame ? point : 0;
|
|
} catch (e) {
|
|
console.log('err :', e);
|
|
scoringResult[key] = 0;
|
|
}
|
|
}
|
|
else if (type == "gradient") {
|
|
const items = xpath.select(ele, gpdpXmlDoc);
|
|
const startColorXpath = scoringData[key].startColor;
|
|
const endColorXpath = scoringData[key].endColor;
|
|
let matched = false;
|
|
|
|
for (const item of items) {
|
|
const startColor = parseColorToHex(xpath.select1(startColorXpath, item)?.value);
|
|
const endColor = parseColorToHex(xpath.select1(endColorXpath, item)?.value);
|
|
|
|
console.log(startColor + ":" + rightAnswer["startColor"], endColor + ":" + rightAnswer["endColor"]);
|
|
|
|
if (startColor === rightAnswer["startColor"] && endColor === rightAnswer["endColor"]) {
|
|
totalScore += point;
|
|
scoringResult[key] = point;
|
|
matched = true;
|
|
console.log("✅ 정답 일치:", rightAnswer);
|
|
break;
|
|
}
|
|
}
|
|
if (!matched) {
|
|
scoringResult[key] = 0;
|
|
console.log("❌ 정답 없음:", rightAnswer);
|
|
}
|
|
}
|
|
// 그림자 속성이 있는지 여부 파악해서 그림자 속성 별로 점수 1 점씩 부여
|
|
else if (type == "shadow") {
|
|
|
|
const result = xpath.select(ele["shadow"], gpdpXmlDoc);
|
|
let shadowScore = 0;
|
|
if (result.length == 0) {
|
|
scoringResult[key] = 0;
|
|
console.log('shadow not found');
|
|
continue;
|
|
}
|
|
|
|
shadowScore += 1;
|
|
const width = xpath.select(ele["width"], gpdpXmlDoc);
|
|
const distance = xpath.select(ele["distance"], gpdpXmlDoc);
|
|
const blur = xpath.select(ele["blur"], gpdpXmlDoc);
|
|
const angle = xpath.select(ele["angle"], gpdpXmlDoc);
|
|
|
|
if (width.length !== 0 && width[0].value == rightAnswer["width"]) {
|
|
shadowScore += 1;
|
|
console.log('width matched');
|
|
}
|
|
if (distance.length !== 0 && distance[0].value == rightAnswer["distance"]) {
|
|
shadowScore += 1;
|
|
console.log('distance matched');
|
|
}
|
|
if (blur.length !== 0 && blur[0].value == rightAnswer["blur"]) {
|
|
shadowScore += 1;
|
|
console.log('blur matched');
|
|
}
|
|
if (angle.length !== 0 && angle[0].value == rightAnswer["angle"]) {
|
|
shadowScore += 1;
|
|
console.log('angle matched');
|
|
}
|
|
totalScore += shadowScore;
|
|
scoringResult[key] = shadowScore;
|
|
}
|
|
else {
|
|
const result = xpath.select(ele, gpdpXmlDoc);
|
|
const result2 = null;
|
|
let isCheck = false;
|
|
|
|
if (result.length == 0) {
|
|
isCheck = true;
|
|
}
|
|
if (isCheck && ele2) {
|
|
result2 = xpath.select(ele2, gpdpXmlDoc);
|
|
|
|
if (result2.length == 0) {
|
|
scoringResult[key] = 0;
|
|
continue;
|
|
}
|
|
result = result2;
|
|
// console.log(`1st isChecked: ${isCheck}, result: ${result}`)
|
|
}
|
|
// value와 result[0].value를 비교하여 같으면 점수 point 부여
|
|
// console.log(`${(value === result[0].value)}, ${result.length > 0 && value === result[0].value} `)
|
|
// console.log(`2nd isChecked: ${isCheck}, result: ${result}`)
|
|
totalScore += result.length > 0 ? point : 0;
|
|
scoringResult[key] = result.length > 0 ? point : 0;
|
|
}
|
|
}
|
|
scoringResult['총점'] = totalScore;
|
|
return scoringResult;
|
|
}
|