Sindbad~EG File Manager

const brcrypt = require("bcrypt");
const db = require("../models");
const jwt = require("jsonwebtoken");
const crypto = require("crypto");
const nodemailer = require("nodemailer");
const { google } = require("googleapis");
const { OAuth2Client } = require("google-auth-library");

const { Op } = require("sequelize");

const loginController = async (req, res) => {
  try {
    const { email, password } = req.body;
    let [result] = await db.tblUser.findAll({
      where: {
        email: email,
      },
    });
    // return res.json({ data: result });
    if (!result) {
      return res
        .status(404)
        .json({ status: 404, message: "Invalid Credentials." });
    }

    const isMatched = await brcrypt.compare(password, result.password);
    if (!isMatched) {
      return res
        .status(403)
        .json({ status: 403, message: "Invalid Credentials." });
    }

    let token = await jwt.sign(
      { email: result.email, auctioneerId: result.auctioneer_id },
      process.env.JWT_KEY
    );
    return res.json({
      status: 200,
      message: "Success",
      data: [{ token, ...result.dataValues }],
    });
  } catch (error) {
    return res.status(500).json({
      status: 500,
      message: "Internal Server Error",
      error: error.message,
    });
  }
};
const signupController = async (req, res) => {
  try {
    const { email, password } = req.body;
    const salt = await brcrypt.genSalt(10);
    const hashedPassword = await brcrypt.hash(password, salt);
    req.body.password = hashedPassword;
    let result;
    result = await db.tblUser.findAll({ where: { email: email } });

    if (result.length > 0) {
      return res.status(402).json({
        status: 402,
        message: "The email address is already in use!",
      });
    }
    result = await db.tblUser.create(req.body);

    let token = await jwt.sign(
      { email: result.email, userId: result.user_id },
      process.env.JWT_KEY
    );
    return res.json({
      status: 200,
      message: "Success",
      data: [{ token, ...result.dataValues }],
    });
  } catch (error) {
    return res.status(500).json({
      status: 500,
      message: "Internal Server Error",
      error: error.message,
    });
  }
};

const updateUserPassword = async (req, res) => {
  try {
    let { userId, newPassword } = req.body;

    if (newPassword) {
      const salt = await brcrypt.genSalt(10);
      const encrypPassword = await brcrypt.hash(newPassword, salt);
      req.body.password = encrypPassword;
      let result = await db.tblUser.update(req.body, {
        where: { user_id: userId },
      });
      return res.status(200).json({ status: 200, message: "Success" });
    } else {
      return res.json({ status: 400, message: "newpassword undefined" });
    }
  } catch (error) {
    return res.status(500).json({
      status: 500,
      message: "Internal Server Error",
      error: error.message,
    });
  }
};

// Setup OAuth2 Client for nodemailer
const oAuth2Client = new google.auth.OAuth2(
  process.env.OAUTH_CLIENT_ID,
  process.env.OAUTH_CLIENT_SECRET,
  process.env.OAUTH_REDIRECT_URL
);

oAuth2Client.setCredentials({
  refresh_token: process.env.OAUTH_REFRESH_TOKEN,
});

let transporter;

// Helper function to initialize the transporter
const createTransporter = async () => {
  try {
    const accessTokenResponse = await oAuth2Client.getAccessToken();
    const accessToken = accessTokenResponse.token;
    transporter = nodemailer.createTransport({
      service: "gmail",
      auth: {
        type: "OAuth2",
        user: process.env.EMAIL_USERNAME,
        clientId: process.env.OAUTH_CLIENT_ID,
        clientSecret: process.env.OAUTH_CLIENT_SECRET,
        refreshToken: process.env.OAUTH_REFRESH_TOKEN,
        accessToken: accessToken,
      },
    });
  } catch (error) {
    console.error("Could not create mail transporter", error);
    throw new Error("EmailTransporterInitializationFailed");
  }
};

function getTranperter() {
  transporter = nodemailer.createTransport({
    host: "mail.dfwblackcars.com", // Replace with your mail server host from cPanel
    port: 465, // Secure SMTP port number provided by your hosting (commonly 465 or 587)
    secure: true, // True for 465, false for other ports
    auth: {
      user: "test@dfwblackcars.com", // The email account you created in cPanel
      pass: "]..$qp0yHnVO", // Email account password
    },
  });
  return transporter;
}
// Helper functions for password hashing
const generateHash = (password) => {
  return brcrypt.hashSync(password, brcrypt.genSaltSync(8), null);
};

const validPassword = (password, storedHash) => {
  return brcrypt.compareSync(password, storedHash);
};

const forgotPassword = async (req, res) => {
  const { email } = req.body;
  if (!transporter) {
    try {
      getTranperter();
    } catch (error) {
      return res.status(500).json({
        status: 500,
        message: "Failed to send email due to internal error",
      });
    }
  }
  // Generate token
  const token = crypto.randomBytes(20).toString("hex");

  try {
    const user = await db.tblUser.findOne({ where: { email: email } });

    if (!user) {
      return res.status(400).json({
        status: 400,
        error: "No account with that email address exists.",
      });
    }

    user.resetPasswordToken = token;
    user.resetPasswordExpires = Date.now() + 3600000; // 1 hour

    await user.save();

    const mailOptions = {
      to: user.email,
      from: process.env.EMAIL_USERNAME,
      subject: "Password Reset Confirmation",
      text: `Please click on the following link, or paste this into your browser to complete the process:\n\n`,
      html: `
        <html>
        <body>
          
          <p>Please click on the following link, or paste this into your browser to complete the process:\n\n</p>
          <a href="${process.env.CLIENT_URL}/reset/${token}\n\n" target="_blank">Reset Password</a>
          <p>If you did not request a password reset, please ignore this email.</p>
  
        </body>
        </html>`,
    };
    transporter.sendMail(mailOptions, (error, info) => {
      if (error) {
        return res.status(500).send(error);
      }

      console.log("Message sent successfully!");
      console.log('Server responded with "%s"', info.response);
      transporter.close();
    });

    res.json({
      status: 200,
      message: "Success",
      data: {
        notification: `An e-mail has been sent to ${user.email} with further instructions.`,
        token: token,
      },
    });
  } catch (error) {
    return res.status(500).send(error.message);
  }
};

const resetPasswordViaToken = async (req, res) => {
  const { token } = req.params;
  const { newPassword } = req.body;

  try {
    const user = await db.tblUser.findOne({
      where: {
        resetPasswordToken: token,
        resetPasswordExpires: { [Op.gt]: Date.now() },
      },
    });

    if (!user) {
      return res.status(400).json({
        status: 400,
        error: "Password reset token is invalid or has expired.",
      });
    }

    user.password = generateHash(newPassword);
    user.resetPasswordToken = null;
    user.resetPasswordExpires = null;

    await user.save();
    res.status(200).json({
      status: 200,
      message: "Success! Your password has been changed.",
    });
  } catch (error) {
    res.status(500).send(error.message);
  }
};

module.exports = {
  loginController,
  signupController,
  updateUserPassword,
  forgotPassword,
  resetPasswordViaToken,
};