React와 Node.js를 활용한 PDF 생성 및 미리보기 이미지 처리(2)

import express from "express";
import "express-async-errors";
import { body } from "express-validator";
import { isAuth } from "../middleware/auth.js";
import { isUpload } from "../middleware/uploadBook.js";
import { convertPdf } from "../middleware/convertPdf.js";
import { validate } from "../middleware/validator";
import * as ebookController from "../controller/ebook.js";

const router = express.Router();

const validateEbook = [
  // 유효성 검사 미들웨어
  // ...,
  validate, // express-validator가 적용된 후 발생한 에러를 처리하는 미들웨어.
];

router.get("/", isAuth, ebookController.getBooks);

router.post(
  "/",
  isAuth, // 인증 여부를 확인하는 미들웨어.
  validateEbook,
  isUpload.single("file"), // 업로드된 파일을 처리하는 미들웨어. file 필드에서 단일 파일을 받음.
  convertPdf, // PDF 파일을 PNG로 변환하는 미들웨어.
  ebookController.uploadBook // 업로드된 전자책 데이터를 처리하는 컨트롤러.
);

// ... 수정, 삭제 라우터

export default router;

import path from "path";
import multer from "multer";
import fs from "fs";

// 업로드 폴더 경로 설정 (public/uploads)
const uploadPath = path.join(process.cwd(), "public", "files");

// 서버 시작 시 업로드 경로가 존재하지 않으면 폴더를 생성
if (!fs.existsSync(uploadPath)) {
  fs.mkdirSync(uploadPath, { recursive: true });
  console.log("files directory created inside public");
}

// Multer 설정
const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    cb(null, uploadPath); // public/uploads 경로로 파일 저장
  },
  filename: (req, file, cb) => {
    const safeFileName =
      Date.now() +
      "-" +
      Buffer.from(file.originalname, "latin1")
        .toString("utf8")
        .replace(/[^a-zA-Z0-9.\-_]/g, "");
    cb(null, safeFileName); // 파일 이름 설정
  },
});

// 파일 업로드 제한
export const isUpload = multer({
  storage,
  limits: {
    fileSize: 510 * 1024 * 1024, // 파일 크기 제한 (10MB)
  },
  fileFilter: (req, file, cb) => {
    if (file.mimetype === "application/pdf") {
      cb(null, true); // PDF 파일만 허용
    } else {
      cb(new Error("Only PDF files are allowed"), false);
    }
  },
});

import { Poppler } from "node-poppler";
import path from "path";
import fs from "fs";

const poppler = new Poppler();

// Express 미들웨어로 작동하며, PDF 파일을 변환한 후에 요청을 다음 미들웨어로 넘긴다.
export const convertPdf = async (req, res, next) => {
  try {
    const file = req.file;

    // 파일 존재 여부 검사
    if (!file) {
      return res.status(400).json({ message: "No file uploaded" });
    }

    // 이미지 저장 경로 설정
    const uploadPath = path.join(process.cwd(), "public", "images");

    // 이미지 경로가 없으면 생성
    if (!fs.existsSync(uploadPath)) {
      fs.mkdirSync(uploadPath, { recursive: true });
      console.log("Images directory created inside public");
    }

    const pdfFilePath = file.path; // 업로드된 PDF 파일의 경로

    // 변환된 이미지 파일이 저장될 경로
    const outputFilePath = path.join(
      uploadPath,
      `${path.parse(file.filename).name}-preview`
    );

    // PDF 파일의 첫 페이지를 PNG 이미지로 변환
    await poppler.pdfToCairo(pdfFilePath, outputFilePath, {
      pngFile: true, // PNG 파일로 변환
      singleFile: true, // 첫 페이지만 변환

      // 첫 페이지와 마지막 페이지를 동일하게 설정
      firstPageToConvert: 1,
      lastPageToConvert: 1,
    });

    req.outputFilePath = outputFilePath; // 변환된 이미지 경로 저장
    next(); // 변환이 완료되면 다음 미들웨어로 넘어감
  } catch (error) {
    res.status(500).json({
      message: "PDF to image conversion failed",
      error: error.message,
    });
  }
};

import * as ebookRepository from "../data/ebook.js";

export async function getBooks(req, res) {
  const filename = req.query.filename;

  const data = await (filename
    ? ebookRepository.getAllByFilename(filename)
    : ebookRepository.getAll());
  res.status(200).json(data);
}

export async function uploadBook(req, res) {
  try {
    const { file } = req;
    const outputFilePath = `${req.outputFilePath}.png`; // convertPdf에서 저장한 이미지 경로를 참조
    const originalname = Buffer.from(file.originalname, "latin1").toString(
      "utf8"
    ); // 한글 파일명 처리

    if (!file || !outputFilePath) {
      return res.status(400).json({ message: "File or output path missing" });
    }

    const book = await ebookRepository.create(
      file.filename, // 파일 이름
      originalname, // 한글 파일명 처리
      outputFilePath, // 이미지 경로
      file.path, // PDF 파일 경로
      file.mimetype, // 파일 타입 (예: application/pdf)
      file.size, // 파일 크기
      req.userId // 업로드한 사용자 ID
    );

    res.status(201).json({ message: "File uploaded successfully", book });
  } catch (error) {
    console.error("File upload failed:", error);
    res
      .status(500)
      .json({ message: "File upload failed", error: error.message });
  }
}

import SQ from "sequelize";
import { sequelize } from "../db/database.js";
import { User } from "./auth.js";
import fs from "fs";

const DataTypes = SQ.DataTypes;
const Sequelize = SQ.Sequelize;

// model 정의
const Ebook = sequelize.define("ebook", {
  id: {
    type: DataTypes.INTEGER,
    autoIncrement: true,
    allowNull: false,
    primaryKey: true,
  },
  // ... (다른 필드들)
});

Ebook.belongsTo(User);

const INCLUDE_USER = {
  attributes: [
    "id",
    // ...,
    [Sequelize.col("user.name"), "name"],
    [Sequelize.col("user.username"), "username"],
  ],
  include: {
    model: User,
    attributes: [],
  },
};

const ORDER_DESC = { order: [["createdAt", "DESC"]] };

// 이미지 파일을 읽어서 Base64로 인코딩하는 함수
function encodeImageToBase64(filePath) {
  const image = fs.readFileSync(filePath);
  return Buffer.from(image).toString("base64");
}

export async function getAll() {
  const ebooks = await Ebook.findAll({
    ...INCLUDE_USER,
    ...ORDER_DESC,
  });

  // 각 Ebook의 thumbnail 경로를 Base64로 변환
  const ebooksWithBase64Thumbnail = ebooks.map((ebook) => {
    const base64Thumbnail = encodeImageToBase64(ebook.thumbnail);
    return {
      ...ebook.dataValues,
      thumbnail: base64Thumbnail,
    };
  });

  return ebooksWithBase64Thumbnail;
}

export async function create(
  filename,
  //  ...,
  userId
) {
  return Ebook.create({
    filename,
    // ...,
  }).then((data) => this.getById(data.dataValues.id));
}