Software: Apache. PHP/8.1.30 

uname -a: Linux server1.tuhinhossain.com 5.15.0-163-generic #173-Ubuntu SMP Tue Oct 14 17:51:00 UTC
2025 x86_64 

uid=1002(picotech) gid=1003(picotech) groups=1003(picotech),0(root)  

Safe-mode: OFF (not secure)

/home/picotech/domains/rentals.picotech.app/public_html/server/routes/   drwxr-xr-x
Free 23.55 GB of 117.98 GB (19.96%)
                            Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Self remove    Logout    

Viewing file:     renter.js (7.29 KB)      -rw-rw-r--

import express from 'express';
import { Renter, Room, RenterDocument, User, Floor, Activity, Settings, Bed, Building, RentPayment } from '../models/index.js';
import upload from '../middleware/upload.js';
import sendEmail from '../utils/email.js'
import { now } from 'sequelize/lib/utils';
import { renterValidators } from '../middleware/validators.js';

const router = express.Router();
// GET all renters
router.get('/', async (req, res) => {
  try {
    const renters = await Renter.findAll({
      include: [
        {
          model: Room,
          as: 'room',
          include: [
            {
              model: Floor,
              as: 'floor',
            },
          ]
        },
        {
          model: RenterDocument,
          as: 'documents',
        },
        {
          model: Bed,
          as: 'bed',
        },
        {
          model: Floor,
          as: 'floor',
        },
        {
          model: Building,
          as: 'building',
        }
      ],
      order: [['created_at', 'DESC']]
    });
    res.json(renters);
  } catch (err) {
    res.status(500).json({ error: 'Failed to fetch renters' });
  }
});

// GET one renter by ID
router.get('/:id', async (req, res) => {
  try {
    const renter = await Renter.findByPk(req.params.id, {
      include: [
        {
          model: Room,
          as: 'room',
          include: [
            {
              model: Floor,
              as: 'floor',
            },
          ],
        },
        {
          model: RenterDocument,
          as: 'documents',
        },
        {
          model: Floor,
          as: 'floor',
        },
        {
          model: Building,
          as: 'building',
        },
      ],
    });

    if (!renter) return res.status(404).json({ error: 'Renter not found' });
    res.json(renter);
  } catch (err) {
    res.status(500).json({ error: 'Failed to fetch renter' });
  }
});

const uploadFields = upload.fields([
  { name: 'documents', maxCount: 7 },
]);
// CREATE new renter
router.post('/', uploadFields, renterValidators.create, async (req, res) => {
  try {
    const { room_id, documentsMeta, name, email, password, phone } = req.body;

    const hasRenter = await Renter.findOne({ where: { room_id: room_id } });

    if (hasRenter) {
      return res.status(404).json({ error: 'Has an Renter' });
    }

    const userData = {
      name: name,
      email: email,
      phone: phone,
      password: password,
      role: 'renter',
      permissions: ["renter"],
    };

    const user = await User.create(userData);

    // const renter = await Renter.create(req.body);
    const renter = await Renter.create({
      ...req.body,
      user_id: user.id,
    });

    const room = await Room.findOne({ where: { id: room_id } });
    if (!room) {
      return res.status(404).json({ error: 'Room not found' });
    }
    if (room.status !== 'available') {
      return res.status(404).json({ error: 'Room is not available right now' });
    }
    room.status = 'occupied';
    room.renter_id = renter.id;
    await room.save();

    const setting = await Settings.findOne({ where: { name: 'smtp' } });
    if (setting && setting.value) {
      let smtpConfig = {};
      try {
        smtpConfig = JSON.parse(setting.value);
      } catch (e) {
        console.warn('Failed to parse SMTP config:', e);
      }

      if (smtpConfig.smtpHost && smtpConfig.fromEmail) {
        await sendEmail({
          email,
          subject: 'New Renter Information',
          message: `Dear ${name}, Your login email is ${email} and password is ${password}.`,
        });
      } else {
        console.warn('SMTP host or fromEmail is missing.');
      }
    }

    let metadataArray = [];
    try {
      metadataArray = JSON.parse(documentsMeta || '[]');
    } catch (e) {
      return res.status(400).json({ error: 'Invalid documentsMeta format' });
    }

    // Save uploaded documents
    if (req.files?.documents?.length > 0) {
      for (let i = 0; i < req.files.documents.length; i++) {
        const file = req.files.documents[i];
        const meta = metadataArray[i] || {}; // fallback to empty

        await RenterDocument.create({
          renter_id: renter.id,
          type: meta.type || 'unknown',
          description: meta.description || '',
          file_name: file.originalname,
          file_url: `/uploads/${file.filename}`,
          file_size: file.size,
          mime_type: file.mimetype,
        });
      }
    }
    const data = {
      model_id: renter.id,
      model_name: 'Renter',
      description: `New Renter ${renter.name} has been assigned to room #${renter.room_id}`,
    };
    const activity = await Activity.create(data);
    res.status(201).json(renter);
  } catch (err) {
    res.status(400).json({ error: err.message });
  }
});


// UPDATE renter
router.put('/:id', renterValidators.update, async (req, res) => {
  try {

    const { room_id, name, email, password, phone } = req.body;

    const renter = await Renter.findByPk(req.params.id);
    if (!renter) return res.status(404).json({ error: 'Renter not found' });

    const userData = {
      name: name,
      email: email,
      phone: phone,
      password: password,
    };

    const user = await User.findByPk(renter.user_id);
    if (!user) {
      return res.status(404).json({ message: 'User not found' });
    }

    await user.update(userData);

    const oldroom = await Room.findOne({
      where: {
        renter_id: renter.id,
      },
    });

    if (oldroom && oldroom.id !== room_id) {
      const room = await Room.findOne({ where: { id: room_id } });
      if (!room) {
        return res.status(404).json({ error: 'Room not found' });
      }
      if (room.status !== 'available') {
        return res.status(404).json({ error: 'Room is not available right now' });
      }

      oldroom.status = 'available';
      oldroom.renter_id = null;
      await oldroom.save();

      room.status = 'occupied';
      room.renter_id = renter.id;
      await room.save();
    }

    await renter.update(req.body);

    const data = {
      model_id: renter.id,
      model_name: 'Renter',
      description: `Renter ${renter.name} data has been updated`,
    };
    const activity = await Activity.create(data);
    res.json(renter);
  } catch (err) {
    res.status(400).json({ error: err.message });
  }
});

// DELETE renter
router.delete('/:id', async (req, res) => {
  try {
    const renter = await Renter.findByPk(req.params.id);
    if (!renter) return res.status(404).json({ error: 'Renter not found' });
    const data = {
      model_id: renter.id,
      model_name: 'Renter',
      description: `Renter ${renter.name} has been deleted`,
    };
    const activity = await Activity.create(data);

    const room = await Room.findOne({ where: { id: renter.room_id } });
    if (!room) {
      return res.status(404).json({ error: 'Room not found' });
    }
    room.status = 'available';
    room.renter_id = null;
    await room.save();
    await renter.destroy();
    res.json({ message: 'Renter deleted' });
  } catch (err) {
    res.status(500).json({ error: 'Failed to delete renter' });
  }
});

export default router;