Yasmine's branch

.gitignore

@@ -1,2 +1,2 @@
 node_modules
-.vscode
+.vscode

all the about

@@ -0,0 +1,147 @@
+const express = require('express');
+const mongoose = require('mongoose');
+const bodyParser = require('body-parser');
+const jwt = require('jsonwebtoken');
+const Subreddit = require('./models/subreddit');
+
+const app = express();
+app.use(bodyParser.json());
+
+// Connect to MongoDB
+mongoose.connect('mongodb://localhost:27017/myapp', { useNewUrlParser: true, useUnifiedTopology: true })
+  .then(() => console.log('MongoDB connected'))
+  .catch(err => console.error('MongoDB connection error:', err));
+
+async function authenticateUser(req, res, next) {
+  try {
+
+    const token = req.headers.authorization ? req.headers.authorization.split(' ')[1] : req.cookies.jwt;
+
+    if (!token) {
+      return res.status(401).json({ error: 'Unauthorized: No token provided' });
+    }
+
+    const decoded = jwt.verify(token, process.env.JWT_SECRET);
+
+    const user = await userModel.findById(decoded.userID);
+
+    if (!user) {
+      return res.status(401).json({ error: 'Unauthorized: User not found' });
+    }
+
+    req.user = user;
+
+    next();
+  } catch (error) {
+    console.error('Authentication error:', error);
+    return res.status(401).json({ error: 'Unauthorized: Invalid token' });
+  }
+}
+
+// Task: about/Where
+app.post('/about/where', authenticateUser, async (req, res) => {
+    try {
+
+      const location = req.user.location;
+      return res.status(200).json({ location });
+    } catch (error) {
+      console.error('Error:', error);
+      return res.status(500).json({ error: 'Internal server error' });
+    }
+  });
+
+  // Task: about/Banned
+  app.post('/about/banned', authenticateUser, async (req, res) => {
+    try {
+
+      const bannedUsers = await Ban.find();
+      return res.status(200).json({ bannedUsers });
+    } catch (error) {
+      console.error('Error:', error);
+      return res.status(500).json({ error: 'Internal server error' });
+    }
+  });
+
+  // Task: about/Muted
+  app.post('/about/muted', authenticateUser, async (req, res) => {
+    try {
+
+      const mutedUsers = await Mute.find();
+      return res.status(200).json({ mutedUsers });
+    } catch (error) {
+      console.error('Error:', error);
+      return res.status(500).json({ error: 'Internal server error' });
+    }
+  });
+
+  // Task: about/Moderators
+  app.post('/about/moderators', authenticateUser, async (req, res) => {
+    try {
+
+      const moderators = await Moderator.find({ subreddit: req.body.subredditId });
+      return res.status(200).json({ moderators });
+    } catch (error) {
+      console.error('Error:', error);
+      return res.status(500).json({ error: 'Internal server error' });
+    }
+  });
+
+  // Task: about/Location
+  app.post('/about/location', authenticateUser, async (req, res) => {
+    try {
+
+      const locationData = await Location.find({ coordinates: req.body.coordinates });
+      return res.status(200).json({ locationData });
+    } catch (error) {
+      console.error('Error:', error);
+      return res.status(500).json({ error: 'Internal server error' });
+    }
+  });
+
+  // Task: about/Reports
+  app.post('/about/reports', authenticateUser, async (req, res) => {
+    try {
+
+      const reports = await Report.find();
+      return res.status(200).json({ reports });
+    } catch (error) {
+      console.error('Error:', error);
+      return res.status(500).json({ error: 'Internal server error' });
+    }
+  });
+
+  // Task: about/Spam
+  app.post('/about/spam', authenticateUser, async (req, res) => {
+    try {
+
+      const spam = await Spam.find();
+      return res.status(200).json({ spam });
+    } catch (error) {
+      console.error('Error:', error);
+      return res.status(500).json({ error: 'Internal server error' });
+    }
+  });
+
+  // Task: about/Modqueue
+  app.post('/about/modqueue', authenticateUser, async (req, res) => {
+    try {
+
+      const modqueue = await Modqueue.find();
+      return res.status(200).json({ modqueue });
+    } catch (error) {
+      console.error('Error:', error);
+      return res.status(500).json({ error: 'Internal server error' });
+    }
+  });
+
+  // Task: about/Unmoderated
+  app.post('/about/unmoderated', authenticateUser, async (req, res) => {
+    try {
+
+      const unmoderated = await Unmoderated.find();
+      return res.status(200).json({ unmoderated });
+    } catch (error) {
+      console.error('Error:', error);
+      return res.status(500).json({ error: 'Internal server error' });
+    }
+  });

approve,remove,show_comment,leavemoderator,accept_moderator_invite

@@ -0,0 +1,108 @@
+const express = require('express');
+const mongoose = require('mongoose');
+const bodyParser = require('body-parser');
+const jwt = require('jsonwebtoken');
+const User = require('./models/user'); 
+const Item = require('./models/item'); 
+const Comment = require('./models/comment'); 
+const Moderator = require('./models/moderator'); 
+
+const app = express();
+app.use(bodyParser.json());
+
+// Connect to MongoDB
+mongoose.connect('mongodb://localhost:27017/myapp', { useNewUrlParser: true, useUnifiedTopology: true })
+  .then(() => console.log('MongoDB connected'))
+  .catch(err => console.error('MongoDB connection error:', err));
+
+async function authenticateUser(req, res, next) {
+  try {
+    const token = req.headers.authorization ? req.headers.authorization.split(' ')[1] : req.cookies.jwt;
+
+    if (!token) {
+      return res.status(401).json({ error: 'Unauthorized: No token provided' });
+    }
+
+    const decoded = jwt.verify(token, process.env.JWT_SECRET);
+    const user = await User.findById(decoded.userID); 
+
+    if (!user) {
+      return res.status(401).json({ error: 'Unauthorized: User not found' });
+    }
+
+    req.user = user;
+
+    next();
+  } catch (error) {
+    console.error('Authentication error:', error);
+    return res.status(401).json({ error: 'Unauthorized: Invalid token' });
+  }
+}
+
+// Task: approve
+app.put('/approve', authenticateUser, async (req, res) => {
+  try {
+    const { itemId } = req.body;
+
+    await Item.findByIdAndUpdate(itemId, { approved: true });
+    return res.status(200).json({ message: 'Approved successfully' });
+  } catch (error) {
+    console.error('Error approving:', error);
+    return res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+// Task: remove
+app.put('/remove', authenticateUser, async (req, res) => {
+  try {
+    const { itemId } = req.body;
+
+    await Item.findByIdAndDelete(itemId);
+    return res.status(200).json({ message: 'Removed successfully' });
+  } catch (error) {
+    console.error('Error removing:', error);
+    return res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+// Task: show_comment
+app.get('/show_comment', authenticateUser, async (req, res) => {
+  try {
+    const { commentId } = req.query;
+
+    const comment = await Comment.findById(commentId);
+    return res.status(200).json({ message: 'Comment shown successfully', comment });
+  } catch (error) {
+    console.error('Error showing comment:', error);
+    return res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+// Task: leavemoderator
+app.post('/leavemoderator', authenticateUser, async (req, res) => {
+  try {
+    const { subredditId } = req.body;
+
+    await Moderator.findOneAndRemove({ user: req.user._id, subreddit: subredditId });
+    return res.status(200).json({ message: 'Moderator left successfully' });
+  } catch (error) {
+    console.error('Error leaving moderator:', error);
+    return res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+// Task: accept_moderator_invite
+app.post('/accept_moderator_invite', authenticateUser, async (req, res) => {
+  try {
+    const { subredditId } = req.body;
+
+    const moderator = new Moderator({ user: req.user._id, subreddit: subredditId });
+    await moderator.save();
+    return res.status(200).json({ message: 'Moderator invitation accepted successfully' });
+  } catch (error) {
+    console.error('Error accepting moderator invitation:', error);
+    return res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+module.exports = app;

delete_sr_banner,delete_sr_icon,upload_sr_icon

@@ -0,0 +1,110 @@
+const express = require('express');
+const mongoose = require('mongoose');
+const bodyParser = require('body-parser');
+const jwt = require('jsonwebtoken');
+const Subreddit = require('./models/subreddit');
+
+const app = express();
+app.use(bodyParser.json());
+
+// Connect to MongoDB
+mongoose.connect('mongodb://localhost:27017/myapp', { useNewUrlParser: true, useUnifiedTopology: true })
+  .then(() => console.log('MongoDB connected'))
+  .catch(err => console.error('MongoDB connection error:', err));
+
+async function authenticateUser(req, res, next) {
+  try {
+
+    const token = req.headers.authorization ? req.headers.authorization.split(' ')[1] : req.cookies.jwt;
+
+    if (!token) {
+      return res.status(401).json({ error: 'Unauthorized: No token provided' });
+    }
+
+    const decoded = jwt.verify(token, process.env.JWT_SECRET);
+
+    const user = await userModel.findById(decoded.userID);
+
+    if (!user) {
+      return res.status(401).json({ error: 'Unauthorized: User not found' });
+    }
+
+    req.user = user;
+
+    next();
+  } catch (error) {
+    console.error('Authentication error:', error);
+    return res.status(401).json({ error: 'Unauthorized: Invalid token' });
+  }
+}
+
+// Task: delete_sr_banner
+app.delete('/delete_sr_banner', authenticateUser, async (req, res) => {
+  try {
+    const { subredditId } = req.body;
+    // Check if the request body contains required fields
+    if (!subredditId) {
+      return res.status(400).json({ error: 'Subreddit ID is required' });
+    }
+    // Find the subreddit by ID
+    const subreddit = await Subreddit.findById(subredditId);
+    if (!subreddit) {
+      return res.status(404).json({ error: 'Subreddit not found' });
+    }
+    // Delete the subreddit's banner
+    subreddit.banner = null;
+    await subreddit.save();
+    return res.status(200).json({ message: 'Subreddit banner deleted successfully' });
+  } catch (error) {
+    console.error('Error deleting subreddit banner:', error);
+    return res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+// Task: delete_sr_icon
+app.delete('/delete_sr_icon', authenticateUser, async (req, res) => {
+  try {
+    const { subredditId } = req.body;
+    // Check if the request body contains required fields
+    if (!subredditId) {
+      return res.status(400).json({ error: 'Subreddit ID is required' });
+    }
+    // Find the subreddit by ID
+    const subreddit = await Subreddit.findById(subredditId);
+    if (!subreddit) {
+      return res.status(404).json({ error: 'Subreddit not found' });
+    }
+    // Delete the subreddit's icon
+    subreddit.icon = null;
+    await subreddit.save();
+    return res.status(200).json({ message: 'Subreddit icon deleted successfully' });
+  } catch (error) {
+    console.error('Error deleting subreddit icon:', error);
+    return res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+// Task: upload_sr_icon
+app.post('/upload_sr_icon', authenticateUser, async (req, res) => {
+  try {
+    const { subredditId, icon } = req.body;
+    // Check if the request body contains required fields
+    if (!subredditId || !icon) {
+      return res.status(400).json({ error: 'Subreddit ID and icon data are required' });
+    }
+    // Find the subreddit by ID
+    const subreddit = await Subreddit.findById(subredditId);
+    if (!subreddit) {
+      return res.status(404).json({ error: 'Subreddit not found' });
+    }
+    // Update the subreddit's icon
+    subreddit.icon = icon;
+    await subreddit.save();
+    return res.status(200).json({ message: 'Subreddit icon uploaded successfully' });
+  } catch (error) {
+    console.error('Error uploading subreddit icon:', error);
+    return res.status(500).json({ error: 'Internal server error' });
+  }
+});
+
+module.exports = app;