Initial project submission.

Author: Azaldin Freidoon

config/database.js

@@ -0,0 +1,25 @@
+require('dotenv').config();
+
+// config/database.js
+const { Sequelize } = require('sequelize');
+
+const sequelize = new Sequelize(process.env.DB_NAME, process.env.DB_USER, process.env.DB_PASSWORD, {
+  host: process.env.DB_HOST,
+  port: process.env.DB_PORT,
+  dialect: 'postgres',
+  logging: false
+});
+
+// Test the connection
+async function testConnection() {
+  try {
+    await sequelize.authenticate();
+    console.log('Database connection has been established successfully.');
+  } catch (error) {
+    console.error('Unable to connect to the database:', error);
+  }
+}
+
+testConnection();
+
+module.exports = sequelize;

controllers/authController.js

@@ -0,0 +1,73 @@
+const bcrypt = require('bcrypt');
+const jwt = require('jsonwebtoken');
+const { User } = require('../models');
+
+exports.register = async (req, res) => {
+  try {
+    const { username, email, password } = req.body;
+    
+    if (!username || !email) {
+      return res.status(400).json({ error: 'Username and email are required!' });
+    }
+
+    const user = await User.create({
+      username,
+      email,
+      password
+    });
+
+    // Remove sensitive data from response
+    const userResponse = {
+      user_id: user.user_id,
+      username: user.username,
+      email: user.email,
+      created_at: user.created_at,
+      status: user.status
+    };
+
+    res.status(201).json(userResponse);
+  } catch (error) {
+    if (error.name === 'SequelizeValidationError' || error.name === 'SequelizeUniqueConstraintError') {
+      return res.status(400).json({ error: error.errors[0].message });
+    }
+    res.status(400).json({ error: error.message });
+  }
+};
+
+exports.login = async (req, res) => {
+  try {
+    const { username, email, password } = req.body;
+    
+    let user;
+    if (username) {
+      user = await User.findOne({ where: { username } });
+    } else if (email) {
+      user = await User.findOne({ where: { email } });
+    } else {
+      return res.status(401).json({ error: 'Invalid credentials' });
+    }
+
+    if (!user) {
+      return res.status(401).json({ error: 'Invalid credentials' });
+    }
+
+    user.password = password;
+    const isValid = await user.validatePassword(password);
+    if (!isValid) {
+      return res.status(401).json({ error: 'Invalid credentials' });
+    }
+
+    const token = jwt.sign({ userId: user.user_id }, process.env.JWT_SECRET, { expiresIn: '1d' });
+    
+    res.json({ 
+      user: {
+        user_id: user.user_id,
+        username: user.username,
+        email: user.email
+      },
+      token: token
+    });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+};

controllers/channelController.js

@@ -0,0 +1,127 @@
+const { Channel, UserChannel, ChannelInvitation, User } = require('../models');
+
+exports.createChannel = async (req, res) => {
+  try {
+    const { channelName, isPrivate } = req.body;
+    const channel = await Channel.create({ channel_name: channelName, is_private: isPrivate });
+    await UserChannel.create({ user_id: req.userData.userId, channel_id: channel.channel_id });
+    res.status(201).json(channel);
+  } catch (error) {
+    res.status(500).json({ message: 'Error creating channel', error: error.message });
+  }
+};
+
+exports.getChannels = async (req, res) => {
+  try {
+    const channels = await Channel.findAll({
+      include: [
+        {
+          model: User,
+          where: { user_id: req.userData.userId },
+          attributes: [],
+          through: { attributes: [] },
+        },
+      ],
+    });
+    res.json(channels);
+  } catch (error) {
+    res.status(500).json({ message: 'Error fetching channels', error: error.message });
+  }
+};
+
+exports.getInvitations = async (req, res) => {
+  try {
+    const invitations = await ChannelInvitation.findAll({ where: { invitee_id: req.userData.userId } });
+    res.json(invitations);
+  } catch (error) {
+    res.status(500).json({ message: 'Error fetching invitations', error: error.message });
+  }
+};
+
+exports.inviteToChannel = async (req, res) => {
+  try {
+    const { channelId, inviteeId } = req.body;
+    const userId = req.userData.userId;
+
+    // Check if user is inviting themselves
+    if (userId === inviteeId) {
+      return res.status(400).json({ message: 'Cannot invite yourself to a channel' });
+    }
+
+    // Check if invitee exists
+    const invitee = await User.findByPk(inviteeId);
+    if (!invitee) {
+      return res.status(404).json({ message: 'Invitee not found' });
+    }
+
+    // Check if user is a member of the channel
+    const userChannel = await UserChannel.findOne({
+      where: { 
+        channel_id: channelId,
+        user_id: userId
+      }
+    });
+
+    if (!userChannel) {
+      return res.status(403).json({ message: 'You must be a member of the channel to invite others' });
+    }
+
+    const inviteeChannel = await UserChannel.findOne({
+      where: {
+        channel_id: channelId,
+        user_id: inviteeId
+      }
+    });
+
+    if (inviteeChannel) {
+      return res.status(400).json({ message: 'Invitee is already a member of the channel' });
+    }
+
+    await ChannelInvitation.create({
+      channel_id: channelId,
+      inviter_id: req.userData.userId,
+      invitee_id: inviteeId,
+    });
+
+    await userChannel.update({ is_private: false });
+    res.status(201).json({ message: 'Invitation sent successfully' });
+  } catch (error) {
+    res.status(500).json({ message: 'Error sending invitation', error: error.message });
+  }
+};
+
+exports.acceptInvitation = async (req, res) => {
+  try {
+    const { invitationId } = req.body;
+
+    // Check if invitationId is provided
+    if (!invitationId) {
+      return res.status(400).json({ message: 'Invitation ID is required' });
+    }
+
+    const invitation = await ChannelInvitation.findByPk(invitationId);
+    if (!invitation || invitation.invitee_id !== req.userData.userId) {
+      return res.status(403).json({ message: 'Invalid invitation' });
+    }
+
+    // Mark invitation as accepted
+    await invitation.update({ accepted: true });
+
+    // Check if user already member of channel
+    const userChannel = await UserChannel.findOne({
+      where: {
+        user_id: req.userData.userId,
+        channel_id: invitation.channel_id
+      }
+    });
+
+    if (userChannel) {
+      return res.json({ message: 'Invitation accepted successfully' });
+    }
+
+    await UserChannel.create({ user_id: req.userData.userId, channel_id: invitation.channel_id });
+    res.json({ message: 'Invitation accepted successfully' });
+  } catch (error) {
+    res.status(500).json({ message: 'Error accepting invitation', error: error.message });
+  }
+};

controllers/fileController.js

@@ -0,0 +1,73 @@
+const { File, SearchIndexFile, Message } = require('../models');
+const { Op, Sequelize } = require('sequelize');
+
+exports.uploadFile = async (req, res) => {
+  try {
+    const { messageId, fileName, filePath, fileType } = req.body;
+    const file = await File.create({
+      message_id: messageId,
+      file_name: fileName,
+      file_path: filePath,
+      file_type: fileType,
+    });
+    // Index file for search
+    const terms = fileName.toLowerCase().split(/\W+/);
+    await Promise.all(terms.map(term => 
+      SearchIndexFile.create({ file_id: file.file_id, term })
+    ));
+    res.status(201).json(file);
+  } catch (error) {
+    res.status(500).json({ message: 'Error uploading file', error: error.message });
+  }
+};
+
+exports.searchFiles = async (req, res) => {
+  try {
+    const { q: searchQuery } = req.query;
+
+    // Check if search query is provided
+    if (!searchQuery || typeof searchQuery !== 'string') {
+      return res.status(400).json({ message: 'Search query parameter "q" is required' });
+    }
+
+    // Sanitize and prepare search terms
+    const terms = searchQuery.toLowerCase()
+      .trim()
+      .split(/\W+/)
+      .filter(term => term.length > 0);
+
+    if (terms.length === 0) {
+      return res.status(400).json({ message: 'Search query must contain valid terms' });
+    }
+
+    const fileIds = await SearchIndexFile.findAll({
+      where: { 
+        term: { [Op.in]: terms }
+      },
+      attributes: ['file_id'],
+      group: ['file_id'],
+      having: Sequelize.literal(`COUNT(DISTINCT term) = ${terms.length}`),
+    });
+
+    const files = await File.findAll({
+      where: { 
+        file_id: { [Op.in]: fileIds.map(f => f.file_id) }
+      },
+      include: [{
+        model: Message,
+        attributes: ['message_id', 'sender_id']
+      }],
+      order: [['uploaded_at', 'DESC']],
+      limit: 50 // Prevent excessive results
+    });
+
+    res.json({
+      results: files,
+      count: files.length,
+      query: searchQuery
+    });
+
+  } catch (error) {
+    res.status(500).json({ message: 'Error searching files', error: error.message });
+  }
+};

controllers/messageController.js

@@ -0,0 +1,43 @@
+const { Message, User } = require('../models');
+
+exports.getThreadMessages = async (req, res) => {
+  try {
+    const { parentMessageId } = req.params;
+
+    // Check if parentMessageId is provided
+    if (!parentMessageId) {
+      return res.status(400).json({ message: 'Parent message ID is required' });
+    }
+
+    const messages = await Message.findAll({
+      where: { parent_message_id: parentMessageId },
+      include: [{
+        model: User,
+        as: 'sender',
+        attributes: ['user_id', 'username'] // Include relevant user fields
+      }],
+      order: [['sent_at', 'ASC']],
+    });
+
+    res.json(messages);
+  } catch (error) {
+    res.status(500).json({ message: 'Error fetching thread messages', error: error.message });
+  }
+};
+
+exports.createMessage = async (req, res) => {
+  try {
+    const { channel_id, content, parent_message_id } = req.body;
+    const sender_id = req.userData.userId;
+    let message;
+
+    if (parent_message_id) {
+      message = await Message.create({ channel_id, sender_id, content, parent_message_id });
+    } else {
+      message = await Message.create({ channel_id, sender_id, content });
+    }
+    res.status(201).json(message);
+  } catch (error) {
+    res.status(500).json({ message: 'Error creating message', error: error.message });
+  }
+};

controllers/reactionController.js

@@ -0,0 +1,27 @@
+const { Reaction } = require('../models');
+
+exports.addReaction = async (req, res) => {
+  try {
+    const { messageId, emojiCode } = req.body;
+    const reaction = await Reaction.create({
+      message_id: messageId,
+      user_id: req.userData.userId,
+      emoji_code: emojiCode,
+    });
+    res.status(201).json(reaction);
+  } catch (error) {
+    res.status(500).json({ message: 'Error adding reaction', error: error.message });
+  }
+};
+
+exports.removeReaction = async (req, res) => {
+  try {
+    const { reactionId } = req.params;
+    await Reaction.destroy({
+      where: { reaction_id: reactionId, user_id: req.userData.userId },
+    });
+    res.json({ message: 'Reaction removed successfully' });
+  } catch (error) {
+    res.status(500).json({ message: 'Error removing reaction', error: error.message });
+  }
+};