notherbase-fs 2.0.2 → 3.0.0

package/controllers/creation.js

@@ -5,30 +5,75 @@ export default class Creation {
     constructor() {
         this.router = express.Router();
 
+        //home
         this.router.get("/", function(req, res) { res.redirect("/the-front"); });
-        this.router.get(`/the-front`, this.front);
-        this.router.get(`/the-front/:detail`, this.frontDetail);
-        this.router.get(`/:page`, this.page);
-        this.router.get(`/:region/:area/:poi`, this.poi);
-        this.router.get(`/:region/:area/:poi/:detail`, this.detail);
-        this.router.use(this.void);
+        //the-front
+        this.router.get(`/the-front`, this.explore);
+        this.router.get(`/the-front/:frontDetail`, this.explore);
+        //pages
+        this.router.get(`/:page`, this.explore);
+        //explorer
+        this.router.get(`/:region/:area/:poi`, this.lock, this.explore);
+        this.router.get(`/:region/:area/:poi/:detail`, this.lock, this.explore);
+        //void
+        this.router.use(function(req, res) { 
+            console.log(req.path);
+            res.redirect("/void");
+        });
+    }
+
+    lock = (req, res, next) => {
+        req.lock = true;
+        next();
     }
 
-    explore = async (main, siteTitle, reqUser, req, res, next) => {
+    explore = async (req, res, next) => {
+        let main = `${req.contentPath}`;
+        let siteTitle = `NotherBase - `;
+
+        if (req.params.frontDetail) {
+            main += `/the-front/${req.params.frontDetail}/index`;
+            siteTitle += req.params.frontDetail;
+        }
+        else if (req.params.detail) {
+            main += `/${req.params.region}/${req.params.area}/${req.params.poi}/${req.params.detail}/index`;
+            siteTitle += req.params.detail;
+        }
+        else if (req.params.poi) {
+            main += `/${req.params.region}/${req.params.area}/${req.params.poi}/index`;
+            siteTitle += req.params.poi;
+        }
+        else if (req.params.page) {
+            main += `/${req.params.page}/index`;
+            siteTitle = req.params.page;
+        }
+        else {
+            main += `/the-front/index`;
+            siteTitle += "the-front";
+        }
+
         try {
             if (fs.existsSync(main + ".ejs")) {
-                let user = new req.db.User("user", req.session.currentUser);
-                let userData = await user.recall();
+                let user = await req.db.User.recallOne(req.session.currentUser);
+
+                let userStuff = {
+                    userID: null,
+                    user: null,
+                };
+
+                if (user) userStuff = {
+                    userID: user.id,
+                    user: user.memory.data,
+                };
 
                 let context = {
+                    ...userStuff,
                     siteTitle: siteTitle,
-                    userID: user._ID,
-                    user: userData,
                     main: main,
                     query: req.query,
                     dir: req.frontDir,
                     route: req.path,
-                    requireUser: reqUser
+                    requireUser: req.lock
                 }
 
                 res.render(`explorer`, context);
@@ -40,51 +85,4 @@ export default class Creation {
             res.status(500).end();
         }
     }
-
-    page = async (req, res, next) => {
-        if (fs.existsSync(`${req.contentPath}/pages/${req.params.page}.ejs`)) {
-            let user = new req.db.User("user", req.session.currentUser);
-            let userData = await user.recall();
-    
-            res.render(`${req.contentPath}/pages/${req.params.page}.ejs`, {
-                user: userData,
-                query: req.query
-            });
-        } 
-        else {
-            next();
-        }
-    }
-
-    front = async (req, res, next) => {
-        let main = `${req.contentPath}/the-front/views/index`;
-        this.explore(main, `NotherBase - The Front`, false, req, res, next);
-    }
-
-    frontDetail = async (req, res, next) => {
-        let main = `${req.contentPath}/the-front/views/${req.params.detail}`;
-        this.explore(main, `NotherBase - ${req.params.detail}`, false, req, res, next);
-    }
-
-    poi = async (req, res, next) => {
-        let main = `${req.contentPath}/explorer${req.path}/views/index`;
-        this.explore(main, `NotherBase - ${req.params.poi}`, true, req, res, next);
-    }
-
-    detail = async (req, res, next) => {
-        let main = `${req.contentPath}/explorer/${req.params.region}/${req.params.area}/${req.params.poi}/views/${req.params.detail}`;
-        this.explore(main, `NotherBase - ${req.params.detail}`, true, req, res, next);
-    }
-
-    void = async (req, res) => {
-        res.render(`explorer`, 
-        {
-            siteTitle: "NotherBase | The Void",
-            user: null,
-            inventory: null,
-            main: `${req.contentPath}/void/index`,
-            route: `/void`,
-            requireUser: false
-        });
-    }
 }

package/controllers/spirit-world.js

@@ -1,60 +1,12 @@
 import express from "express";
 import { stripHtml } from "string-strip-html";
-import contact from "./spirits/contact.js";
-import inventory from "./spirits/inventory.js";
-import item from "./spirits/item.js";
-import serve from "./spirits/serve.js";
-import attribute from "./spirits/attribute.js";
-import user from "./spirits/user.js";
-import { check, findUser, loginCheck, success } from "./spirits/util.js";
+import User from "./spirits/user.js";
+import Contact from "./spirits/contact.js";
+import { success, fail } from "./spirits/util.js";
+import fs from 'fs';
 
 export default class SpiritWorld {
-    constructor(io) {
-        this.io = io;
-        this.router = express.Router();
-
-        this.router.post(`/`, this.do);
-
-        this.io.on('connection', this.setupChat);
-
-        Object.assign(this, contact);
-        Object.assign(this, inventory);
-        Object.assign(this, item);
-        Object.assign(this, serve);
-        Object.assign(this, attribute);
-        Object.assign(this, user);
-    }
-
-    do = async (req, res) => {
-        let result = null;
-
-        /* req.body {
-            action: "getUserBasic",
-            route: "/something" (opt),
-            service: "something" (opt),
-            scope: "local" (opt),
-            parent: "id" (opt),
-            _lastUpdate: 0 (opt),
-            data: {} (opt)
-        } */
-        
-        try {
-            if (this[req.body.action]) result = await this[req.body.action](req);
-            else result = {
-                status: "failed",
-                message: `No function with the name ${req.body.action}`,
-                isUpToDate: true,
-                data: {}
-            }
-            
-            res.send(result);
-        } catch (error) {
-            console.log(error);
-            res.send(error);
-        }
-    }
-
-    setupChat = (socket) => {
+    #setupChat = (socket) => {
         socket.join(socket.handshake.query.room);
     
         this.io.to(socket.handshake.query.room).emit("chat message", {
@@ -80,31 +32,62 @@ export default class SpiritWorld {
         });
     }
 
-    recall =  async (req) => {
-        if (req.body.scope === "local") {
-            loginCheck(req);
-            let user = await findUser(req);
-            req.body.parent = user.memory._id;
-        } 
+    constructor(io) {
+        this.io = io;
+        this.router = express.Router();
+        this.user = new User();
+        this.contact = new Contact();
+
+        this.router.post("/serve", this.serve);
+        this.router.get("/load", this.load);
+        this.router.use("/user", this.user.router);
+        this.router.use("/contact-nother", this.contact.router);
+
+        this.io.on('connection', this.#setupChat);
+    }
+
+    load = async (req, res) => {
+        let user = await req.db.User.recallOne(req.session.currentUser);
+
+        let parent = null;
+        if (req.query.scope === "local" && user) parent = user.id;
 
-        let spirit = new req.db.Spirit(req.body);
-        let spiritData = await spirit.recall();
+        let spirit = await req.db.Spirit.recallOne({
+            route: req.query.route,
+            service: req.query.service,
+            scope: req.query.scope,
+            parent: parent
+        });
+
+        if (!spirit) spirit = await req.db.Spirit.create({
+            route: req.query.route,
+            service: req.query.service,
+            scope: req.query.scope,
+            parent: parent
+        }, {});
 
-        check(spiritData, "No spirit found.");
+        if (!spirit.memory.data) spirit.memory.data = {};
 
-        return success("Spirit found.", spiritData);
+        res.send(spirit.memory.data);
     }
 
-    commit =  async (req) => {
-        if (req.body.scope === "local") {
-            loginCheck(req);
-            let user = await findUser(req);
-            req.body.parent = user.memory._id;
-        } 
+    serve = async (req, res) => {
+        try {
+            let scriptPath = `${req.contentPath}${req.body.route}/${req.body.data.script}.js`;
+            
+            let script, result = null;
 
-        let spirit = new req.db.Spirit(req.body);
-        await spirit.commit(req.body.data);
+            if (fs.existsSync(scriptPath)) {
+                let user = await req.db.User.recallOne(req.session.currentUser);
 
-        return success("Spirit updated.");
+                script = await import(scriptPath);
+                result = await script.default(req, user);
+                success(res, "Served.", result);
+            }
+            else fail(res, `Script not found: ${req.body.data.script} at ${scriptPath}`);
+        } catch (error) {
+            console.log(error);
+            fail(res, "Server error");
+        }
     }
 }

package/controllers/spirits/contact.js

@@ -1,16 +1,23 @@
+import express from "express";
 import { success } from "./util.js";
 
-export default {
-    contactNother: async function(req) {
-        req.body.service = "contact";
-        let contact = new req.db.Spirit(req.body);
+export default class Contact {
+    constructor() {
+        this.router = express.Router();
 
-        await contact.commit({
-            user: req.session.currentUser,
-            location: req.body.data.route,
-            content: req.body.data.content
-        });
+        this.router.post(`/`, this.contactNother);
+    }
+
+    contactNother = async function(req, res) {
+        let user = await User.recallOne(req.session.currentUser);
+
+        let spirit = await req.db.Spirit.create({
+            route: "/",
+            service: "nother-contacts",
+            scope: "local",
+            parent: user.id
+        }, req.body);
 
-        return success();
+        success(res, "Message sent.");
     }
 }

package/controllers/spirits/user.js

@@ -1,130 +1,162 @@
+import express from "express";
 import bcrypt from "bcrypt";
-import {loginCheck, check, findUser, fail, success} from "./util.js";
-
-export default {
-    logout: async (req) => {
-        loginCheck(req);
+import { check, success, fail, loginCheck } from "./util.js";
+
+export default class User {
+    constructor() {
+        this.router = express.Router();
+
+        this.router.post("/logout", this.logout);
+        this.router.post("/sendPasswordReset", this.sendPasswordReset);
+        this.router.post("/changePassword", this.changePassword);
+        this.router.post("/register", this.register);
+        this.router.post("/login", this.login);
+        this.router.post("/changeEmail", this.changeEmail);
+        this.router.post("/changeUsername", this.changeUsername);
+        this.router.post("/deletePermanently", this.deletePermanently);
+        this.router.post("/getInventory", this.getInventory);
+        this.router.post("/getAttributes", this.getAttributes);
+    }
 
+    logout = async (req, res) => {
         await req.session.destroy();
 
-        return success("Logged out.");
-    },
-    sendPasswordReset: async (req) => {
-        let reset = new req.db.User("reset");
-
-        let token = Math.floor(Math.random() * 9999);
-
-        await reset.create({
-            email: req.body.data.email, 
-            token: token, 
-            tokenExp: Date.now() + (1000 * 60 * 30)
-        });
-
-        req.db.SendMail.passwordReset(req.body.data.email, token);
-
-        return success("Password reset.", {});
-    },
-    changePassword: async (req) => {
-        let reset = new req.db.User("reset");
-        let resetData = await reset.recallFromData("token", req.body.data.token);
-
-        check(resetData, "Reset token not valid!");
-        check(resetData.tokenExp < Date.now(), "Reset token expired!");
-        check(req.body.data.password !== req.body.data.confirmation, "Passwords must match!");
-
-        const salt = await bcrypt.genSalt(10);
-        const hash = await bcrypt.hash(req.body.data.password, salt);
-
-        let user = new req.db.User("user");
-        let userData = (await user.recallFromData("email", resetData.email)).data;
-
-        userData.password = hash;
-        await user.commit(userData);
-
-        await reset.delete();
-
-        return success("Password changed successfully!");
-    },
-    register: async (req) => {
-        check(req.body.data.password.length > 7, "Password too short.");
-        check(req.body.data.email.length > 7, "Email too short.");
-        check(req.body.data.username.length > 2, "Username too short.");
-
-        let user = new req.db.User("user", req.body.data.email);
-        let userData = await user.recall();
-
-        check(!userData, "Email already in use!");
-
-        const salt = await bcrypt.genSalt(10);
-        const hash = await bcrypt.hash(req.body.data.password, salt);
-
-        await user.create({
-            username: req.body.data.username,
-            password: hash,
-            email: req.body.data.email,
-            coin: 0,
-            home: "/",
-            authLevels: [ "Basic" ],
-            location: "/the-front",
-            attributes: {
-                translation: 0,
-                strength: 0,
-                agility: 0,
-                defense: 0
-            },
-            inventory: []
-        });
-
-        return success("Registration successful!");
-    },
-    login: async (req) => {
-        let user = await findUser(req, req.body.data.email);
+        success(res, "Logged out.");
+    }
 
-        let passResult = await bcrypt.compare(req.body.data.password, user.memory.data.password);
-        check(passResult, "Password doesn't match.");
+    sendPasswordReset = async (req, res) => {
+        let spirit = await req.db.User.recallOne(req.body.data.email);
 
-        req.session.currentUser = req.body.data.email;
+        if (spirit) {
+            let token = Math.floor(Math.random() * 9999);
 
-        return success("Logged in.");
-    },
-    changeUserEmail: async (req) => {
-        loginCheck(req);
+            if (req.body.data.test) console.log("token: " + token);
 
-        let user = new req.db.User("user", req.body.data.email);
-        let userData = await user.recall();
+            spirit.memory.data.resetToken = token;
+            spirit.memory.data.resetExp = Date.now() + (1000 * 60 * 10);
+            await spirit.commit();
+    
+            req.db.SendMail.passwordReset(req.body.data.email, token);
+    
+            success(res, "Password reset token sent.");
+        }
+        else fail(res, "User not found.");
+    }
 
-        check(!userData, "Email already in use!");
+    changePassword = async (req, res) => {
+        if (check(res, req.body.data.token, "No token provided!")){
+            let spirit = await req.db.User.recallOne(req.body.data.email);
+    
+            if (check(res, spirit, "User not found!") &&
+                check(res, spirit.memory.data.resetToken == req.body.data.token, "Reset token not valid!") &&
+                check(res, spirit.memory.data.resetExp > Date.now(), "Reset token expired!") &&
+                check(res, req.body.data.password === req.body.data.confirmation, "Passwords must match!")) 
+            {
+                spirit.memory.data.resetExp = -1;
+        
+                const salt = await bcrypt.genSalt(10);
+                const hash = await bcrypt.hash(req.body.data.password, salt);
+        
+                spirit.memory.data.password = hash;
+                await spirit.commit();
+        
+                success(res, "Password changed successfully!");
+            }
+        }
+    }
 
-        user = await findUser(req);
+    register = async (req, res) => {
+        if (check(res, req.body.data.password.length > 7, "Password too short.") &&
+            check(res, req.body.data.email.length > 7, "Email too short.") &&
+            check(res, req.body.data.username.length > 2, "Username too short.")) 
+        {
+            let spirit = await req.db.User.recallOne(req.body.data.email);
+    
+            if (check(res, !spirit, "Email already in use!")) {
+                spirit = await req.db.User.create(req.body.data.username, req.body.data.password, req.body.data.email);
+        
+                success(res, "Registration successful!");
+            }
+        }
+    }
 
-        user.memory.data.email = req.body.data.email;
-        await user.commit();
+    login = async (req, res) => {
+        let spirit = await req.db.User.recallOne(req.body.data.email);
+        if (check(res, spirit, "User not found.")) {
+            let passResult = await bcrypt.compare(req.body.data.password, spirit.memory.data.password);
+            
+            if (check(res, passResult, "Password doesn't match the email.")) {
+                req.session.currentUser = req.body.data.email;
+        
+                success(res, "Logged in.", spirit.memory.data.username);
+            }
+        }
+    }
 
-        req.session.currentUser = req.body.data.email;
+    changeEmail = async (req, res) => {
+        if (loginCheck(req, res)) {
+            let spirit = await req.db.User.recallOne(req.body.data.email);
+    
+            if (check(res, !spirit, "Email already in use!")) {
+                spirit = await req.db.User.recallOne(req.session.currentUser);
+        
+                spirit.memory.data.email = req.body.data.email;
+                await spirit.commit();
+        
+                req.session.currentUser = req.body.data.email;
+        
+                success(res, "Email changed.");
+            }
+        }
+    }
 
-        return success();
-    },
-    changeUsername: async (req) => {
-        loginCheck(req);
-       
-        let user = new req.db.User("user");
-        let userData = await user.recallFromData("username", req.body.data.username);
-        check(!userData, "Username already in use!");
+    changeUsername = async (req, res) => {
+        if (loginCheck(req, res)) {
+            let spirit = await req.db.User.recallOne(null, req.body.data.username);
+    
+            if (check(res, !spirit, "Username already in use!")) {
+                spirit = await req.db.User.recallOne(req.session.currentUser);
+        
+                spirit.memory.data.username = req.body.data.username;
+                await spirit.commit();
+        
+                success(res, "Username changed");
+            }
+        }
+    }
 
-        user = await findUser(req);
-
-        user.memory.data.username = req.body.data.username;
-        await user.commit();
-
-        return success();
-    },
-    deleteUserPermanently: async (req) => {
-        loginCheck(req);
+    deletePermanently = async (req, res) => {
+        if (loginCheck(req, res)) {
+            let deleted = await req.db.User.delete(req.session.currentUser);
+    
+            if (check(res, deleted > 0, "No account deleted")) {
+                await req.session.destroy();
         
-        await user.findOneAndDelete().where("data.email").equals(req.session.currentUser);
-        await req.session.destroy();
+                success(res, "Account deleted.");
+            }
+        }
+    }
 
-        return success("Account deleted.");
+    getInventory = async (req, res) => {
+        if (loginCheck(req, res)) {
+            let spirit = await req.db.User.recallOne(req.session.currentUser);
+            if (spirit.memory._lastUpdate > req.body._lastUpdate) {
+                let inv = spirit.memory.data.inventory;
+            
+                success(res, "Inventory found", inv, spirit.memory._lastUpdate);
+            }
+            else fail(res, "Inventory up to date.");
+        }
     }
-}
 
+    getAttributes = async (req, res) => {
+        if (loginCheck(req, res)) {
+            let user = await req.db.User.recallOne(req.session.currentUser);
+    
+            if (user.memory._lastUpdate > req.body._lastUpdate) {
+                success(res, "Attributes found", user.memory.data.attributes);
+            }
+            else fail(res, "Attributes up to date.");
+        }
+    }
+}

package/controllers/spirits/util.js

@@ -1,39 +1,31 @@
-export let loginCheck = (req) => {
-    check(req.session.currentUser, "Please login first.");
-}
-
-export let findUser = async (req, email = req.session.currentUser) => {
-    let user = new req.db.User("user", email);
-    let userData = await user.recall();
-
-    check(userData, "User not found.");
-
-    return user;
-}
-
-export let check = (checkee, failMsg) => {
-    if (!checkee) throw {
-        status: "failed",
-        message: failMsg,
-        isUpToDate: true,
-        data: null
-    };
-}
+export const check = (res, checkee, failMsg = "Failed!") => {
+    if (!checkee) {
+        fail(res, failMsg);
+        return false;
+    }
+    else {
+        return true;
+    }
+};
 
-export let success = (msg = "Update successful.", data = null, isUpToDate = false) => {
-    return {
+export const success = (res, msg = "Success!", data = null, lastUpdate = 0) => {
+    res.send({
         status: "success",
         message: msg,
-        isUpToDate: isUpToDate,
+        lastUpdate: lastUpdate,
         data: data
-    };
-}
+    });
+};
 
-export let fail = (msg, data = null, isUpToDate = true) => {
-    return {
+export const fail = (res, msg = "Failed!") => {
+    res.send({
         status: "failed",
         message: msg,
-        isUpToDate: isUpToDate,
-        data: data
-    }
+        lastUpdate: 0,
+        data: null
+    });
+};
+
+export const loginCheck = (req, res) => {
+    return check(res, req.session.currentUser, "Please login first.");
 }