Merge pull request #81 from 9roomMoa/feat-23

swoo0514 · web-flow · commit bf000904a685 · 2025-03-31T02:13:27.000+09:00
Feat 23
diff --git a/src/controllers/noti-controller.js b/src/controllers/noti-controller.js
@@ -0,0 +1,28 @@
+const { StatusCodes } = require('http-status-codes');
+const notiService = require('../services/noti-service');
+
+exports.getNotifications = async (req, res) => {
+  try {
+    const userId = req.user?.sub;
+
+    if (!userId) {
+      return res.status(StatusCodes.BAD_REQUEST).json({
+        success: false,
+        message: 'User ID Omission',
+      });
+    }
+
+    const notifications = await notiService.getNotifications(userId);
+
+    return res.status(StatusCodes.OK).json({
+      data: notifications,
+      success: true,
+      meessage: 'Notifications retrieved successfully',
+    });
+  } catch (err) {
+    return res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
+      success: false,
+      message: 'Internal server error: ' + err.message,
+    });
+  }
+};
diff --git a/src/models/Notification.js b/src/models/Notification.js
@@ -0,0 +1,49 @@
+const { required } = require('joi');
+const mongoose = require('mongoose');
+
+const NotificationSchema = mongoose.Schema(
+  {
+    message: { type: String, required: true },
+    sender: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'User',
+      default: null,
+    },
+    receiver: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'User',
+      required: true,
+    },
+    noticeType: {
+      type: String,
+      enum: [
+        'task_assigned',
+        'task_updated',
+        'task_deadline',
+        'comment_added',
+        'document_uploaded',
+      ],
+    },
+    relatedTask: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'Task',
+      default: null,
+    },
+    relatedComment: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'Comment',
+      default: null,
+    },
+    relatedDocument: {
+      type: mongoose.Schema.Types.ObjectId,
+      default: null,
+    },
+    isRead: {
+      type: Boolean,
+      default: false,
+    },
+  },
+  { timestamps: true }
+);
+
+module.exports = mongoose.model('Notification', NotificationSchema);
diff --git a/src/routes/project-route.js b/src/routes/project-route.js
@@ -3,6 +3,7 @@ const router = express.Router();
 const projectController = require('../controllers/project-controller');
 const userController = require('../controllers/user-controller');
 const authMiddleware = require('../middlewares/verify-token');
+const notiController = require('../controllers/noti-controller');
 
 router.post('/', authMiddleware.verifyToken, projectController.createProject);
 
@@ -18,4 +19,10 @@ router.get(
   userController.getUserInfoByKeyword
 );
 
+router.get(
+  '/:pid/notifications',
+  authMiddleware.verifyToken,
+  notiController.getNotifications
+);
+
 module.exports = router;
diff --git a/src/services/comment-service.js b/src/services/comment-service.js
@@ -2,6 +2,8 @@ const Task = require('../models/Task');
 const User = require('../models/User');
 const Comment = require('../models/Comment');
 const taskUtil = require('../utils/task-util');
+const User = require('../models/User');
+const Notification = require('../models/Notification');
 
 exports.searchComments = async (keyword, taskId, userId) => {
   try {
@@ -51,6 +53,23 @@ exports.createComment = async (commentData) => {
     const comment = new Comment(commentData);
     await comment.save();
 
+    const user = await User.findById(commentData.commenterId);
+    const tasks = await Task.findById(commentData.taskId).select('assignedTo');
+
+    const notifications = tasks.assignedTo
+      .filter((uid) => uid.toString() !== commentData.commenterId.toString())
+      .map((uid) => ({
+        message: `${user.name}님께서 코멘트를 남기셨습니다.`,
+        receiver: uid,
+        sender: commentData.commenterId,
+        noticeType: 'comment_added',
+        relatedComment: comment._id,
+      }));
+
+    if (notifications.length > 0) {
+      await Notification.insertMany(notifications);
+    }
+
     return comment;
   } catch (err) {
     console.error(err);
diff --git a/src/services/docs-service.js b/src/services/docs-service.js
@@ -3,6 +3,7 @@ const { GridFSBucket } = require('mongodb');
 // const { ObjectId } = require('bson');
 const taskUtil = require('../utils/task-util');
 const Task = require('../models/Task');
+const Notification = require('../models/Notification');
 
 let bucket;
 
@@ -37,12 +38,38 @@ exports.postDocument = async (file, taskId, userId) => {
 
         uploadStream.end(file.buffer);
 
-        uploadStream.on('finish', () => {
-          resolve({
-            success: true,
-            message: 'Document uploaded successfully',
-            fileId: uploadStream.id,
-          });
+        uploadStream.on('finish', async () => {
+          try {
+            const task = await Task.findById(taskId).select('assignedTo title');
+
+            const notifications = task.assignedTo
+              .filter((uid) => uid.toString() !== userId.toString())
+              .map((uid) => ({
+                message: `[${task.title}] 업무에 ${file.originalname} 문서가 업로드 되었습니다.`,
+                receiver: uid,
+                sender: userId,
+                noticeType: 'document_uploaded',
+                relatedTask: taskId,
+                relatedDocument: uploadStream.id,
+              }));
+
+            if (notifications.length > 0) {
+              await Notification.insertMany(notifications);
+            }
+
+            resolve({
+              success: true,
+              message: 'Document uploaded successfully',
+              fileId: uploadStream.id,
+            });
+          } catch (err) {
+            console.error(err.message);
+            resolve({
+              success: true,
+              message: 'Document uploaded, but failed to notify users',
+              fileId: uploadStream.id,
+            });
+          }
         });
 
         uploadStream.on('error', (err) => {
diff --git a/src/services/noti-service.js b/src/services/noti-service.js
@@ -0,0 +1,18 @@
+const taskUtil = require('../utils/task-util');
+
+exports.getNotifications = async (userId) => {
+  try {
+    const [notifications, unreadCount] = Promise.all([
+      await Notification.find({ receiver: userId }).sort({ createdAt: -1 }),
+      await Notification.countDocuments({ isRead: false, receiver: userId }),
+    ]);
+
+    return {
+      notifications,
+      unreadCount,
+    };
+  } catch (err) {
+    console.error(err);
+    throw err;
+  }
+};
diff --git a/src/services/task-service.js b/src/services/task-service.js
@@ -1,6 +1,7 @@
 const Project = require('../models/Project');
 const Task = require('../models/Task');
 const User = require('../models/User');
+const Notification = require('../models/Notification');
 const taskUtil = require('../utils/task-util');
 
 exports.createTask = async (taskData, userId) => {
@@ -19,6 +20,21 @@ exports.createTask = async (taskData, userId) => {
     const task = new Task({ ...taskData, createdBy: userId });
     await task.save();
 
+    if (Array.isArray(task.assignedTo) && task.assignedTo.length > 0) {
+      const notifications = task.assignedTo
+        .filter((uid) => uid.toString() !== userId.toString())
+        .map((uid) => ({
+          message: `${task.title} 업무가 할당되었습니다.`,
+          receiver: uid,
+          sender: userId,
+          noticeType: 'task_assigned',
+          relatedTask: task._id,
+        }));
+
+      if (notifications.length > 0)
+        await Notification.insertMany(notifications);
+    }
+
     return task;
   } catch (err) {
     console.error(err);
@@ -94,15 +110,31 @@ exports.updateTaskInfo = async (taskData, taskId, userId) => {
       throw new Error('date data are invalidate');
     }
 
-    const result = await Task.findByIdAndUpdate(
+    const task = await Task.findByIdAndUpdate(
       taskId,
       {
         $set: taskData,
       },
       { new: true, runValidators: true }
     );
 
-    return result;
+    if (Array.isArray(task.assignedTo) && task.assignedTo.length > 0) {
+      const notifications = task.assignedTo
+        .filter((uid) => uid.toString !== userId.toString)
+        .map((uid) => ({
+          message: `${task.title} 업무가 업데이트 되었습니다.`,
+          receiver: uid,
+          sender: userId,
+          noticeType: 'task_updated',
+          relatedTask: task._id,
+        }));
+
+      if (notifications.length > 0) {
+        await Notification.insertMany(notifications);
+      }
+    }
+
+    return task;
   } catch (err) {
     console.error(err);
     throw new Error('Error occured during updating task');
@@ -171,14 +203,31 @@ exports.addManagers = async (taskId, userId, managerId) => {
     }
     await taskUtil.isExistingResource(User, managerId);
 
-    const updatedTask = Task.findByIdAndUpdate(
+    const alreadyAssigned = task.assignedTo.map((uid) => uid.toString());
+
+    const updatedTask = await Task.findByIdAndUpdate(
       taskId,
       {
         $addToSet: { assignedTo: managerId },
       },
       { new: true }
     );
 
+    if (
+      !alreadyAssigned.includes(managerId.toString()) &&
+      updatedTask.assignedTo.length > 0
+    ) {
+      const notification = {
+        message: `${updatedTask.title} 업무가 할당되었습니다.`,
+        receiver: managerId,
+        sender: userId,
+        noticeType: 'task_assigned',
+        relatedTask: updatedTask._id,
+      };
+
+      await Notification.create(notification);
+    }
+
     return updatedTask;
   } catch (err) {
     console.error(err);
diff --git a/src/validation/notification-validation.js b/src/validation/notification-validation.js
@@ -0,0 +1,20 @@
+const Joi = require('joi');
+
+exports.creatingNotificationSchema = Joi.object({
+  message: Joi.string().required(),
+  sender: Joi.string().required(),
+  receiver: Joi.string().required(),
+  noticeType: Joi.string().valid([
+    'task_assigned',
+    'task_updated',
+    'task_deadline',
+    'comment_added',
+    'document_uploaded',
+    'project_added',
+  ]),
+  relatedTask: Joi.string().optional(),
+  relatedComment: Joi.string().optional(),
+  relatedComment: Joi.string().optional(),
+  relatedDocument: Joi.string().optional(),
+  isRead: Joi.string().required(),
+});
diff --git a/src/validation/task-validation.js b/src/validation/task-validation.js
@@ -7,20 +7,20 @@ exports.creatingSchema = Joi.object({
   status: Joi.string()
     .valid('To Do', 'In Progress', 'Done', 'Issue', 'Hold')
     .default('To Do'),
-  priority: Joi.number().integer().min(0).max(4).default(0),
+  priority: Joi.number().integer().min(1).max(5).default(1),
   project: Joi.string().required(), // 프로젝트 ID
   assignedTo: Joi.array().items(Joi.string()).optional(), // 사용자 ID
   // createdBy: Joi.string().required(), // 생성자 ID
   projectScope: Joi.string().valid('Public', 'Restricted').default('Public'),
   startDate: Joi.date(),
   dueDate: Joi.date(),
-  isDaily: Joi.boolean().default('false'),
+  isDaily: Joi.boolean().default(false),
 });
 
 //상태, 공개여부, 일정, 우선선위
 exports.updatingSchema = Joi.object({
   status: Joi.string()
-    .valid('To Do', 'In Progress', 'Done', 'Issue')
+    .valid('To Do', 'In Progress', 'Done', 'Issue', 'Hold')
     .optional(),
   priority: Joi.number().integer().min(1).max(5).optional(),
   startDate: Joi.date().optional(),
