Master

.gitignore

@@ -1,2 +1,5 @@
 .env
-node_modules/
+node_modules/
+DummyData/
+WorkSpace.code-workspace
+email-pass.txt

backend/.gitignore

@@ -0,0 +1,28 @@
+# Ignore node_modules directory
+node_modules/
+
+# Ignore environment-specific files
+.env
+.env.local
+.env.*.local
+
+# Ignore build artifacts
+build/
+dist/
+
+# Ignore logs
+logs/
+
+# Ignore dependency lock files
+package-lock.json
+yarn.lock
+
+# Ignore IDE and editor files
+.vscode/
+.idea/
+*.sublime-project
+*.sublime-workspace
+
+# Ignore system files
+.DS_Store
+Thumbs.db

backend/config/db.js

@@ -0,0 +1,17 @@
+import mongoose from "mongoose";
+
+const connectDB = async () => {
+  try {
+    const conn = await mongoose.connect(process.env.MONGO_URI, {
+      useNewUrlParser: true,
+      useUnifiedTopology: true,
+    });
+
+    console.log(`MongoDB connected`);
+  } catch (error) {
+    console.log(`Error: ${error.message}`);
+    process.exit(1);
+  }
+};
+
+export default connectDB;

backend/controllers/commentControllers.js

@@ -0,0 +1,136 @@
+import Comment from "../models/Comment";
+import Post from "../models/Post";
+
+const createComment = async (req, res, next) => {
+  try {
+    const { desc, slug, parent, replyOnUser } = req.body;
+
+    const post = await Post.findOne({ slug });
+
+    if (!post) {
+      const error = new Error("Post not found");
+      return next(error);
+    }
+
+    const newComment = new Comment({
+      user: req.user._id,
+      desc,
+      post: post._id,
+      parent,
+      replyOnUser,
+    });
+    const savedComment = await newComment.save();
+
+    return res.json(savedComment);
+  } catch (error) {
+    next(error);
+  }
+};
+
+const updateComment = async (req, res, next) => {
+  try {
+    const { desc, check } = req.body;
+
+    const comment = await Comment.findById(req.params.commentId);
+
+    if (!comment) {
+      const error = new Error("Comment not found");
+      return next(error);
+    }
+
+    comment.desc = desc || comment.desc;
+    comment.check = typeof check !== "undefined" ? check : comment.check;
+
+    const updatedComment = await comment.save();
+
+    return res.json(updatedComment);
+  } catch (error) {
+    next(error);
+  }
+};
+
+const deleteComment = async (req, res, next) => {
+  try {
+    const comment = await Comment.findByIdAndDelete(req.params.commentId);
+    await Comment.deleteMany({ parent: comment._id });
+
+    if (!comment) {
+      const error = new Error("Comment not found");
+      return next(error);
+    }
+
+    return res.json({ message: "Comment deleted successfully" });
+  } catch (error) {
+    next(error);
+  }
+};
+
+const getAllComments = async (req, res, next) => {
+  try {
+    const filter = req.query.searchKeyword;
+    const userId = req.query.userId;
+
+    let where = {};
+
+    if (userId) {
+      where.user = userId;
+    }
+
+    if (filter) {
+      where.desc = { $regex: filter, $options: "i" };
+    }
+
+    let query = Comment.find(where);
+    const page = parseInt(req.query.page) || 1;
+    const pageSize = parseInt(req.query.limit) || 10;
+    const skip = (page - 1) * pageSize;
+    const total = await Comment.find(where).countDocuments();
+    const pages = Math.ceil(total / pageSize);
+
+    res.header({
+      "x-filter": filter,
+      "x-totalcount": JSON.stringify(total),
+      "x-currentpage": JSON.stringify(page),
+      "x-pagesize": JSON.stringify(pageSize),
+      "x-totalpagecount": JSON.stringify(pages),
+    });
+
+    if (page > pages) {
+      return res.json([]);
+    }
+
+    const result = await query
+      .skip(skip)
+      .limit(pageSize)
+      .populate([
+        {
+          path: "user",
+          select: ["avatar", "name", "verified"],
+        },
+        {
+          path: "parent",
+          populate: [
+            {
+              path: "user",
+              select: ["avatar", "name"],
+            },
+          ],
+        },
+        {
+          path: "replyOnUser",
+          select: ["avatar", "name"],
+        },
+        {
+          path: "post",
+          select: ["slug", "title"],
+        },
+      ])
+      .sort({ updatedAt: "desc" });
+
+    return res.json(result);
+  } catch (error) {
+    next(error);
+  }
+};
+
+export { createComment, updateComment, deleteComment, getAllComments };

backend/controllers/mailControllers.js

@@ -0,0 +1,36 @@
+import nodemailer from "nodemailer";
+
+const transporter = nodemailer.createTransport({
+    service: "gmail",
+    port: 587,
+    secure: false, // Use `true` for port 465, `false` for all other ports
+    auth: {
+        user: process.env.ADMIN_EMAIL,
+        pass: process.env.ADMIN_EMAIL_PASSWORD,
+    },
+});
+
+const sendAdminRequestEmail = (req, res) => {
+    const { email, name } = req.body;
+    const mailOptions = {
+        from: {
+            name: "Social Multimedia",
+            address: process.env.ADMIN_EMAIL,
+        },
+        to: process.env.ADMIN_EMAIL,
+        subject: "Solicitud para ser administrador",
+        text: `Se ha recibido una solicitud para ser administrador de ${name}. Email: ${email}`,
+        html: `<h1>Solicitud para ser administrador</h1><p>Se ha recibido una solicitud para ser administrador de ${name}.</p><p>Email: ${email}</p>`,
+    };
+
+    transporter.sendMail(mailOptions, (error, info) => {
+        if (error) {
+            console.log(error);
+            res.status(500).json({ message: "Error sending email" });
+        } else {
+            res.status(200).json({ message: "Email succesfully sent" });
+        }
+    });
+};
+
+export { sendAdminRequestEmail };

backend/controllers/postCategoriesControllers.js

@@ -0,0 +1,161 @@
+import Post from "../models/Post";
+import PostCategories from "../models/PostCategories";
+
+const createPostCategory = async (req, res, next) => {
+  try {
+    const { title } = req.body;
+
+    const postCategory = await PostCategories.findOne({ title });
+
+    if (postCategory) {
+      const error = new Error("This category already exists");
+      return next(error);
+    }
+
+    const newPostCategory = new PostCategories({ title });
+
+    const savedPostCategory = await newPostCategory.save();
+
+    return res.status(201).json(savedPostCategory);
+  } catch (error) {
+    next(error);
+  }
+};
+
+const getSingleCategory = async (req, res, next) => {
+  try {
+    const postCategory = await PostCategories.findById(
+      req.params.postCategoryId
+    );
+
+    if (!postCategory) {
+      const error = new Error("Category not found");
+      return next(error);
+    }
+
+    return res.json(postCategory);
+  } catch (error) {
+    next(error);
+  }
+};
+
+const getAllPostCategories = async (req, res, next) => {
+  try {
+    const filter = req.query.search;
+    const userId = req.query.userId;
+
+    let where = {};
+
+    if (userId) {
+      where.user = userId;
+    }
+
+    if (filter) {
+      where.title = { $regex: filter, $options: "i" };
+    }
+
+    let query = PostCategories.find(where);
+    const page = parseInt(req.query.page) || 1;
+    const pageSize = parseInt(req.query.limit) || 10;
+    const skip = (page - 1) * pageSize;
+    const total = await PostCategories.find(where).countDocuments();
+    const pages = Math.ceil(total / pageSize);
+
+    res.header({
+      "x-filter": filter,
+      "x-totalcount": JSON.stringify(total),
+      "x-currentpage": JSON.stringify(page),
+      "x-pagesize": JSON.stringify(pageSize),
+      "x-totalpagecount": JSON.stringify(pages),
+    });
+
+    if (page > pages) {
+      return res.json([]);
+    }
+
+    const result = await query
+      .skip(skip)
+      .limit(pageSize)
+      .sort({ updatedAt: "desc" });
+
+    return res.json(result);
+  } catch (error) {
+    next(error);
+  }
+};
+
+const updatePostCategory = async (req, res, next) => {
+  try {
+    const { title } = req.body;
+
+    const postCategory = await PostCategories.findByIdAndUpdate(
+      req.params.postCategoryId,
+      { title: title },
+      { new: true }
+    );
+
+    if (!postCategory) {
+      const error = new Error("This category does not exist");
+      return next(error);
+    }
+
+    return res.json(postCategory);
+  } catch (error) {
+    next(error);
+  }
+};
+
+const deletePostCategory = async (req, res, next) => {
+  try {
+    const categoryId = req.params.postCategoryId;
+
+    await Post.updateMany(
+      { categories: { $in: [categoryId] } },
+      { $pull: { categories: categoryId } }
+    );
+
+    await PostCategories.deleteOne({ _id: categoryId });
+
+    res.send({
+      message: "Post category deleted successfully!",
+    });
+  } catch (error) {
+    next(error);
+  }
+};
+
+const getPopularCategories = async (req, res, next) => {
+  try {
+    const categories = await PostCategories.aggregate([
+      {
+        $lookup: {
+          from: "posts",
+          localField: "_id",
+          foreignField: "categories",
+          as: "posts",
+        },
+      },
+      {
+        $project: {
+          title: 1,
+          count: { $size: "$posts" },
+        },
+      },
+      { $sort: { count: -1 } },
+      { $limit: 5 },
+    ]);
+
+    return res.json(categories);
+  } catch (error) {
+    next(error);
+  }
+}
+
+export {
+  createPostCategory,
+  getAllPostCategories,
+  updatePostCategory,
+  deletePostCategory,
+  getSingleCategory,
+  getPopularCategories,
+};