ci: 2024-04-28 배포

backend/src/v1/notifications/notifications.service.ts

@@ -1,138 +1,24 @@
-import { executeQuery, makeExecuteQuery, pool } from '~/mysql';
+import { executeQuery } from '~/mysql';
 import { publishMessage } from '../slack/slack.service';
+import { handleReservationOverdueAndAssignReservationToNextWaitingUser } from '../reservations/reservations.service';
+import { logger } from '~/logger';
 
-const succeedReservation = async (reservation: { bookId: number; bookInfoId: number }) => {
-  const conn = await pool.getConnection();
-  const transactionExecuteQuery = makeExecuteQuery(conn);
+const sendSlackMessage = async (slack: string, message: string) => {
   try {
-    const candidates: {
-      id: number;
-      slack: string;
-      title: string;
-    }[] = await transactionExecuteQuery(
-      `
-    SELECT
-      reservation.id AS id,
-      user.slack AS slack,
-      book_info.title AS title
-    FROM
-      reservation
-    LEFT JOIN user ON
-      user.id = reservation.userId
-    LEFT JOIN book_info ON
-      book_info.id = reservation.bookInfoId
-    WHERE
-      reservation.status = 0 AND
-      reservation.bookInfoId = ?
-    ORDER BY
-      reservation.createdAt DESC
-    LIMIT 1
-    `,
-      [reservation.bookInfoId],
-    );
-    if (candidates.length !== 0) {
-      await transactionExecuteQuery(
-        `
-        UPDATE
-          reservation
-        SET
-          bookId = ?,
-          endAt = DATE_ADD(NOW(), INTERVAL 3 DAY)
-        WHERE
-          reservation.id = ?
-      `,
-        [reservation.bookId, candidates[0].id],
-      );
-      publishMessage(
-        candidates[0].slack,
-        `:jiphyeonjeon: 예약 알림 :jiphyeonjeon:\n예약하신 도서 \`${candidates[0].title}\`(이)가 대출 가능합니다. 3일 내로 집현전에 방문해 대출해주세요. (방문하시기 전에 비치 여부를 확인해주세요)`,
-      );
-    }
-  } catch (e) {
-    await conn.rollback();
-    if (e instanceof Error) {
-      throw e;
-    }
-  } finally {
-    conn.release();
+    await publishMessage(slack, message);
+  } catch (error) {
+    logger.error('[scheduler error(slack)]', error);
   }
 };
 
-export const notifyReservation = async () => {
-  const reservations: [
-    {
-      bookId: number;
-      bookInfoId: number;
-    },
-  ] = await executeQuery(`
-      SELECT
-        reservation.bookId AS bookId,
-        reservation.bookInfoId AS bookInfoId
-      FROM
-        reservation
-      WHERE
-        reservation.status = 3 AND
-        DATE(reservation.updatedAt) = CURDATE()
-    `);
-  reservations.forEach(async (reservation) => {
-    if (reservation.bookId) {
-      succeedReservation(reservation);
-    }
-  });
-};
-
-export const notifyReservationOverdue = async () => {
-  const reservations: {
-    slack: string;
-    title: string;
-    bookId: number;
-    bookInfoId: number;
-  }[] = await executeQuery(`
-    SELECT
-      user.slack AS slack,
-      book_info.title AS title,
-      reservation.bookId AS bookId,
-      reservation.bookInfoId AS bookInfoId
-    FROM
-      reservation
-    LEFT JOIN user ON
-      user.id = reservation.userId
-    LEFT JOIN book_info ON
-      book_info.id = reservation.bookInfoId
-    WHERE
-      reservation.status = 3 AND
-      DATEDIFF(CURDATE(), DATE(reservation.endAt)) = 1
-  `);
-  reservations.forEach(async (reservation) => {
-    publishMessage(
-      reservation.slack,
-      `:jiphyeonjeon: 예약 만료 알림 :jiphyeonjeon:\n예약하신 도서 \`${reservation.title}\`의 예약이 만료되었습니다.`,
-    );
-    const ranks: [{ id: number; createdAt: Date }] = await executeQuery(
-      `
-      SELECT
-        id,
-        createdAt
-      FROM
-        reservation
-      WHERE
-        bookInfoId = ? AND status = 0
-      ORDER BY createdAt ASC
-    `,
-      [reservation.bookInfoId],
-    );
-    await executeQuery(
-      `
-      UPDATE reservation
-      SET
-        bookId = ?,
-        endAt = ADDDATE(CURDATE(),1)
-      WHERE
-        id = ?
-    `,
-      [reservation.bookId, ranks[0].id],
-    );
-  });
+/**
+ * 만료된 예약을 처리하고, 다음 예약자에게 할당하고, 슬랙 메시지를 전송합니다.
+ * @throws 만료된 예약를 처리하고, 다음 예약자에게 할당하는 쿼리 과정에서 에러가 발생하면 에러를 던집니다. 슬랙 메시지 전송 실패시엔 로그만 남깁니다.
+ */
+export const notifyReservationOverdueAndNotifyReservation = async () => {
+  const { overDueReservations, assignedReservations } = await handleReservationOverdueAndAssignReservationToNextWaitingUser();
+  await Promise.allSettled(overDueReservations.map(({slack, title}) => sendSlackMessage(slack, `:jiphyeonjeon: 예약 만료 알림 :jiphyeonjeon:\n예약하신 도서 \`${title}\`의 예약이 만료되었습니다.`)));
+  await Promise.allSettled(assignedReservations.map((data) => sendSlackMessage(data!.slack, `:jiphyeonjeon: 예약 알림 :jiphyeonjeon:\n예약하신 도서 \`${data!.title}\`(이)가 대출 가능합니다. 3일 내로 집현전에 방문해 대출해주세요.`,)));
 };
 
 /**

backend/src/v1/reservations/reservations.service.ts

@@ -187,6 +187,128 @@ export const cancel = async (reservationId: number): Promise<void> => {
   }
 };
 
+type TransactionExecuteQueryType = (queryText: string, values?: any[]) => Promise<any>;
+
+/**
+ * 만료된 예약을 처리 후, 다음 예약자에게 예약을 할당하기 위한 예약 정보를 반환합니다.
+ * - 책이 할당 될때, status는 여전히 0이지만 endAt과 bookId가 null에서 각각 값이 할당됩니다.
+ * - 따라서 status가 0이면서 책이 할당 되어 bookId와 endAt을 가졌으면서 endAt이 현재 날짜보다 이전인 예약을 찾습니다.
+ * - status를 3을 부여하여 만료된 예약임을 표시합니다.
+ * @param transactionExecuteQuery 트랜잭션 처리를 위한 executeQuery
+ */
+const handleReservationOverdue = async (transactionExecuteQuery: TransactionExecuteQueryType) => {
+  const overDueReservations: {
+    slack: string;
+    title: string;
+    bookId: number;
+    bookInfoId: number;
+  }[] = await transactionExecuteQuery(`
+    SELECT
+      user.slack AS slack,
+      book_info.title AS title,
+      reservation.bookId AS bookId,
+      reservation.bookInfoId AS bookInfoId
+    FROM
+      reservation
+    LEFT JOIN user ON
+      user.id = reservation.userId
+    LEFT JOIN book_info ON
+      book_info.id = reservation.bookInfoId
+    WHERE
+      reservation.status = 0 AND
+      bookId IS NOT NULL AND
+      IFNULL(DATEDIFF(CURDATE(), DATE(reservation.endAt)), 0) >= 1;
+
+  `);
+  await transactionExecuteQuery(`
+    UPDATE
+      reservation
+    SET
+      reservation.status = 3
+    WHERE
+      reservation.id IN (
+        SELECT id
+          FROM (
+            SELECT
+              reservation.id
+            FROM
+              reservation
+            WHERE
+              reservation.status = 0 AND
+              reservation.bookId IS NOT NULL AND
+              IFNULL(DATEDIFF(CURDATE(), DATE(reservation.endAt)), 0) >= 1
+          ) AS expiredReservations
+      );
+  `);
+  return overDueReservations;
+}
+
+/**
+ * 예약 취소 시, 다음 예약자에게 예약을 할당합니다.
+ * - 아직 책을 할당 받지 못한 예약자는 status가 0이고, bookId와 endAt이 null입니다.
+ * - 따라서 해당 조건을 만족하면서 가장 먼저 예약한 예약자를 찾아 해당 예약자에게 책을 할당합니다.
+ * @param transactionExecuteQuery 트랜잭션 처리를 위한 executeQuery
+ * @param bookData 책 정보, title, bookId, bookInfoId를 가지고 있습니다. 해당 책은 반드시 예약가능한 상태여야 합니다.
+ * @returns 인자로 받은 transactionExecuteQuery를 이용한 함수를 반환합니다. 해당 함수를 이용해 쿼리를 실행하고, 쿼리 실행 결과를 반환합니다. 반환된 값은 결과를 슬랙 메시지로 안내시 사용가능합니다.
+ */
+const assignReservationToNextWaitingUser = (transactionExecuteQuery: TransactionExecuteQueryType) => async (bookData: {title: string, bookId: number, bookInfoId: number}) => {
+
+  const firstWaitingReservation: { id: number, slack: string }[] = await transactionExecuteQuery(
+    `
+    SELECT
+      reservation.id AS id,
+      user.slack AS slack
+    FROM
+      reservation
+    LEFT JOIN user ON
+      user.id = reservation.userId
+    WHERE
+      bookInfoId = ? AND status = 0 AND bookId IS NULL AND endAt IS NULL
+    ORDER BY
+      reservation.createdAt ASC
+    LIMIT 1
+    FOR UPDATE;
+  `,
+    [bookData.bookInfoId],
+  );
+  if (firstWaitingReservation.length > 0) {
+    await transactionExecuteQuery(
+      `
+      UPDATE reservation
+      SET
+        bookId = ?,
+        endAt = ADDDATE(CURDATE(), 3)
+      WHERE
+        id = ?;
+    `,
+      [bookData.bookId, firstWaitingReservation[0].id],
+    );
+    return { title: bookData.title, slack: firstWaitingReservation[0].slack };
+  }
+  return null;
+};
+
+/**
+ * 만료된 예약을 처리하고, 다음 예약자에게 할당하고, 슬랙 메시지 전송을 위한 정보를 반환합니다.
+ * @returns 각각 만료된 예약, 다음 예약자에게 할당된 예약 정보를 반환합니다. 해당 정보는 슬랙 메시지 전송을 위해 사용됩니다.
+ */
+export const handleReservationOverdueAndAssignReservationToNextWaitingUser = async() => {
+  const conn = await pool.getConnection();
+  const transactionExecuteQuery = makeExecuteQuery(conn);
+  await conn.beginTransaction();
+  try {
+    const overDueReservations = await handleReservationOverdue(transactionExecuteQuery);
+    const assignedReservations = await Promise.all(overDueReservations.map(assignReservationToNextWaitingUser(transactionExecuteQuery)));
+    await conn.commit();
+    return { overDueReservations, assignedReservations };
+  } catch (error) {
+    await conn.rollback();
+    throw error;
+  } finally {
+    await conn.release();
+  }
+}
+
 export const userCancel = async (userId: number, reservationId: number): Promise<void> => {
   const reservations = await executeQuery(
     `

backend/src/v1/utils/scheduler.ts

@@ -12,7 +12,6 @@ const midnightScheduler = () => {
   rule.tz = 'Asia/Seoul';
   schedule.scheduleJob(rule, async () => {
     await slack.updateSlackId();
-    await notifications.notifyReservationOverdue();
     await searchKeywords.renewLastPopular();
   });
 };
@@ -24,7 +23,8 @@ const morningScheduler = () => {
   rule.minute = 42;
   rule.tz = 'Asia/Seoul';
   schedule.scheduleJob(rule, async () => {
-    await notifications.notifyReservation();
+    await notifications.notifyReservationOverdueAndNotifyReservation();
+    await notifications.notifyReturningReminder();
     await notifications.notifyOverdueManager();
     await notifications.notifyOverdue();
   });

nginx/conf.d/default.conf

@@ -1,9 +1,15 @@
 server {
-    listen       80;
+    listen       443 ssl;
     server_name  42library.kr;
 
     #access_log  /var/log/nginx/host.access.log  main;
 
+    ssl_certificate /etc/letsencrypt/live/42library.kr/fullchain.pem; # managed by Cert>
+    ssl_certificate_key /etc/letsencrypt/live/42library.kr/privkey.pem; # managed by Ce>
+
+    include /etc/letsencrypt/options-ssl-nginx.conf; # managed by Certbot
+    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # managed by Certbot
+
     location /api/ {
         proxy_pass http://backend:3000;
     }
@@ -42,3 +48,13 @@ server {
         root   /usr/share/nginx/html;
     }
 }
+
+server {
+    if ($host = 42library.kr) {
+        return 301 https://$host$request_uri;
+    } # managed by Certbot
+
+    listen 80;
+    server_name 42library.kr;
+    return 404; # managed by Certbot
+}