공공데이터 xml 파일 json으로 변경해 결과 가져오기(javascript, nodejs)

* 한국어기초사전 api 가져옴

https://krdict.korean.go.kr/openApi/openApiInfo

* 11/16 추가

• 사과처럼 "먹는 사과(apple)"와 "사과하다(apology)" 뜻이 2개인 경우를 생각하지 못함
• axdata.js의 코드 수정함

* 11/30 추가

• 뜻이 한 개면서 뜻이 1개인 것과 2개인 것 서로 구분 못함
• axdata.js의 코드 수정함

* 문제점

1. 파일이 json이 아닌 xml (변환 필요)
2. 검색 시 값이 1개거나 여러 개거나 차이를 두고 결과를 다르게 호출할 것(나무는 값이 여러 개이나, 설탕은 값이 한 개)
   ▶ ex_값을 두고 값이 한 개일 때는 값이 안 들어감

검색 시 나오는 값 저장
korean: 한글,
korean_dfn: 한글 뜻,
english: 영어,
english_dfn: 영어 뜻,
ex_english: 영어단어 검색 이후의 값,
ex_english_dfn: 영어뜻 검색 이후의 값,

* 참고한 곳들

• xml을 json으로 parsing
  https://ibks-platform.tistory.com/176

• json에서 undefined 뜸(json값으로 보이나 string값이므로 json으로 파싱할 것)
  https://okky.kr/articles/829506
  https://developer.mozilla.org/ko/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse

* 결과

▶ 나무 검색 시

▶ 설탕 검색 시

▶ 검색 결과가 없는 경우(지브리 검색함)

* 코드(backend쪽만 작성함)

▶ 미리 설치할 것들
▶ xml-js가 xml파일에서 json으로 변환하는 모듈

npm i axios cors dotenv express https nodemon xml-js

[server.js]

const express = require("express");
require("dotenv").config();
const app = express();
const cors = require("cors");
const axdata = require("./axdata.js");

app.use(
  cors({
    origin: "*",
    credentials: false,
  })
);

app.get("/", async (req, res) => {
  await axdata("햇살", (error, { wordLists } = {}) => {
    if (error) {
      res.send(error);
    }
    res.send(wordLists);
  });
});

app.listen(8000, () => {
  console.log("The server is running at port 8000");
});

[axdata.js]

const axios = require("axios");
const https = require("https");
const convert = require("xml-js");

const axdata = async (wordName, callback) => {
  const url = process.env.WORD_URL;
  let ServiceKey = decodeURIComponent(process.env.WORD_API);

  let korean = "";
  let korean_dfn = "";
  let english = "";
  let english_dfn = "";

  let ex_english = "";
  let ex_english_dfn = "";

  try {
    const response = await axios.get(url, {
      params: {
        key: ServiceKey,
        q: wordName,
        advanced: "y",
        method: "exact",
        translated: "y",
        trans_lang: 1,
      },
      httpsAgent: new https.Agent({
        rejectUnauthorized: false, //허가되지 않은 인증을 reject하지 않겠다!
      }),
    });

    // console.log("response.data", response.data);

    //xml -> json으로 변환
    const result = response.data;
    const xmlToJson = convert.xml2json(result, { compact: true, spaces: 1 });

    const obj = JSON.parse(xmlToJson);
    // console.log(obj.channel.item);
    // console.log(Object.keys(obj.channel.item).includes("0"));
    
  if (word === undefined) {
      korean = wordName;
      korean_dfn = "사전에 입력되지 않은 단어입니다.";
      english = "잘못 검색한 단어입니다.";
      english_dfn = "값을 찾을 수 없습니다.";

      ex_english = "단어 없음";
      ex_english_dfn = "단어 뜻 없음";
    }
    //단어 존재하는 경우
    else if (word !== undefined) {
      if (obj.channel.item[0] === undefined) {
        //단어가 한 개인 경우
        korean = word.word._text;
        //뜻이 한 개인 경우(레몬)
        if (word.sense.length === undefined) {
          korean_dfn = word.sense.definition._text;
          english = word.sense.translation.trans_word._cdata;
          english_dfn = word.sense.translation.trans_dfn._cdata;

          ex_english = "중복된 단어는 없습니다.";
          ex_english_dfn = "중복된 뜻은 없습니다.";
        } else {
          //뜻이 여러 개인 경우(소금)
          korean_dfn = word.sense[0].definition._text;
          english = word.sense[0].translation.trans_word._cdata;
          english_dfn = word.sense[0].translation.trans_dfn._cdata;

          ex_english = word.sense[1].translation.trans_word._cdata;
          ex_english_dfn = word.sense[1].translation.trans_dfn._cdata;
        }
      } else {
        //단어도 뜻도 여러 개인 경우(사과)
        korean = word[0].word._text;
        korean_dfn = word[0].sense.definition._text;
        english = word[0].sense.translation.trans_word._cdata;
        english_dfn = word[0].sense.translation.trans_dfn._cdata;

        ex_english = word[1].sense.translation.trans_word._cdata;
        ex_english_dfn = word[1].sense.translation.trans_dfn._cdata;
      }
    }

    const wordLists = {
      korean: korean,
      korean_dfn: korean_dfn,
      english: english,
      english_dfn: english_dfn,
      ex_english: ex_english,
      ex_english_dfn: ex_english_dfn,
    };

    console.log(wordLists);

    callback(undefined, { wordLists });
  } catch (error) {
    console.log("error broke out:  ", error);
  }
};

module.exports = axdata;