574 lines
23 KiB
JavaScript
574 lines
23 KiB
JavaScript
const getRates = require("../util/exchangeRate");
|
|
const { calculatePlanProgress, updatePlanProgressInDB } = require("../util/calculations");
|
|
const suggestions = require("../util/suggestions");
|
|
const status = require("../util/statuses");
|
|
const ObjectId = require('mongodb').ObjectId;
|
|
const session = require("express-session");
|
|
const bcrypt = require("bcrypt");
|
|
const path = require("path");
|
|
const joi = require("joi");
|
|
const fs = require("fs");
|
|
const salt = 12;
|
|
|
|
/**
|
|
* getAssetSchema returns correct joi object
|
|
* to validate req.body depending on asset type
|
|
* @param {string} type of asset
|
|
* @returns {joi.object} schema
|
|
*/
|
|
const getAssetSchema = (type) => {
|
|
let assetSchema;
|
|
|
|
switch (type) {
|
|
case "other":
|
|
assetSchema = joi.object({
|
|
type: joi.string().valid("other", "stock", "saving").required(),
|
|
icon: joi.string().alphanum().required(),
|
|
name: joi.string().alphanum().min(3).max(30).required(),
|
|
value: joi.number().min(0).required(),
|
|
purchaseDate: joi.date().required(),
|
|
description: joi.string().alphanum().max(240),
|
|
id: joi.string().alphanum(), // May be passed when updating existing asset
|
|
});
|
|
break;
|
|
case "saving":
|
|
assetSchema = joi.object({
|
|
type: joi.string().valid("other", "stock", "saving").required(),
|
|
name: joi.string().alphanum().min(3).max(30).required(),
|
|
value: joi.number().min(0).required(),
|
|
id: joi.string().alphanum(), // May be passed when updating existing asset
|
|
});
|
|
break;
|
|
case "stock":
|
|
assetSchema = joi.object({
|
|
type: joi.string().valid("other", "stock", "saving").required(),
|
|
ticker: joi.string().alphanum().min(3).max(5).required(),
|
|
price: joi.number().min(0).required(),
|
|
quantity: joi.number().min(1).required(),
|
|
purchaseDate: joi.date().required(),
|
|
id: joi.string().alphanum(), // May be passed when updating existing asset
|
|
});
|
|
break;
|
|
default:
|
|
return null;
|
|
};
|
|
|
|
return assetSchema;
|
|
}
|
|
|
|
/**
|
|
* @param {function} middleware handler
|
|
* @param {MongoClient.collection} users db collection
|
|
* @param {MongoClient.collection} assets db collection
|
|
* @returns {express.Router} user protected routes router
|
|
*/
|
|
module.exports = (middleware, users, plans, assets) => {
|
|
const router = require("express").Router();
|
|
|
|
// Create list of icon filenames
|
|
let icons = fs.readdirSync(path.join(__dirname, "../public/svgs/icons"));
|
|
icons = icons.map((icon) => icon.split(".")[0]);
|
|
|
|
router.use(middleware);
|
|
|
|
router.get('/home', async (req, res) => {
|
|
// if no session with geoData
|
|
if (!req.session.geoData) {
|
|
req.session.geoData = {
|
|
country: null,
|
|
toCurrencyRates: [],
|
|
};
|
|
}
|
|
|
|
res.render('dashboard', { user: req.user, geoData: req.session.geoData });
|
|
|
|
return res.status(status.Ok);
|
|
});
|
|
|
|
router.get('/assets', async (req, res) => {
|
|
let userAssets = await assets.find({ userId: new ObjectId(req.session.user._id) }).toArray();
|
|
res.render('assets', {
|
|
user: req.session.user,
|
|
errMessage: req.session.errMessage,
|
|
assets: userAssets,
|
|
geoData: req.session.geoData,
|
|
icons: icons,
|
|
});
|
|
return res.status(status.Ok);
|
|
});
|
|
|
|
router.get('/plans', async (req, res) => {
|
|
try {
|
|
const userPlansFromDB = await plans.find({ userId: new ObjectId(req.session.user._id) }).toArray();
|
|
|
|
// Use a for...of loop for proper async/await behavior in series for updates
|
|
for (const plan of userPlansFromDB) {
|
|
const percentage = await calculatePlanProgress(plan, assets, req.session.user._id);
|
|
await updatePlanProgressInDB(plan._id, percentage, plans); // Pass the 'plans' collection
|
|
}
|
|
|
|
// Re-fetch plans to get updated progress for rendering
|
|
const updatedUserPlans = await plans.find({ userId: new ObjectId(req.session.user._id) }).toArray();
|
|
|
|
res.render('plans', {
|
|
user: req.session.user,
|
|
plans: updatedUserPlans, // Send the most up-to-date plans
|
|
geoData: req.session.geoData
|
|
});
|
|
} catch (err) {
|
|
console.error("Error fetching plans:", err);
|
|
req.session.errMessage = "Could not load your plans. Please try again.";
|
|
res.status(status.InternalServerError).redirect('/home');
|
|
}
|
|
});
|
|
|
|
router.get('/plans/:id', async (req, res) => {
|
|
|
|
try {
|
|
const planId = req.params.id;
|
|
let userAssets = await assets.find({ userId: new ObjectId(req.session.user._id) }).toArray();
|
|
|
|
|
|
if (!ObjectId.isValid(planId)) {
|
|
req.session.errMessage = "Invalid plan ID format.";
|
|
return res.status(status.BadRequest).redirect('/plans');
|
|
}
|
|
|
|
const plan = await plans.findOne({ userId: new ObjectId(req.session.user._id), _id: new ObjectId(planId) });
|
|
|
|
if (!plan) {
|
|
console.log(`Plan not found with ID: ${planId} for user: ${req.session.user.email}`);
|
|
req.session.errMessage = "Plan not found or you do not have permission to view it.";
|
|
return res.status(status.NotFound).redirect('/plans');
|
|
}
|
|
|
|
// The plan.progress should be up-to-date from the database as it was updated in the /plans route
|
|
// or when assets/plans are modified. If an immediate recalculation for this specific view is absolutely needed,
|
|
// (e.g., if assets were modified without an immediate plan progress update elsewhere),
|
|
// you could do it here:
|
|
// const currentProgress = await calculatePlanProgress(plan, assets, req.session.user._id);
|
|
// plan.progress = currentProgress; // This would only update the 'plan' object for this render, not in DB
|
|
|
|
res.render('planDetail', {
|
|
user: req.session.user,
|
|
plan: plan, // This plan object will have the progress from the database
|
|
geoData: req.session.geoData,
|
|
assets: userAssets,
|
|
suggestions: await suggestions.generateSuggestions(),
|
|
});
|
|
|
|
} catch (err) {
|
|
console.error("Error fetching plan:", err);
|
|
req.session.errMessage = "Could not load your plan. Please try again.";
|
|
res.status(status.InternalServerError).redirect('/home');
|
|
}
|
|
});
|
|
|
|
router.get('/newPlan', (req, res) => {
|
|
if (!req.session.user.financialData || !req.session.user) {
|
|
req.session.errMessage = "Please complete your financial data before creating a plan.";
|
|
return res.status(status.Unauthorized).redirect('/questionnaire');
|
|
}
|
|
const errMessage = req.session.errMessage;
|
|
req.session.errMessage = "";
|
|
res.render('newPlan', {
|
|
user: req.session.user,
|
|
errMessage: errMessage,
|
|
geoData: req.session.geoData
|
|
});
|
|
});
|
|
|
|
router.post('/newPlan', async (req, res) => {
|
|
const planSchema = joi.object({
|
|
name: joi.string().min(3).max(100).required(),
|
|
retirementAge: joi.number().min(18).max(120).required(),
|
|
retirementExpenses: joi.number().min(0).required(),
|
|
retirementAssets: joi.number().min(0).required(),
|
|
retirementLiabilities: joi.number().min(0).required(),
|
|
});
|
|
|
|
const validationOptions = { convert: true, abortEarly: false };
|
|
const { error, value } = planSchema.validate(req.body, validationOptions);
|
|
|
|
if (error) {
|
|
console.error("Plan validation error:", error.details);
|
|
req.session.errMessage = "Invalid input: " + error.details.map(d => d.message.replace(/"/g, '')).join(', ');
|
|
res.status(status.BadRequest).redirect("/newPlan");
|
|
return;
|
|
}
|
|
const newPlan = {
|
|
userId: new ObjectId(req.session.user._id),
|
|
name: value.name,
|
|
retirementAge: value.retirementAge,
|
|
retirementExpenses: value.retirementExpenses,
|
|
retirementAssets: value.retirementAssets,
|
|
retirementLiabilities: value.retirementLiabilities,
|
|
progress: "0"
|
|
};
|
|
|
|
try {
|
|
await plans.insertOne({ userId: new ObjectId(req.session.user._id), ...newPlan });
|
|
req.session.errMessage = "";
|
|
res.redirect('/plans');
|
|
}
|
|
catch (err) {
|
|
console.error("Error saving plan:", err);
|
|
req.session.errMessage = "An error occurred while saving your plan. Please try again.";
|
|
res.status(status.InternalServerError).redirect("/newPlan");
|
|
}
|
|
});
|
|
|
|
router.get('/pun', async (req, res) => {
|
|
const pun = await suggestions.generatePun();
|
|
return res.status(status.Ok).json({ pun });
|
|
});
|
|
|
|
router.get('/more', (req, res) => {
|
|
res.render('more', {
|
|
user: req.session.user,
|
|
geoData: req.session.geoData
|
|
});
|
|
return res.status(status.Ok);
|
|
});
|
|
|
|
router.get('/profile', (req, res) => {
|
|
res.render('profile', {
|
|
user: req.session.user,
|
|
errMessage: req.session.errMessage,
|
|
geoData: req.session.geoData
|
|
});
|
|
return res.status(status.Ok);
|
|
});
|
|
|
|
router.get('/settings', (req, res) => {
|
|
res.render('settings', {
|
|
user: req.session.user,
|
|
geoData: req.session.geoData
|
|
});
|
|
return res.status(status.Ok);
|
|
});
|
|
|
|
router.get('/questionnaire', (req, res) => {
|
|
const errMessage = req.session.errMessage;
|
|
req.session.errMessage = "";
|
|
res.render('questionnaire', {
|
|
user: req.session.user,
|
|
errMessage: errMessage,
|
|
geoData: req.session.geoData
|
|
});
|
|
});
|
|
|
|
router.post('/questionnaire', (req, res) => {
|
|
const questionnaireSchema = joi.object({
|
|
dob: joi.date().required(),
|
|
education: joi.string().valid('primary', 'secondary', 'tertiary', 'postgraduate').required(),
|
|
maritalStatus: joi.string().valid('single', 'married', 'divorced', 'widowed').required(),
|
|
income: joi.number().min(0).required(),
|
|
expenses: joi.number().min(0).required(),
|
|
assets: joi.number().min(0).required(),
|
|
liabilities: joi.number().min(0).required(),
|
|
});
|
|
|
|
const validationOptions = { convert: true, abortEarly: false };
|
|
const { error, value } = questionnaireSchema.validate(req.body, validationOptions);
|
|
|
|
if (error) {
|
|
console.error("Questionnaire validation error:", error.details);
|
|
req.session.errMessage = "Invalid input: " + error.details.map(d => d.message.replace(/"/g, '')).join(', ');
|
|
res.status(status.BadRequest).redirect("/questionnaire");
|
|
return;
|
|
}
|
|
|
|
users.updateOne(
|
|
{ _id: new ObjectId(req.session.user._id) },
|
|
{
|
|
$set: {
|
|
financialData: true,
|
|
dob: value.dob,
|
|
education: value.education,
|
|
maritalStatus: value.maritalStatus,
|
|
income: value.income,
|
|
expenses: value.expenses,
|
|
assets: value.assets,
|
|
liabilities: value.liabilities,
|
|
}
|
|
}
|
|
).then((result) => {
|
|
if (result.matchedCount === 0) {
|
|
console.log(`User not found during questionnaire update: ${req.session.user.email}`);
|
|
req.session.errMessage = "User session invalid. Please log in again.";
|
|
res.status(status.NotFound).redirect("/login");
|
|
return;
|
|
}
|
|
if (result.modifiedCount === 0 && result.matchedCount === 1) {
|
|
console.log(`User questionnaire data unchanged (already up-to-date): ${req.session.user.email}`);
|
|
}
|
|
|
|
req.session.user.financialData = true;
|
|
req.session.errMessage = "";
|
|
|
|
req.session.save(err => {
|
|
if (err) {
|
|
res.status(status.InternalServerError).redirect("/plans");
|
|
}
|
|
res.status(status.Ok).redirect("/plans");
|
|
});
|
|
|
|
}).catch(err => {
|
|
console.error("Error updating questionnaire in database:", err);
|
|
req.session.errMessage = "An error occurred while saving your information. Please try again.";
|
|
res.status(status.InternalServerError).redirect("/questionnaire");
|
|
});
|
|
});
|
|
|
|
router.post("/updateAccount", async (req, res) => {
|
|
const accountSchema = joi.object({
|
|
email: joi.string().email(),
|
|
name: joi.string().pattern(new RegExp('^[a-zA-Z]+$')).max(20),
|
|
password: joi.string().alphanum().max(20).min(8),
|
|
repassword: joi.string().alphanum().max(20).min(8),
|
|
});
|
|
|
|
const valid = accountSchema.validate(req.body);
|
|
|
|
if (valid.err) {
|
|
req.session.errMessage = "Invalid input",
|
|
res.status(status.BadRequest);
|
|
return res.redirect("/profile");
|
|
}
|
|
|
|
let update = {
|
|
name: req.body.name,
|
|
};
|
|
|
|
if ((req.body.password != "") && (req.body.password != req.body.repassword)) {
|
|
req.session.errMessage = "New passwords must match";
|
|
res.status(status.BadRequest);
|
|
return res.redirect("/profile");
|
|
} else if (req.body.password != "") {
|
|
let hashedPassword = await bcrypt.hashSync(req.body.password, salt);
|
|
update.password = hashedPassword;
|
|
}
|
|
|
|
users.updateOne(
|
|
{ email: req.session.email },
|
|
{ $set: update }
|
|
).then((result) => {
|
|
if (result.matchedCount === 0) {
|
|
console.log(`User not found during account update: ${req.session.email}`);
|
|
req.session.errMessage = "User session invalid. Please log in again.";
|
|
res.status(status.NotFound).redirect("/login");
|
|
return;
|
|
}
|
|
if (result.modifiedCount === 0 && result.matchedCount === 1) {
|
|
console.log(`User account data unchanged (already up-to-date): ${req.session.email}`);
|
|
}
|
|
|
|
req.session.errMessage = "";
|
|
return res.status(status.Ok).redirect("/profile");
|
|
}).catch(err => {
|
|
console.error("Error updating account in database:", err);
|
|
req.session.errMessage = "An error occurred while saving your information. Please try again.";
|
|
return res.status(status.InternalServerError).redirect("/profile");
|
|
});
|
|
});
|
|
|
|
router.post("/createAsset", async (req, res) => {
|
|
// Create asset, each asset has different data structure based on type
|
|
const type = req.body.type;
|
|
const assetSchema = getAssetSchema(type);
|
|
|
|
if (!assetSchema) {
|
|
console.error("Modified asset type, rejected");
|
|
req.session.errMessage = "Invalid input";
|
|
return res.status(status.BadRequest).redirect("/assets");
|
|
}
|
|
|
|
const valid = assetSchema.validate(req.body);
|
|
|
|
if (valid.err) {
|
|
req.session.errMessage = "Invalid input",
|
|
res.status(status.BadRequest);
|
|
return res.redirect("/assets");
|
|
}
|
|
|
|
let newAsset = {
|
|
userId: new ObjectId(req.session.user._id),
|
|
...req.body,
|
|
updatedAt: new Date(),
|
|
};
|
|
|
|
if (type == "stock") {
|
|
newAsset.quantity = parseInt(newAsset.quantity);
|
|
newAsset.price = parseFloat(newAsset.price)
|
|
newAsset.value = newAsset.quantity * newAsset.price;
|
|
newAsset.name = `${newAsset.ticker} Stock`;
|
|
}
|
|
newAsset.value = parseFloat(newAsset.value);
|
|
newAsset.icon = type == "stock" ? "Stock" : type == "saving" ? "Coins" : newAsset.icon;
|
|
|
|
assets.insertOne(newAsset, (err, _) => {
|
|
if (err) {
|
|
console.error("Error creating asset: ", err);
|
|
req.session.errMessage = "Internal server error";
|
|
return res.status(status.InternalServerError).redirect("/assets");
|
|
}
|
|
});
|
|
|
|
req.session.errMessage = "";
|
|
return res.status(status.Ok).redirect("/assets");
|
|
});
|
|
|
|
router.post("/updateAsset", async (req, res) => {
|
|
const type = req.body.type;
|
|
const assetSchema = getAssetSchema(type);
|
|
|
|
if (!assetSchema) {
|
|
console.error("Modified asset type, rejected");
|
|
req.session.errMessage = "Invalid input";
|
|
return res.status(status.BadRequest).redirect("/assets");
|
|
}
|
|
|
|
const valid = assetSchema.validate(req.body);
|
|
|
|
if (valid.err) {
|
|
req.session.errMessage = "Invalid input",
|
|
res.status(status.BadRequest);
|
|
return res.redirect("/assets");
|
|
}
|
|
|
|
if (req.body.userId != req.session.user._id) {
|
|
req.session.errMessage = "Cannot change asset owner",
|
|
res.status(status.BadRequest);
|
|
return res.redirect("/assets");
|
|
}
|
|
|
|
let update = { ...req.body, updatedAt: new Date() };
|
|
if (type == "stock") {
|
|
update.quantity = parseInt(update.quantity);
|
|
update.price = parseFloat(update.price)
|
|
update.value = update.quantity * update.price;
|
|
update.name = `${update.ticker} Stock`;
|
|
}
|
|
update.value = parseFloat(update.value);
|
|
delete update.id;
|
|
delete update.userId;
|
|
|
|
assets.updateOne(
|
|
{ "_id": new ObjectId(req.body.id) },
|
|
{ $set: update },
|
|
).then((result) => {
|
|
if (result.matchedCount === 0) {
|
|
console.log(`Asset not found: ${req.body.id}`);
|
|
req.session.errMessage = "Unable to update asset";
|
|
return res.status(status.NotFound).redirect("/assets");
|
|
}
|
|
if (result.modifiedCount === 0 && result.matchedCount === 1) {
|
|
console.log(`Asset data unchanged (already up-to-date): ${req.body.id}`);
|
|
}
|
|
|
|
req.session.errMessage = "";
|
|
return res.status(status.Ok).redirect("/assets");
|
|
|
|
}).catch((err) => {
|
|
console.error("Error updating asset: ", err);
|
|
req.session.errMessage = "An error occurred while saving your information. Please try again.";
|
|
return res.status(status.InternalServerError).redirect("/assets");
|
|
});
|
|
});
|
|
|
|
router.post("/deleteAsset", (req, res) => {
|
|
const id = new ObjectId(req.body.id);
|
|
|
|
assets.deleteOne(
|
|
{ "_id": id }
|
|
).then((result) => {
|
|
if (result.deletedCount === 0) {
|
|
console.error(`Asset not found: ${req.body.id}`);
|
|
req.session.errMessage = "Unable to delete asset. Please try again.";
|
|
return res.status(status.NotFound).redirect("/assets");
|
|
}
|
|
|
|
if (!result.acknowledged) {
|
|
console.error("Error deleting asset: ", err);
|
|
req.session.errMessage = "An error occurred while deleting an asset. Please try again.";
|
|
return res.status(status.InternalServerError).redirect("/assets");
|
|
}
|
|
|
|
req.session.errMessage = "";
|
|
return res.status(status.Ok).redirect("/assets");
|
|
|
|
}).catch((err) => {
|
|
console.error("Error deleting asset: ", err);
|
|
req.session.errMessage = "An error occurred while deleting an asset. Please try again.";
|
|
return res.status(status.InternalServerError).redirect("/assets");
|
|
});
|
|
});
|
|
|
|
router.post("/deleteUser", (req, res) => {
|
|
// not as critical if results aren't as expected only if crashing
|
|
assets.deleteMany({ userId: new ObjectId(req.session.user._id) }).catch((err) => {
|
|
console.error("Error deleting user assets: ", err);
|
|
req.session.errMessage = "An error occured while deleting your account. Please try again.";
|
|
return res.status(status.InternalServerError).redirect("/profile");
|
|
});
|
|
|
|
plans.deleteMany({ userId: new ObjectId(req.session.user._id) }).catch((err) => {
|
|
console.error("Error deleting user assets: ", err);
|
|
req.session.errMessage = "An error occured while deleting your account. Please try again.";
|
|
return res.status(status.InternalServerError).redirect("/profile");
|
|
});
|
|
|
|
users.deleteOne(
|
|
{ _id: new ObjectId(req.session.user._id) },
|
|
).then((result) => {
|
|
if (result.deletedCount === 0) {
|
|
console.error(`User not found: ${req.body.id}`);
|
|
req.session.errMessage = "Unabled to delete account. Please try again.";
|
|
return res.status(status.NotFound).redirect("/profile");
|
|
}
|
|
|
|
if (!result.acknowledged) {
|
|
console.error("Error deleting user: ", err);
|
|
req.session.errMessage = "An error occured while deleting your account. Please try again.";
|
|
return res.status(status.InternalServerError).redirect("/profile");
|
|
}
|
|
|
|
// Direct to logout to destroy session
|
|
req.session.destroy();
|
|
return res.status(status.Ok).redirect("/signup");
|
|
}).catch((err) => {
|
|
console.error("Error deleting user: ", err);
|
|
req.session.errMessage = "An error occured while deleting your account. Please try again.";
|
|
return res.status(status.InternalServerError).redirect("/profile");
|
|
});
|
|
});
|
|
|
|
router.get("/exRates/:lat/:lon", async (req, res) => {
|
|
if (!req.session.geoData.country) {
|
|
const response = await fetch(`https://maps.googleapis.com/maps/api/geocode/json?latlng=${req.params.lat},${req.params.lon}&result_type=country&key=${process.env.GEOLOCATION_API}`);
|
|
const data = await response.json();
|
|
|
|
country = data.results[0].formatted_address;
|
|
let results = await getRates(country);
|
|
|
|
if (!results.exRates) {
|
|
req.session.geoData = {
|
|
message: "error"
|
|
}
|
|
} else {
|
|
req.session.geoData = {
|
|
country: results.abbreviation,
|
|
toCurrencyRates: results.exRates,
|
|
geoData: req.session.geoData
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
return res.status(status.Ok).send({ data: req.session.geoData });
|
|
})
|
|
|
|
return router;
|
|
};
|