started dockerfiles and itemrequest

backend/routes/itemRequests.js

@@ -0,0 +1,286 @@
+const express = require('express');
+const { Op } = require('sequelize');
+const { ItemRequest, ItemRequestResponse, User, Item } = require('../models');
+const { authenticateToken } = require('../middleware/auth');
+const router = express.Router();
+
+router.get('/', async (req, res) => {
+  try {
+    const {
+      search,
+      status = 'open',
+      page = 1,
+      limit = 20
+    } = req.query;
+
+    const where = { status };
+    
+    if (search) {
+      where[Op.or] = [
+        { title: { [Op.iLike]: `%${search}%` } },
+        { description: { [Op.iLike]: `%${search}%` } }
+      ];
+    }
+
+    const offset = (page - 1) * limit;
+
+    const { count, rows } = await ItemRequest.findAndCountAll({
+      where,
+      include: [
+        { 
+          model: User, 
+          as: 'requester', 
+          attributes: ['id', 'username', 'firstName', 'lastName'] 
+        }
+      ],
+      limit: parseInt(limit),
+      offset: parseInt(offset),
+      order: [['createdAt', 'DESC']]
+    });
+
+    res.json({
+      requests: rows,
+      totalPages: Math.ceil(count / limit),
+      currentPage: parseInt(page),
+      totalRequests: count
+    });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+router.get('/my-requests', authenticateToken, async (req, res) => {
+  try {
+    const requests = await ItemRequest.findAll({
+      where: { requesterId: req.user.id },
+      include: [
+        { 
+          model: User, 
+          as: 'requester', 
+          attributes: ['id', 'username', 'firstName', 'lastName'] 
+        },
+        {
+          model: ItemRequestResponse,
+          as: 'responses',
+          include: [
+            {
+              model: User,
+              as: 'responder',
+              attributes: ['id', 'username', 'firstName', 'lastName']
+            },
+            {
+              model: Item,
+              as: 'existingItem'
+            }
+          ]
+        }
+      ],
+      order: [['createdAt', 'DESC']]
+    });
+
+    res.json(requests);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+router.get('/:id', async (req, res) => {
+  try {
+    const request = await ItemRequest.findByPk(req.params.id, {
+      include: [
+        { 
+          model: User, 
+          as: 'requester', 
+          attributes: ['id', 'username', 'firstName', 'lastName'] 
+        },
+        {
+          model: ItemRequestResponse,
+          as: 'responses',
+          include: [
+            {
+              model: User,
+              as: 'responder',
+              attributes: ['id', 'username', 'firstName', 'lastName']
+            },
+            {
+              model: Item,
+              as: 'existingItem'
+            }
+          ]
+        }
+      ]
+    });
+
+    if (!request) {
+      return res.status(404).json({ error: 'Item request not found' });
+    }
+
+    res.json(request);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+router.post('/', authenticateToken, async (req, res) => {
+  try {
+    const request = await ItemRequest.create({
+      ...req.body,
+      requesterId: req.user.id
+    });
+
+    const requestWithRequester = await ItemRequest.findByPk(request.id, {
+      include: [
+        { 
+          model: User, 
+          as: 'requester', 
+          attributes: ['id', 'username', 'firstName', 'lastName'] 
+        }
+      ]
+    });
+
+    res.status(201).json(requestWithRequester);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+router.put('/:id', authenticateToken, async (req, res) => {
+  try {
+    const request = await ItemRequest.findByPk(req.params.id);
+
+    if (!request) {
+      return res.status(404).json({ error: 'Item request not found' });
+    }
+
+    if (request.requesterId !== req.user.id) {
+      return res.status(403).json({ error: 'Unauthorized' });
+    }
+
+    await request.update(req.body);
+
+    const updatedRequest = await ItemRequest.findByPk(request.id, {
+      include: [
+        { 
+          model: User, 
+          as: 'requester', 
+          attributes: ['id', 'username', 'firstName', 'lastName'] 
+        }
+      ]
+    });
+
+    res.json(updatedRequest);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+router.delete('/:id', authenticateToken, async (req, res) => {
+  try {
+    const request = await ItemRequest.findByPk(req.params.id);
+
+    if (!request) {
+      return res.status(404).json({ error: 'Item request not found' });
+    }
+
+    if (request.requesterId !== req.user.id) {
+      return res.status(403).json({ error: 'Unauthorized' });
+    }
+
+    await request.destroy();
+    res.status(204).send();
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+router.post('/:id/responses', authenticateToken, async (req, res) => {
+  try {
+    const request = await ItemRequest.findByPk(req.params.id);
+
+    if (!request) {
+      return res.status(404).json({ error: 'Item request not found' });
+    }
+
+    if (request.requesterId === req.user.id) {
+      return res.status(400).json({ error: 'Cannot respond to your own request' });
+    }
+
+    if (request.status !== 'open') {
+      return res.status(400).json({ error: 'Cannot respond to closed request' });
+    }
+
+    const response = await ItemRequestResponse.create({
+      ...req.body,
+      itemRequestId: req.params.id,
+      responderId: req.user.id
+    });
+
+    await request.increment('responseCount');
+
+    const responseWithDetails = await ItemRequestResponse.findByPk(response.id, {
+      include: [
+        {
+          model: User,
+          as: 'responder',
+          attributes: ['id', 'username', 'firstName', 'lastName']
+        },
+        {
+          model: Item,
+          as: 'existingItem'
+        }
+      ]
+    });
+
+    res.status(201).json(responseWithDetails);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+router.put('/responses/:responseId/status', authenticateToken, async (req, res) => {
+  try {
+    const { status } = req.body;
+    const response = await ItemRequestResponse.findByPk(req.params.responseId, {
+      include: [
+        {
+          model: ItemRequest,
+          as: 'itemRequest'
+        }
+      ]
+    });
+
+    if (!response) {
+      return res.status(404).json({ error: 'Response not found' });
+    }
+
+    if (response.itemRequest.requesterId !== req.user.id) {
+      return res.status(403).json({ error: 'Only the requester can update response status' });
+    }
+
+    await response.update({ status });
+
+    if (status === 'accepted') {
+      await response.itemRequest.update({ status: 'fulfilled' });
+    }
+
+    const updatedResponse = await ItemRequestResponse.findByPk(response.id, {
+      include: [
+        {
+          model: User,
+          as: 'responder',
+          attributes: ['id', 'username', 'firstName', 'lastName']
+        },
+        {
+          model: Item,
+          as: 'existingItem'
+        }
+      ]
+    });
+
+    res.json(updatedResponse);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+module.exports = router;