feat: Add Calander and Event (#2)

* - Timetable 생성 api
- Timetable 수정 api
- Timetable 삭제 api
- 현재 사용자가 볼 수 있는 Timetable GET api
- Event 생성 api
- ics파일 import api
- Event 수정 api
- Event 삭제 api
- 현재 사용자가 볼 수 있는 Event 목록 GET api
    - 반복 Event 전개 후 표시
    - 날짜 필터링 넣기

* feat: ics export

* feat: activity timetable add visibility

* fix: reorganize API endpoints

* fix: clean up

* fix: event repeat fix

* fix: apply eslint, change to dayjs, move create event

Author: Choi-Eunseok

backend/package.json

@@ -11,7 +11,9 @@
     "@elysiajs/jwt": "^1.2.0",
     "@elysiajs/swagger": "^1.2.2",
     "elysia": "^1.2.0",
-    "mongoose": "^8.13.1"
+    "ics": "^3.8.1",
+    "mongoose": "^8.13.1",
+    "node-ical": "^0.20.1"
   },
   "devDependencies": {
     "bun-types": "latest"

backend/src/guards/eventAuthorityService.ts

@@ -0,0 +1,64 @@
+import { Elysia } from "elysia";
+
+import ActivityModel from "@back/models/activity";
+import JoinedActivityModel, { permissionList } from "@back/models/joined_activity";
+import TimetableModel from "@back/models/timetable";
+import exit, { errorElysia } from "@back/utils/error";
+
+import getEvent from "./getEvent";
+import getUser from "./getUser";
+
+const eventAuthorityService = () =>
+  new Elysia()
+    .use(getUser)
+    .use(getEvent)
+    .use(ActivityModel)
+    .use(JoinedActivityModel)
+    .use(TimetableModel)
+    .guard({
+      response: {
+        ...errorElysia(["UNAUTHORIZED"])
+      }
+    })
+    .resolve(async ({
+      event,
+      user,
+      activityModel,
+      joinedActivityModel,
+      timetableModel,
+      error
+    }) => {
+      const userId = user._id.toString();
+
+      const timetable = await timetableModel.db.findById(event.timetable_id);
+      if (!timetable) return exit(error, "UNAUTHORIZED");
+
+      const ownerType = timetable.owner_type;
+      const ownerId = timetable.owner?.toString();
+
+      if ((ownerType === "user" || ownerType === "global") && ownerId === userId) {
+        return;
+      }
+
+      if (ownerType === "activity") {
+        const activity = await activityModel.db.findById(ownerId);
+        if (!activity) return exit(error, "UNAUTHORIZED");
+
+        const permissionIndex = permissionList.indexOf("vice_president");
+        const allowedPermissions = permissionList.slice(0, permissionIndex + 1);
+
+        const joined = await joinedActivityModel.db.findOne({
+          activity_id: ownerId,
+          user_id: userId,
+          permission: { $in: allowedPermissions },
+        });
+
+        if (!joined) return exit(error, "UNAUTHORIZED");
+        return;
+      }
+
+      return exit(error, "UNAUTHORIZED");
+    })
+    .as("plugin");
+
+export default eventAuthorityService;

backend/src/guards/getEvent.ts

@@ -0,0 +1,38 @@
+import Elysia, { t } from "elysia";
+
+import EventModel, { IEvent } from "@back/models/event";
+import exit, { errorElysia } from "@back/utils/error";
+
+const getEvent = new Elysia()
+  .use(EventModel)
+  .guard({
+    params: t.Object({
+      event_id: t.String({
+        description: "이벤트 ID",
+      }),
+    }),
+    response: {
+      ...errorElysia(["NO_EVENT_ID", "NO_EVENT", "INVALID_ID_TYPE"]),
+    },
+  })
+  .resolve(async ({
+    params,
+    error,
+    eventModel,
+  }): Promise<{ event: IEvent }> => {
+    try {
+      const { event_id } = params;
+
+      if (!event_id) return exit(error, "NO_EVENT_ID");
+      const found = await eventModel.db.findById(event_id);
+      
+      if (!found) return exit(error, "NO_EVENT");
+
+      return { event: found.toObject() };
+    } catch {
+      return exit(error, "INVALID_ID_TYPE");
+    }
+  })
+  .as("plugin");
+
+export default getEvent;

backend/src/guards/getTimetable.ts

@@ -0,0 +1,38 @@
+import Elysia, { t } from "elysia";
+
+import TimetableModel, { ITimetable } from "@back/models/timetable";
+import exit, { errorElysia } from "@back/utils/error";
+
+const getTimetable = new Elysia()
+  .use(TimetableModel)
+  .guard({
+    params: t.Object({
+      timetable_id: t.String({
+        description: "캘린더 ID",
+      }),
+    }),
+    response: {
+      ...errorElysia(["NO_TIMETABLE_ID", "NO_TIMETABLE", "INVALID_ID_TYPE"]),
+    },
+  })
+  .resolve(async ({
+    params,
+    error,
+    timetableModel,
+  }): Promise<{ timetable: ITimetable }> => {
+    try {
+      const { timetable_id } = params;
+
+      if (!timetable_id) return exit(error, "NO_TIMETABLE_ID");
+      const found = await timetableModel.db.findById(timetable_id);
+      
+      if (!found) return exit(error, "NO_TIMETABLE");
+
+      return { timetable: found.toObject() };
+    } catch {
+      return exit(error, "INVALID_ID_TYPE");
+    }
+  })
+  .as("plugin");
+
+export default getTimetable;

backend/src/guards/timetableAuthorityService.ts

@@ -0,0 +1,64 @@
+import { Elysia } from "elysia";
+
+import ActivityModel from "@back/models/activity";
+import JoinedActivityModel, { permissionList } from "@back/models/joined_activity";
+import TimetableModel from "@back/models/timetable";
+import exit, { errorElysia } from "@back/utils/error";
+
+import getUser from "./getUser";
+
+const timetableAuthorityService = () =>
+  new Elysia()
+    .use(getUser)
+    .use(ActivityModel)
+    .use(JoinedActivityModel)
+    .use(TimetableModel)
+    .guard({
+      response: {
+        ...errorElysia(["UNAUTHORIZED"]),
+      },
+    })
+    .resolve(async ({ user, error, body, query, params, timetableModel, activityModel, joinedActivityModel }) => {
+      type RequestInput = { timetable_id?: string };
+
+      const timetableId =
+        (body as RequestInput)?.timetable_id ??
+        (query as RequestInput)?.timetable_id ??
+        (params as RequestInput)?.timetable_id;
+
+
+      if (!timetableId) return exit(error, "UNAUTHORIZED");
+
+      const timetable = await timetableModel.db.findById(timetableId);
+      if (!timetable) return exit(error, "UNAUTHORIZED");
+
+      const ownerType = timetable.owner_type;
+      const ownerId = timetable.owner?.toString();
+      const userId = user._id.toString();
+
+      if ((ownerType === "user" || ownerType === "global") && ownerId === userId) {
+        return;
+      }
+
+      if (ownerType === "activity") {
+        const activity = await activityModel.db.findById(timetable.owner);
+        if (!activity) return exit(error, "UNAUTHORIZED");
+
+        const permissionIndex = permissionList.indexOf("vice_president");
+        const allowedPermissions = permissionList.slice(0, permissionIndex + 1);
+
+        const joined = await joinedActivityModel.db.findOne({
+          activity_id: timetable.owner,
+          user_id: user._id,
+          permission: { $in: allowedPermissions },
+        });
+
+        if (!joined) return exit(error, "UNAUTHORIZED");
+        return;
+      }
+
+      return exit(error, "UNAUTHORIZED");
+    })
+    .as("plugin");
+
+export default timetableAuthorityService;

backend/src/index.ts

@@ -50,6 +50,14 @@ if (Bun.env.NODE_ENV === "development") {
         {
           name: "Activity",
           description: "활동(동아리)에 관련된 API입니다.",
+        },
+        {
+          name: "Timetable",
+          description: "캘린더(시간표)에 관련된 API입니다.",
+        },
+        {
+          name: "Event",
+          description: "이벤트에 관련된 API입니다.",
         }
       ]
     }

backend/src/models/event.ts

@@ -0,0 +1,76 @@
+import dayjs from "dayjs";
+import Elysia, { t } from "elysia";
+import mongoose, { ObjectId } from "mongoose";
+
+import { IDocument } from "@common/types/db";
+
+export const weekdayList = ["SU", "MO", "TU", "WE", "TH", "FR", "SA"] as const;
+
+interface DEvent {
+  timetable_id: ObjectId;
+  title?: string;
+  startTime: string;
+  endTime: string;
+  isAllDay?: boolean;
+
+  repeat?: {
+    frequency: "daily" | "weekly" | "monthly" | null;
+    interval?: number;
+    byWeekDay?: string[];
+    bySetPosition?: number;
+    byMonthDay?: number;
+    until?: string;
+  };
+}
+export type IEvent = IDocument<DEvent>;
+
+export const eventElysiaSchema = t.Object({
+  title: t.String({ example: "회의" }),
+  startTime: t.String({ example: "2025-04-05 10:00:00 " }),
+  endTime: t.String({ example: "2025-04-05 11:00:00" }),
+  isAllDay: t.Optional(t.Boolean({ example: false })),
+  repeat: t.Optional(
+    t.Object({
+      frequency: t.Enum(
+        { daily: "daily", weekly: "weekly", monthly: "monthly", none: "none" },
+        { example: "weekly", description: "\"none\"이면 반복 없음" }
+      ),
+      interval: t.Optional(t.Number({ minimum: 1, default: 1, example: 1, description: "daily 사용시 유효, ex. 이틀에 한번 = 2" })),
+      byWeekDay: t.Optional(t.Array(t.String({ examples: weekdayList, description: "반복할 요일들" }), { example: ["MO", "WE"] })),
+      bySetPosition: t.Optional(t.Number({ example: 2, description: "monthly 사용시 유효, ex. 매월 2번째 화요일 = 2" })),
+      byMonthDay: t.Optional(t.Number({ example: 1, description: "monthly 사용시 유효, byWeekDay bySetPosition 속성은 무시됨 , ex. 매월 1일 = 1" })),
+      until: t.Optional(t.String({ example: "2025-06-30 23:59:59" }))
+    })
+  )
+});
+
+const eventSchema = new mongoose.Schema<IEvent>({
+  timetable_id: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: "Timetable",
+    required: true,
+  },
+  title: String,
+  startTime: { type: String, default: dayjs().format("YYYY-MM-DD HH:mm:ss"), required: true },
+  endTime: { type: String, default: dayjs().format("YYYY-MM-DD HH:mm:ss"), required: true },
+  isAllDay: Boolean,
+
+  repeat: {
+    frequency: { type: String, enum: ["daily", "weekly", "monthly"], default: null },
+    interval: { type: Number, default: 1 },
+    byWeekDay: [String],
+    bySetPosition: Number,
+    byMonthDay: Number,
+    until: { type: String, default: dayjs().format("YYYY-MM-DD HH:mm:ss") }
+  },
+});
+
+eventSchema.index({ timetable_id: 1, startTime: 1, endTime: 1 });
+
+const EventDB = mongoose.model<IEvent>("Event", eventSchema);
+
+const EventModel = new Elysia().decorate("eventModel", {
+  db: EventDB,
+});
+
+export default EventModel;