notherbase-fs 1.5.3 → 2.0.1

package/controllers/creation.js

@@ -0,0 +1,90 @@
+import express from "express";
+import fs from 'fs';
+
+export default class Creation {
+    constructor() {
+        this.router = express.Router();
+
+        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);
+    }
+
+    explore = async (main, siteTitle, reqUser, req, res, next) => {
+        try {
+            if (fs.existsSync(main + ".ejs")) {
+                let user = new req.db.User("user", req.session.currentUser);
+                let userData = await user.recall();
+
+                let context = {
+                    siteTitle: siteTitle,
+                    userID: user._ID,
+                    user: userData,
+                    main: main,
+                    query: req.query,
+                    dir: req.frontDir,
+                    route: req.path,
+                    requireUser: reqUser
+                }
+
+                res.render(`explorer`, context);
+            }
+            else next();
+        }
+        catch(err) {
+            console.log(err);
+            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

@@ -0,0 +1,110 @@
+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";
+
+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) => {
+        socket.join(socket.handshake.query.room);
+    
+        this.io.to(socket.handshake.query.room).emit("chat message", {
+            name: "Server",
+            time: Date.now(),
+            text: `${socket.handshake.query.name} has joined the room.`
+        });
+    
+        socket.on("chat message", (msg) => {
+            this.io.to(socket.handshake.query.room).emit("chat message", {
+                name: msg.name,
+                time: msg.time,
+                text: stripHtml(msg.text).result
+            });
+        });
+    
+        socket.on('disconnect', () => {
+            this.io.to(socket.handshake.query.room).emit("chat message", {
+                name: "Server",
+                time: Date.now(),
+                text: `${socket.handshake.query.name} has left the room.`
+            });
+        });
+    }
+
+    recall =  async (req) => {
+        if (req.body.scope === "local") {
+            loginCheck(req);
+            let user = await findUser(req);
+            req.body.parent = user.memory._id;
+        } 
+
+        let spirit = new req.db.Spirit(req.body);
+        let spiritData = await spirit.recall();
+
+        check(spiritData, "No spirit found.");
+
+        return success("Spirit found.", spiritData);
+    }
+
+    commit =  async (req) => {
+        if (req.body.scope === "local") {
+            loginCheck(req);
+            let user = await findUser(req);
+            req.body.parent = user.memory._id;
+        } 
+
+        let spirit = new req.db.Spirit(req.body);
+        await spirit.commit(req.body.data);
+
+        return success("Spirit updated.");
+    }
+}

package/controllers/spirits/attribute.js

@@ -0,0 +1,47 @@
+import {loginCheck, check, findUser, fail, success} from "./util.js";
+
+export default {
+    attributes: async (req) => {
+        loginCheck(req);
+
+        let user = await findUser(req);
+
+        return success("Got user attributes.", user.memory.data.attributes);
+    },
+    checkAttribute: async (req) => {
+        loginCheck(req);
+
+        let user = await findUser(req);
+        let att = user.memory.data.attributes;
+
+        if (att[req.body.data.check] >= req.body.data.against) {
+            return success("Passed check.")
+        }
+        else return fail("Failed check.");
+    },
+    setAttribute: async (req) => {
+        loginCheck(req);
+
+        let user = await findUser(req);
+
+        user.memory.data.attributes[req.body.data.change] = req.body.data.to;
+        await user.commit();
+
+        return success("Attributes set.", user.memory.data.attributes);
+    },
+    incrementAttribute: async (req) => {
+        loginCheck(req);
+
+        let user = await findUser(req);
+        let att = user.memory.data.attributes;
+
+        if (att[req.body.data.change] < req.body.data.max) {
+            att[req.body.data.change]++;
+            await user.commit();
+
+            return success("Attribute incremented.", att[req.body.data.change]);
+        } 
+        else return fail("Attribute maxed.", att[req.body.data.change]);
+    }
+}
+

package/controllers/spirits/contact.js

@@ -0,0 +1,16 @@
+import { success } from "./util.js";
+
+export default {
+    contactNother: async function(req) {
+        req.body.service = "contact";
+        let contact = new req.db.Spirit(req.body);
+
+        await contact.commit({
+            user: req.session.currentUser,
+            location: req.body.data.route,
+            content: req.body.data.content
+        });
+
+        return success();
+    }
+}

package/controllers/spirits/inventory.js

@@ -0,0 +1,71 @@
+import { success, check, loginCheck, findUser } from "./util.js";
+
+export default {
+    getUserInventory: async (req) => {
+        loginCheck(req);
+        let user = await findUser(req);
+        let inv = user.memory.data.inventory;
+
+        check(inv, "User inventory not found.");
+    
+        return success("User inventory found.", inv);
+    },
+    updateItemInInventory: async (req) => {
+        check(req.body.data.name && req.body.data.amount, `${req.body.data.name} ${req.body.data.amount} Check Input!`);
+
+        let item = new req.db.Item(req.body.data.name);
+        let itemData = await item.recall();
+
+        check(itemData, "Item not found in database.");
+
+        let user = await findUser(req);
+        let inv = user.memory.data.inventory;
+
+        let holding = false;
+
+        for (let j = 0; j < inv.length; j++) {
+            if (inv[j].name === req.body.data.name) {
+                holding = true;
+
+                if (inv[j].amount >= -Math.floor(req.body.data.amount)) {
+                    inv[j].amount += Math.floor(req.body.data.amount);
+
+                    if (inv[j].amount === 0) {
+                        let empty = inv[j];
+
+                        inv.splice(j, 1);
+                        await user.commit();
+
+                        return success("Item emptied.", empty);
+                    }
+                    else {
+                        await user.commit();
+
+                        return success("Item offset.", inv[j]);
+                    }
+                }
+                else {
+                    return fail(`Unable to remove ${req.body.data.amount} ${req.body.data.name} 
+                        from inventory because the inventory has only ${inv[j].amount}.` );
+                }
+            }
+        }
+        
+        if (!holding) {
+            if (req.body.data.amount > 0) {
+                inv.push({
+                    name: req.body.data.name,
+                    amount: req.body.data.amount
+                });
+
+                await user.commit();
+
+                return success("Item offset.", inv[inv.length - 1]);
+            }
+            else {
+                return fail(`Unable to remove ${req.body.data.amount} ${req.body.data.name} 
+                    from inventory because the inventory has none.`);
+            }
+        };
+    }
+}

package/controllers/spirits/item.js

@@ -0,0 +1,41 @@
+import { success, check } from "./util.js";
+
+export default {
+    getAllItems: async (req) => {
+        let items = new req.db.Item();
+        let all = await items.getAll();
+
+        check(all, "Items not found.");
+
+        return success("Found items.", all);
+    },
+    getItem: async (req) => {
+        let item = new req.db.Item(req.body.data.name);
+
+        let itemData = await item.recall();
+
+        check(itemData, `Item not found: ${req.body.data.name}`);
+
+        return success("Found item.", itemData);
+    },
+    setItem: async (req) => {
+        let item = new req.db.Item(req.body.data.name);
+
+        await item.commit(req.body.data);
+
+        return success();
+    },
+    newItem: async (req) => {
+        let item = new req.db.Item(req.body.data.name);
+
+        await item.create(req.body.data);
+
+        return success();
+    },
+    deleteItem: async (req) => {
+        let item = new req.db.Item(req.body.data.name);
+        item.delete();
+
+        return success("Item deleted.");
+    }
+}

package/controllers/spirits/serve.js

@@ -0,0 +1,33 @@
+import { findUser, success, fail } from "./util.js";
+import fs from "fs";
+
+let serve = async (req, scriptPath) => {
+    let script, result = null;
+
+    if (fs.existsSync(scriptPath)) {
+        let user = findUser(req);
+
+        script = await import(scriptPath);
+        result = await script.default(req, user);
+        return success("Served.", result);
+    }
+    else return fail(`Script not found: ${req.body.data.script} at ${scriptPath}`);
+}
+
+export default {
+    serveExplorer: async (req) => {
+        let scriptPath = `${req.contentPath}/explorer${req.body.route}/server-scripts/${req.body.data.script}.js`;
+        
+        return serve(req, scriptPath);
+    },
+    serveFront: async (req) => {
+        let scriptPath = `${req.contentPath}/the-front/server-scripts/${req.body.data.script}.js`;
+        
+        return serve(req, scriptPath);
+    },
+    servePages: async (req) => {
+        let scriptPath = `${req.contentPath}/pages/server-scripts/${req.body.data.script}.js`;
+        
+        return serve(req, scriptPath);
+    }
+}

package/controllers/spirits/user.js

@@ -0,0 +1,130 @@
+import bcrypt from "bcrypt";
+import {loginCheck, check, findUser, fail, success} from "./util.js";
+
+export default {
+    logout: async (req) => {
+        loginCheck(req);
+
+        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);
+
+        let passResult = await bcrypt.compare(req.body.data.password, user.memory.data.password);
+        check(passResult, "Password doesn't match.");
+
+        req.session.currentUser = req.body.data.email;
+
+        return success("Logged in.");
+    },
+    changeUserEmail: async (req) => {
+        loginCheck(req);
+
+        let user = new req.db.User("user", req.body.data.email);
+        let userData = await user.recall();
+
+        check(!userData, "Email already in use!");
+
+        user = await findUser(req);
+
+        user.memory.data.email = req.body.data.email;
+        await user.commit();
+
+        req.session.currentUser = req.body.data.email;
+
+        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!");
+
+        user = await findUser(req);
+
+        user.memory.data.username = req.body.data.username;
+        await user.commit();
+
+        return success();
+    },
+    deleteUserPermanently: async (req) => {
+        loginCheck(req);
+        
+        await user.findOneAndDelete().where("data.email").equals(req.session.currentUser);
+        await req.session.destroy();
+
+        return success("Account deleted.");
+    }
+}
+

package/controllers/spirits/util.js

@@ -0,0 +1,39 @@
+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 let success = (msg = "Update successful.", data = null, isUpToDate = false) => {
+    return {
+        status: "success",
+        message: msg,
+        isUpToDate: isUpToDate,
+        data: data
+    };
+}
+
+export let fail = (msg, data = null, isUpToDate = true) => {
+    return {
+        status: "failed",
+        message: msg,
+        isUpToDate: isUpToDate,
+        data: data
+    }
+}