exam11/background/service/questionService.js

const {
  addQuestion,
  getAllQuestions,
  getQuestionById,
  updateQuestion,
  deleteQuestion,
  getAllQuestionsWithRelations,
  updateQuestionDescription,
  addChoiceQuestion,
  updateChoiceQuestion,
  deleteChoiceQuestion, // 添加这行
  addFillBlankQuestion,
  updateFillBlankQuestion,
  deleteFillBlankQuestion,
  getFillBlankQuestionsByQuestionId,
  getQuestionsCountAndScore,
  getQuestionCount,
} = require("../db/question.js");

// 导入configService中的increaseQuestionBankVersion方法
const { increaseQuestionBankVersion } = require("./configService.js");

/**
 * 服务层：添加题干
 * @param {Object} questionData - 题干数据
 * @returns {Promise<number>} 新创建的题干ID
 */
async function createQuestion(questionData) {
  try {
    const result = await addQuestion(questionData);
    // 调用增加题库版本号的方法
    await increaseQuestionBankVersion();
    return result;
  } catch (error) {
    console.error("服务层: 添加题干失败", error);
    throw error;
  }
}

/**
 * 服务层：获取所有题干
 * @returns {Promise<Array>} 题干列表
 */
async function fetchAllQuestions() {
  try {
    return await getAllQuestions();
  } catch (error) {
    console.error("服务层: 获取所有题干失败", error);
    throw error;
  }
}

/**
 * 服务层：获取所有题干及其关联信息
 * @returns {Promise<Array>} 包含关联信息的题干列表
 */
async function fetchAllQuestionsWithRelations() {
  try {
    return await getAllQuestionsWithRelations();
  } catch (error) {
    console.error("服务层: 获取所有题干及其关联信息失败", error);
    throw error;
  }
}

/**
 * 服务层：根据ID获取题干
 * @param {number} id - 题干ID
 * @returns {Promise<Object|null>} 题干详情
 */
async function fetchQuestionById(id) {
  try {
    return await getQuestionById(id);
  } catch (error) {
    console.error("服务层: 根据ID获取题干失败", error);
    throw error;
  }
}

/**
 * 服务层：更新题干
 * @param {number} id - 题干ID
 * @param {Object} questionData - 题干数据
 * @returns {Promise<boolean>} 是否更新成功
 */
async function modifyQuestion(id, questionData) {
  try {
    const result = await updateQuestion(id, questionData);
    // 调用增加题库版本号的方法
    await increaseQuestionBankVersion();
    return result;
  } catch (error) {
    console.error("服务层: 更新题干失败", error);
    throw error;
  }
}

/**
 * 服务层：更新题干描述
 * @param {number} id - 题干ID
 * @param {string} questionDescription - 新的题干描述
 * @returns {Promise<boolean>} 是否更新成功
 */
async function modifyQuestionDescription(id, questionDescription) {
  try {
    const result = await updateQuestionDescription(id, questionDescription);
    // 调用增加题库版本号的方法
    await increaseQuestionBankVersion();
    return result;
  } catch (error) {
    console.error("服务层: 更新题干描述失败", error);
    throw error;
  }
}

/**
 * 服务层：删除题干
 * @param {number} id - 题干ID
 * @returns {Promise<boolean>} 是否删除成功
 */
async function removeQuestion(id) {
  try {
    const result = await deleteQuestion(id);
    // 调用增加题库版本号的方法
    await increaseQuestionBankVersion();
    return result;
  } catch (error) {
    console.error("服务层: 删除题干失败", error);
    throw error;
  }
}

/**
 * 服务层：添加选择题问题
 * @param {Object} choiceData - 选择题数据
 * @returns {Promise<number>} 新创建的选择题ID
 */
async function createChoiceQuestion(choiceData) {
  try {
    const result = await addChoiceQuestion(choiceData);
    // 调用增加题库版本号的方法
    await increaseQuestionBankVersion();
    return result;
  } catch (error) {
    console.error("服务层: 添加选择题失败", error);
    throw error;
  }
}

/**
 * 服务层：添加选择题问题
 * @param {number} id - 选择题ID
 * @param {Object} choiceData - 选择题数据
 * @returns {Promise<boolean>} 是否更新成功
 */
async function modifyChoiceQuestion(id, choiceData) {
  try {
    const result = await updateChoiceQuestion(id, choiceData);
    // 调用增加题库版本号的方法
    await increaseQuestionBankVersion();
    return result;
  } catch (error) {
    console.error("服务层: 更新选择题失败", error);
    throw error;
  }
}

/**
 * 服务层：删除选择题问题
 * @param {number} id - 选择题ID
 * @returns {Promise<boolean>} 是否删除成功
 */
async function removeChoiceQuestion(id) {
  try {
    const result = await deleteChoiceQuestion(id);
    // 调用增加题库版本号的方法
    await increaseQuestionBankVersion();
    return result;
  } catch (error) {
    console.error("服务层: 删除选择题失败", error);
    throw error;
  }
}

/**
 * 服务层：添加填空题问题
 * @param {Object} fillBlankData - 填空题数据
 * @returns {Promise<number>} 新创建的填空题ID
 */
async function createFillBlankQuestion(fillBlankData) {
  try {
    const result = await addFillBlankQuestion(fillBlankData);
    // 调用增加题库版本号的方法
    await increaseQuestionBankVersion();
    return result;
  } catch (error) {
    console.error("服务层: 添加填空题失败", error);
    throw error;
  }
}

/**
 * 服务层：更新填空题问题
 * @param {number} id - 填空题ID
 * @param {Object} fillBlankData - 填空题数据
 * @returns {Promise<boolean>} 是否更新成功
 */
async function modifyFillBlankQuestion(id, fillBlankData) {
  try {
    const result = await updateFillBlankQuestion(id, fillBlankData);
    // 调用增加题库版本号的方法
    await increaseQuestionBankVersion();
    return result;
  } catch (error) {
    console.error("服务层: 更新填空题失败", error);
    throw error;
  }
}

/**
 * 服务层：删除填空题问题
 * @param {number} id - 填空题ID
 * @returns {Promise<boolean>} 是否删除成功
 */
async function removeFillBlankQuestion(id) {
  try {
    const result = await deleteFillBlankQuestion(id);
    // 调用增加题库版本号的方法
    await increaseQuestionBankVersion();
    return result;
  } catch (error) {
    console.error("服务层: 删除填空题失败", error);
    throw error;
  }
}

/**
 * 服务层：根据题干ID查询填空题问题
 * @param {number} questionId - 题干ID
 * @returns {Promise<Array>} 填空题列表
 */
async function fetchFillBlankQuestionsByQuestionId(questionId) {
  try {
    return await getFillBlankQuestionsByQuestionId(questionId);
  } catch (error) {
    console.error("服务层: 根据题干ID查询填空题失败", error);
    throw error;
  }
}

/**
 * 服务层：查询试题总数和总分
 * @returns {Promise<{totalQuestions: number, totalScore: number}>} 包含试题总数和总分的对象
 */
async function fetchQuestionsCountAndScore() {
  try {
    return await getQuestionsCountAndScore();
  } catch (error) {
    console.error("服务层: 查询试题总数和总分失败", error);
    throw error;
  }
}

/**
 * 服务层：获取题干数量
 * @returns {Promise<number>} 题干数量
 */
async function getQuestionCountService() {
  try {
    return await getQuestionCount();
  } catch (error) {
    console.error("服务层: 获取题干数量失败", error);
    throw error;
  }
}

/**
 * 初始化试题相关IPC通信
 * @param {Electron.IpcMain} ipcMain - IPC主进程实例
 */
function initQuestionIpc(ipcMain) {
  // 题干管理相关IPC
  ipcMain.handle("question-create", async (event, questionData) => {
    try {
      return await createQuestion(questionData);
    } catch (error) {
      console.error("Failed to create question:", error);
      throw error;
    }
  });

  ipcMain.handle("question-fetch-all", async () => {
    try {
      return await fetchAllQuestions();
    } catch (error) {
      console.error("Failed to fetch questions:", error);
      throw error;
    }
  });

  ipcMain.handle("question-fetch-by-id", async (event, id) => {
    try {
      return await fetchQuestionById(id);
    } catch (error) {
      console.error(`Failed to fetch question by id ${id}:`, error);
      throw error;
    }
  });

  ipcMain.handle("question-update", async (event, id, questionData) => {
    try {
      return await modifyQuestion(id, questionData);
    } catch (error) {
      console.error("Failed to update question:", error);
      throw error;
    }
  });

  ipcMain.handle("question-delete", async (event, id) => {
    try {
      return await removeQuestion(id);
    } catch (error) {
      console.error(`Failed to delete question ${id}:`, error);
      throw error;
    }
  });

  // 在已有的 question 相关 IPC 处理程序区域添加
  ipcMain.handle("question-fetch-all-with-relations", async (event) => {
    try {
      return await fetchAllQuestionsWithRelations();
    } catch (error) {
      console.error("Failed to fetch all questions with relations:", error);
      throw error;
    }
  });

  // 添加更新题干描述的 IPC 处理程序
  ipcMain.handle(
    "question-update-description",
    async (event, id, questionDescription) => {
      try {
        return await modifyQuestionDescription(id, questionDescription);
      } catch (error) {
        console.error("Failed to update question description:", error);
        throw error;
      }
    }
  );

  // 添加选择题问题的IPC处理程序
  ipcMain.handle("question-update-choice", async (event, id, choiceData) => {
    try {
      return await modifyChoiceQuestion(id, choiceData);
    } catch (error) {
      console.error("Failed to update choice question:", error);
      throw error;
    }
  });

  // 添加选择题问题的IPC处理程序
  ipcMain.handle("question-create-choice", async (event, choiceData) => {
    try {
      return await createChoiceQuestion(choiceData);
    } catch (error) {
      console.error("Failed to create choice question:", error);
      throw error;
    }
  });

  // 添加填空题问题的IPC处理程序
  ipcMain.handle("question-create-fill-blank", async (event, fillBlankData) => {
    try {
      return await createFillBlankQuestion(fillBlankData);
    } catch (error) {
      console.error("Failed to create fill blank question:", error);
      throw error;
    }
  });

  // 更新填空题问题的IPC处理程序
  ipcMain.handle(
    "question-update-fill-blank",
    async (event, id, fillBlankData) => {
      try {
        return await modifyFillBlankQuestion(id, fillBlankData);
      } catch (error) {
        console.error("Failed to update fill blank question:", error);
        throw error;
      }
    }
  );

  // 删除填空题问题的IPC处理程序
  ipcMain.handle("question-delete-fill-blank", async (event, id) => {
    try {
      return await removeFillBlankQuestion(id);
    } catch (error) {
      console.error(`Failed to delete fill blank question ${id}:`, error);
      throw error;
    }
  });

  // 添加删除选择题问题的IPC处理程序
  ipcMain.handle("question-delete-choice", async (event, id) => {
    try {
      return await removeChoiceQuestion(id);
    } catch (error) {
      console.error(`Failed to delete choice question ${id}:`, error);
      throw error;
    }
  });

  // 根据题干ID查询填空题问题的IPC处理程序
  ipcMain.handle(
    "question-fetch-fill-blank-by-question-id",
    async (event, questionId) => {
      try {
        return await fetchFillBlankQuestionsByQuestionId(questionId);
      } catch (error) {
        console.error(
          `Failed to fetch fill blank questions by question id ${questionId}:`,
          error
        );
        throw error;
      }
    }
  );

  // 注册查询试题总数和总分的IPC处理程序
  ipcMain.handle("question-get-count-and-score", async () => {
    try {
      return await fetchQuestionsCountAndScore();
    } catch (error) {
      console.error("Failed to fetch questions count and score:", error);
      throw error;
    }
  });

  // 在initQuestionIpc函数中添加新的IPC处理程序
  ipcMain.handle("question-get-count", async () => {
    try {
      const count = await getQuestionCountService();
      return count;
    } catch (error) {
      console.error("获取题干数量失败:", error);
      throw error;
    }
  });
}

// 导出使用CommonJS格式
module.exports = {
  createQuestion,
  fetchAllQuestions,
  fetchAllQuestionsWithRelations,
  fetchQuestionById,
  modifyQuestion,
  modifyQuestionDescription,
  removeQuestion,
  createChoiceQuestion,
  modifyChoiceQuestion,
  removeChoiceQuestion, // 添加这行
  createFillBlankQuestion,
  modifyFillBlankQuestion,
  removeFillBlankQuestion,
  fetchFillBlankQuestionsByQuestionId,
  fetchQuestionsCountAndScore,
  initQuestionIpc,
  getQuestionCountService,
};