notherbase-fs 1.1.42 → 1.2.2

package/controllers/authCheck.js

@@ -1,27 +1,12 @@
-const { user, connectionSuccess } = require("../models");
+const { connectionSuccess } = require("../models");
 
 const authCheck = async function authCheck(req, res, next){
     if (connectionSuccess) {
-        try {
-            if (req.session.currentUser) {
-                const foundAccount = await user.findById(req.session.currentUser);
-        
-                if (foundAccount) {
-                    req.session.currentUserFull = foundAccount;
-                    next();
-                }
-                else {
-                    req.session.currentUserFull = null;
-                    res.redirect("/the-front");
-                }
-            }
-            else{
-                res.redirect("/the-front");
-            }
+        if (req.session.currentUser) {
+            next();
         }
-        catch(err) {
-            console.log("database error");
-            console.log(err);
+        else {
+            res.redirect("/the-front");
         }
     }
     else {

package/controllers/explorer.js

@@ -31,6 +31,7 @@ let complete = function complete(explorerBuild) {
                         externalStyles: [],
                         localScripts: [],
                         serverScripts: [],
+                        requiredItems: [],
                         needsKey: "",
                         dropOff: "",
                         ...detail.options
@@ -74,6 +75,13 @@ let complete = function complete(explorerBuild) {
                                 }));
                             }
 
+                            let foundItemIDs = [];
+                            for (let m = 0; m < detail.options.requiredItems.length; m++) {
+                                let foundItem = await item.findOne({name: detail.options.requiredItems[m]});
+
+                                foundItemIDs.push(foundItem._id);
+                            }
+
                             let context = {
                                 siteTitle: "NotherBase",
                                 user: req.session.currentUserFull,
@@ -82,6 +90,7 @@ let complete = function complete(explorerBuild) {
                                 main: detail.options.main,
                                 localScripts: detail.options.localScripts,
                                 serverScriptReturns: serverScriptReturns,
+                                itemIDs: foundItemIDs,
                                 pov: req.query.pov,
                                 inventory: foundInventory,
                                 query: req.query
@@ -121,8 +130,9 @@ let complete = function complete(explorerBuild) {
             user: null,
             styles: [`${dir}/${explorerBuild.void}/styles/void`],
             externalStyles: [],
-            scripts: [],
+            localScripts: [],
             inventory: null,
+            itemIDs: [],
             main: `${dir}/${explorerBuild.void}/index`
         });
     });

package/controllers/inventory.js

@@ -7,7 +7,7 @@ const { inventory, item, connectionSuccess } = require("../models");
 router.get("/", async function(req, res) {
     if (connectionSuccess) {
         try {
-            if (req.session.currentUserFull) {
+            if (req.session.currentUser) {
                 let foundInventory = await inventory.findOne({user: req.session.currentUser}).populate("items.item");
     
                 res.status(200).send({ foundInventory: foundInventory });
@@ -74,10 +74,8 @@ router.post("/", async function(req, res) {
                 
                 if (!holding) {
                     if (req.body.change.amount > 0) {
-                        let foundItem = await item.findById(req.body.change.item);
-        
                         foundInventory.items.push({
-                            item: foundItem._id,
+                            item: req.body.change.item,
                             amount: req.body.change.amount
                         });
     

package/controllers/the-front.js

@@ -1,13 +1,15 @@
-const { inventory, connectionSuccess } = require("../models");
+const { user, inventory, connectionSuccess } = require("../models");
 
 let router = require("express").Router();
 let dir = "";
 
+
 let front = function front(detail) {
     detail.options = {
         styles: [],
         externalStyles: [],
         localScripts: [],
+        requiredItems: [],
         needsKey: "",
         dropOff: "",
         ...detail.options
@@ -28,11 +30,18 @@ let front = function front(detail) {
         return script;
     });
 
-    detail.options.main = "index";
-    if (detail.name !== "") detail.options.main = detail.name;
-    detail.options.main = `${dir}/views/${detail.options.main}`;
-
     router.get(`/${detail.name}`, async function(req, res) {
+        detail.options.main = "index";
+        if (detail.name !== "") detail.options.main = detail.name;
+        detail.options.main = `${dir}/views/${detail.options.main}`;
+
+        let foundItemIDs = [];
+        for (let m = 0; m < detail.options.requiredItems.length; m++) {
+            let foundItem = await item.findOne({name: detail.options.requiredItems[m]});
+
+            foundItemIDs.push(foundItem._id);
+        }
+
         let context = {
             siteTitle: "NotherBase | The Front",
             user: null,
@@ -40,18 +49,17 @@ let front = function front(detail) {
             externalStyles: detail.options.externalStyles,
             main: detail.options.main,
             localScripts: detail.options.localScripts,
+            itemIDs: foundItemIDs,
             inventory: null,
             query: req.query
         }
 
         if (connectionSuccess) {
-            context.user = req.session.currentUserFull;
-
             try {
-                const foundInventory = await inventory.findOne({ user: req.session.currentUser }).populate("items.item");
-                context.inventory = foundInventory;
+                context.user = await user.findById(req.session.currentUser);
+                context.inventory = await inventory.findOne({ user: req.session.currentUser }).populate("items.item");
             
-                if (detail.options.needsKey !== "" && foundInventory) {
+                if (detail.options.needsKey !== "" && context.inventory) {
                     let hasKey = false;
     
                     for (let i = 0; i < foundInventory.items.length; i++) {

package/controllers/user.js

@@ -1,15 +1,173 @@
 const express = require("express");
 const router = express.Router();
 const bcrypt = require("bcrypt");
+const nodemailer = require("nodemailer");
 
 // Import my Data
-const { user, inventory } = require("../models");
+const { user, inventory, sendMail } = require("../models");
 
 const authCheck = require("./authCheck");
 
+let getAttributes = async function getAttributes(userID) {
+    try {
+        let foundUser = await user.findById(userID, 'attributes');
+    
+        if (!foundUser.attributes || foundUser.attributes == {}) {
+            foundUser.attributes = {
+                translation: 0,
+                strength: 0,
+                agility: 0,
+                defense: 0
+            }
+    
+            await foundUser.save();
+        }
+    
+        return foundUser;
+    } 
+    catch (err) {
+        console.log(err);
+        return null;
+    }
+}
+
+router.get("/basic", async function(req, res) {
+    try {
+        if (req.session.currentUser) {
+            let foundUser = await user.findById(req.session.currentUser, 'username email');
+    
+            res.status(200).send(foundUser);
+        }
+        else {
+            res.status(401).send("Please login first!");
+        }
+    }
+    catch(err) {
+        console.log(err);
+        res.status(500).end();
+    }
+});
+
+router.get("/logout", authCheck, async function(req, res) {
+    try {
+        await req.session.destroy();
+
+        res.redirect(`/`);
+    }
+    catch {
+        console.log(err);
+    }
+});
+
+router.get("/all", async function(req, res) {
+    try {
+        let foundUsers = await user.find({}, 'username coin home authLevels location attributes');
+
+        res.status(200).send({ foundUsers: foundUsers });
+    }
+    catch(err) {
+        res.status(500).end();
+        console.log(err);
+    }
+});
+
+router.get("/password-reset", async function(req, res) {
+    try {
+        let foundUser = await user.findOne({ email: req.query.email });
+        
+        if (foundUser) {
+            foundUser.reset.token = Math.floor(Math.random() * 9999);
+            foundUser.reset.exp = Date.now() + (1000 * 60 * 30);
+            
+            await foundUser.save();
+
+            sendMail.passwordReset(req.query.email, foundUser.reset.token);
+
+            res.status(200).send("Reset link sent!");
+        }
+        else {
+            res.status(401).send("Failed: user not found!");
+        }
+    }
+    catch(err) {
+        console.log(err);
+
+        res.status(500).send("Update Failed: Database error!");
+    }
+});
+
+router.post("/password-reset/:token", async function(req, res) {
+    try {
+        const foundUser = await user.findOne({ "reset.token": req.params.token });
+
+        if (foundUser) {
+            if (foundUser.reset.exp > Date.now()) {
+                if (req.body.password !== req.body.confirmation) res.status(400).send("Passwords must match!");
+                else {
+                    foundUser.reset = {};
+
+                    const salt = await bcrypt.genSalt(10);
+                    const hash = await bcrypt.hash(req.body.password, salt);
+        
+                    foundUser.password = hash;
+                    await foundUser.save();
+
+                    res.status(200).send("Password changed successfully!");
+                }
+            }
+            else res.status(498).send("Reset token expired!");
+        }
+        else {
+            res.status(404).send("Reset token not valid!");
+        }
+    }
+    catch(err) {
+        console.log(err);
+
+        res.status(500).send("Internal Server Error!");
+    }
+});
+
+router.get("/attributes", async function(req, res) {
+    try {
+        if (req.session.currentUser) {
+            let foundUser = await getAttributes(req.session.currentUser);
+
+            res.status(200).send(foundUser.attributes);
+        }
+        else {
+            res.status(401).send("Please login first!");
+        }
+    }
+    catch(err) {
+        res.status(500).end();
+        console.log(err);
+    }
+});
+
+router.get("/attributes/check", authCheck, async function(req, res) {
+    try {
+        if (req.session.currentUser) {
+            let foundUser = await getAttributes(req.session.currentUser);
+
+            if (foundUser.attributes[req.query.check] >= parseInt(req.query.against)) {
+                res.status(200).send("Pass");
+            }
+            else res.status(200).send("Fail");
+        }
+        else {
+            res.status(401).send("Please login first!");
+        }
+    }
+    catch(err) {
+        res.status(500).end();
+        console.log(err);
+    }
+});
+
 router.post("/register", async function(req, res) {
     try {
-        const foundAccount = await user.findOne({ username: req.body.username });
+        let foundAccount = await user.findOne({ username: req.body.username });
 
         if (!foundAccount) {
             const salt = await bcrypt.genSalt(10);
@@ -18,10 +176,17 @@ router.post("/register", async function(req, res) {
             let qAuth = await user.create({
                 username: req.body.username,
                 password: hash,
-                email: "temp@example.com",
+                email: req.body.email,
                 coin: 0,
                 home: "/",
-                authLevels: [ "Basic" ]
+                authLevels: [ "Basic" ],
+                location: "/the-front",
+                attributes: {
+                    translation: 0,
+                    strength: 0,
+                    agility: 0,
+                    defense: 0
+                }
             });
 
             await inventory.create({
@@ -44,12 +209,11 @@ router.post("/register", async function(req, res) {
 
 router.post("/login", async function(req, res) {
     try {
-        const foundAccount = await user.findOne({ username: req.body.username });
+        const foundAccount = await user.findOne({ email: req.body.email });
 
         if (foundAccount) {
             if (await bcrypt.compare(req.body.password, foundAccount.password)) {
                 req.session.currentUser = foundAccount._id;
-                req.session.currentUserFull = foundAccount;
 
                 res.status(200).send("Login successful!");
             }
@@ -58,7 +222,7 @@ router.post("/login", async function(req, res) {
             }
         }
         else {
-            res.status(401).send("Login Failed: username not found!");
+            res.status(401).send("Login Failed: Email not found!");
         }
     }
     catch(err) {
@@ -68,41 +232,171 @@ router.post("/login", async function(req, res) {
     }
 });
 
-router.get("/logout", authCheck, async function(req, res) {
+router.post("/email", async function(req, res) {
     try {
-        await req.session.destroy();
+        if (req.session.currentUser) {
+            let foundAccount = await user.findOne({ email: req.body.email });
 
-        res.redirect(`/`);
+            if (!foundAccount) {
+                let foundUser = await user.findById(req.session.currentUser);
+
+                if (foundUser) {
+                    foundUser.email = req.body.email;
+                    await foundUser.save();
+
+                    res.status(200).send("Update successful!");
+                }
+                else {
+                    res.status(401).send("Update Failed: user not found!");
+                }
+            }
+            else {
+                res.status(401).send("Update Failed: email already in use!");
+            }
+        }
+        else {
+            res.status(401).send("Please login first!");
+        }
     }
-    catch {
+    catch(err) {
         console.log(err);
+
+        res.status(500).send("Update Failed: Database error!");
     }
 });
 
-router.get("/all", authCheck, async function(req, res) {
+router.post("/username", async function(req, res) {
     try {
-        let foundUsers = await user.find({}, 'username coin home authLevels location');
+        if (req.session.currentUser) {
+            let foundAccount = await user.findOne({ username: req.body.username });
 
-        res.status(200).send({ foundUsers: foundUsers });
+            if (!foundAccount) {
+                let foundUser = await user.findById(req.session.currentUser);
+        
+                if (foundUser) {
+                    foundUser.username = req.body.username;
+                    await foundUser.save();
+        
+                    res.status(200).send("Update successful!");
+                }
+                else {
+                    res.status(401).send("Update Failed: user not found!");
+                }
+            }
+            else {
+                res.status(401).send("Update Failed: username taken!");
+            }
+        }
+        else {
+            res.status(401).send("Please login first!");
+        }
     }
     catch(err) {
-        res.status(500).end();
         console.log(err);
+
+        res.status(500).send("Update Failed: Database error!");
     }
 });
 
-router.delete("/", authCheck, async function(req, res) {
+router.post("/password", async function(req, res) {
+    try {
+        if (req.session.currentUser) {
+            let foundUser = await user.findById(req.session.currentUser);
+        
+            if (foundUser) {
+                const salt = await bcrypt.genSalt(10);
+                const hash = await bcrypt.hash(req.body.password, salt);
+                foundUser.password = hash;
+                await foundUser.save();
+
+                res.status(200).send("Update successful!");
+            }
+            else {
+                res.status(401).send("Update Failed: user not found!");
+            }
+        }
+        else {
+            res.status(401).send("Please login first!");
+        }
+    }
+    catch(err) {
+        console.log(err);
+
+        res.status(500).send("Update Failed: Database error!");
+    }
+});
+
+router.post("/attributes", async function(req, res) {
     try {
-        const found = await user.findByIdAndDelete(req.session.currentUser);
+        if (req.session.currentUser) {
+            let foundUser = await getAttributes(req.session.currentUser);
 
-        if (!found) console.log("Could not find account. No deletion!");
+            if (foundUser) {
+                foundUser.attributes[req.body.change] = parseInt(req.body.to);
+                await foundUser.save();
 
-        await req.session.destroy();
+                res.status(200).send("AttUp successful!");
+            }
+            else {
+                res.status(401).send("AttUp Failed: user not found!");
+            }
+        }
+        else {
+            res.status(401).send("Please login first!");
+        }
+    }
+    catch(err) {
+        console.log(err);
+
+        res.status(500).send("AttUp Failed: Database error!");
+    }
+});
 
-        res.redirect("/");
+router.post("/attributes/increment", async function(req, res) {
+    try {
+        if (req.session.currentUser) {
+            let foundUser = await getAttributes(req.session.currentUser);
+
+            if (foundUser) {
+                if (foundUser.attributes[req.body.change] < req.body.max) {
+                    foundUser.attributes[req.body.change]++;
+                    await foundUser.save();
+                    res.status(200).send({ newLevel: foundUser.attributes[req.body.change] });
+                } 
+                else {
+                    res.status(304).send({ newLevel: foundUser.attributes[req.body.change] });
+                }
+            }
+            else {
+                res.status(401).send("AttUp Failed: user not found!");
+            }
+        }
+        else {
+            res.status(401).send("Please login first!");
+        }
+    }
+    catch(err) {
+        console.log(err);
+
+        res.status(500).send("AttUp Failed: Database error!");
+    }
+});
+
+router.delete("/", authCheck, async function(req, res) {
+    try {
+        if (req.session.currentUser) {
+            await user.findByIdAndDelete(req.session.currentUser);
+            await req.session.destroy();
+
+            res.redirect("/");
+        }
+        else {
+            res.status(401).send("Please login first!");
+        }
     }
     catch {
         console.log(err);
+        res.status(500).send("Delete Failed: Database error!");
     }
 });
 

package/models/index.js

@@ -5,5 +5,6 @@ module.exports = {
     user: require("./user"),
     contact: require("./contact"),
     inventory: require("./inventory"),
-    game: require("./game")
+    game: require("./game"),
+    sendMail: require("./send-mail")
 }

package/models/send-mail.js

@@ -0,0 +1,26 @@
+const nodemailer = require("nodemailer");
+
+const passwordReset = async (toEmail, resetToken) => {
+    var transporter = nodemailer.createTransport({
+        service: 'gmail',
+        auth: {
+          user: process.env.NOREPLY,
+          pass: process.env.NOREPLYPW
+        }
+    });
+      
+    var mailOptions = {
+        from: process.env.NOREPLY,
+        to: toEmail,
+        subject: 'Password Reset for NotherBase',
+        html: `<h1>Your One-Time Password Reset Code: ${resetToken}<h1>`
+    };
+    
+    transporter.sendMail(mailOptions, function(error, info){
+        if (error) console.log(error);
+    });
+};
+
+module.exports = {
+    passwordReset: passwordReset
+};

package/models/user.js

@@ -9,7 +9,17 @@ const user = mongoose.model('users',
         coin: Number,
         home: String,
         authLevels: [ String ],
-        location: String
+        location: String,
+        attributes: {
+            translation: Number,
+            strength: Number,
+            agility: Number,
+            defense: Number
+        },
+        reset: {
+            token: Number,
+            exp: Number
+        }
     })
 );
 

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "notherbase-fs",
-  "version": "1.1.42",
+  "version": "1.2.2",
   "description": "Functions to help make developing for NotherBase easier.",
   "main": "index.js",
   "scripts": {
-    "test": "nodemon test.js"
+    "test": "nodemon test.js",
+    "gmail-auth": "node gmail-auth.js",
+    "gmail-token": "node gmail-token.js"
   },
   "repository": {
     "type": "git",
@@ -23,8 +25,10 @@
     "ejs": "^3.1.6",
     "express": "^4.17.1",
     "express-session": "^1.17.2",
+    "googleapis": "^100.0.0",
     "method-override": "^3.0.0",
     "mongoose": "^6.1.7",
+    "nodemailer": "^6.7.5",
     "serve-favicon": "^2.5.0",
     "socket.io": "^4.4.1"
   }

package/public/styles/account.css

@@ -0,0 +1,41 @@
+.content#account {
+    padding: 10px;
+}
+
+.content#account hr {
+    margin: 10px 0;
+}
+
+.content#account #info {
+    text-align: center;
+    width: 100%;
+    margin-top: 40px;
+}
+
+.content#account .setting {
+    background: var(--darkBgColor);
+    padding: 25px;
+    border-radius: 5px;
+    display: flex;
+    justify-content: center;
+    text-align: center;
+    flex-wrap: wrap;
+}
+
+.content#account p {
+    width: 100%;
+}
+
+.content#account button {
+    width: 40%;
+}
+
+.content#account .edit {
+    background: var(--darkWoodColor);
+    padding: 25px;
+    border-radius: 5px;
+    display: flex;
+    justify-content: center;
+    text-align: center;
+    flex-wrap: wrap;
+}