benkyd/note-service-server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

redid database structures and now running SQLite and Seqelize

Browse Source
This commit is contained in:
plane000
2018-08-27 17:53:45 +01:00
parent c11aab31a0
commit 1ac8ea9b96
12 changed files with 899 additions and 251 deletions
Download Patch File Download Diff File Expand all files Collapse all files

788
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

4
package.json
View File

@@ -9,7 +9,9 @@
"express": "^4.16.3",
"json-stringify-safe": "^5.0.1",
"mysql": "^2.16.0",
"regenerator-runtime": "^0.12.1"
"regenerator-runtime": "^0.12.1",
"sequelize": "^4.38.0",
"sqlite3": "^4.0.2"
},
"devDependencies": {
"babel-preset-env": "^1.7.0",

10
scripts/users.sql
View File

@@ -13,5 +13,13 @@ CREATE TABLE `notes`.`Users` (
`admin` tinyint(4) DEFAULT NULL
)
ENGINE=InnoDB DEFAULT CHARSET=latin1;
ALTER TABLE `notes`.`Users` ADD PRIMARY KEY (`id`);
CREATE TABLE `notes`.`session` (
`session_id` VARCHAR(32) NOT NULL,
`session_data` TEXT NOT NULL,
`t_created` bigint(20) NOT NULL,
`t_updated`bigint(20) NOT NULL,
PRIMARY KEY (`session_id`)
)

16
src/app.js
View File

@@ -1,15 +1,25 @@
import {Logger} from './models/logger';
import {Config} from './config/config'
import {DbTools} from './models/database/tools';
import {Database} from './models/database/database';
import {Server} from './server';
import {Router} from './controllers/routes/router';
init();
async function init() {
Logger.SetLevel(Logger.VERBOSE_LOGS);
await Config.load();
await DbTools.connect();
await DbTools.testConnection();
await Database.init();
await Database.testConnection();
await Server.start();
await Router.initEndpoints();
}
// Logger.database('Database Log');
// Logger.debug('Debug mode enabled');
// Logger.info('Informatic log');
// Logger.warn('Warning');
// Logger.error('An error has occured');
// Logger.panic('A fatal error has occured, exiting');

5
src/controllers/routes/router.js
View File

@@ -11,10 +11,11 @@ export class Router {
Logger.info('Setting up API HTTP endpoints');
app = Server.App;
app.get('/', [MiddleWare.analytics, Router.frontPage]);
app.get('/user/:id', (req, res) => [MiddleWare.analytics]);
app.delete('/user/:id', (req, res) => {});
app.get('/user/:id', [MiddleWare.analytics]);
app.delete('/user/:id', [MiddleWare.analytics]);
app.post('/user', [MiddleWare.analytics, Controllers.UserController.newUser]);
app.use([MiddleWare.analytics, StatusCodes.pageNotFound]);

5
src/controllers/user.js
View File

@@ -4,6 +4,11 @@ import {ControllerHandler} from './controllerHandler';
export class UserController extends ControllerHandler {
static newUser(req, res, next) {
Logger.info('NEW USER');
let username = req.body.username || null;
let email = req.body.email || null;
let password = req.body.password || null;
next();
}
}

75
src/models/database/baseDatabase.js Normal file
View File

@@ -0,0 +1,75 @@
import Sequelize from 'sequelize';
import {Logger} from '../logger';
import {Config} from '../../config/config';
let connection;
let user;
let auth;
let session;
export class BaseDatabase {
static get Connection() {return connection}
static async init() {
Logger.info('Connecting to SQLite Database');
connection = new Sequelize('database', 'user', 'password', {
host: 'localhost',
dialect: 'sqlite',
logging: Logger.database,
operatorsAliases: false,
storage: 'src/models/database/sqlite/database.sqlite',
});
user = connection.define('user', {
id: {
type: Sequelize.BIGINT,
primaryKey: true,
unique: true
},
username: Sequelize.TEXT,
password: Sequelize.TEXT,
email: Sequelize.TEXT,
ip: Sequelize.TEXT,
lastupdated: Sequelize.TEXT,
verified: Sequelize.BOOLEAN,
authcode: Sequelize.STRING,
timeauthed: Sequelize.TEXT
});
auth = connection.define('auth', {
id: {
type: Sequelize.BIGINT,
primaryKey: true,
unique: true
},
selector: Sequelize.TEXT,
validator: Sequelize.TEXT,
uid: Sequelize.BIGINT,
expires: Sequelize.TEXT
});
session = connection.define('session', {
sessionid: {
type: Sequelize.BIGINT,
primaryKey: true,
unique: true
},
sessiondata: Sequelize.TEXT,
timecreated: Sequelize.TEXT,
timeupdated: Sequelize.TEXT
});
try {
await connection.sync();
} catch (e) {
Logger.panic('Failed to connect to SQLite Database, error:', e)
}
Logger.info('Connected to SQLite Database');
}
static async testConnection() {
}
}

48
src/models/database/database.js
View File

@@ -1,41 +1,29 @@
import mysql from 'mysql';
import Sequelize from 'sequelize';
import {BaseDatabase} from './baseDatabase';
import {Logger} from '../logger';
import {Config} from '../../config/config';
let connection;
export class Database extends BaseDatabase {
static async exec(query) {
let connection = BaseDatabase.Connection;
let res;
export class Database {
static get Connection() {return connection}
static async connect() {
Logger.info('Connecting to mySQL database');
let promise = new Promise((resolve, reject) => {
connection = mysql.createConnection(Config.Database);
connection.connect((err) => {
if (err) {
Logger.panic('Failed to connect to the database as user ' + Config.Database.user);
reject();
}
Logger.info('Connected to mySQL as id ' + connection.threadId);
connection
.query(query)
.then(result => {
res = result[0][0].result;
resolve();
})
.catch(err => {
Logger.error('An error occured while querying a database: ' + err);
reject()
});
});
await promise;
return res;
}
}
static async testConnection() {
let promise = new Promise((resolve, reject) => {
connection.query('SELECT 1 + 1 AS solution', async function (err, results, fields) {
if (err) {
Logger.panic('Failed to query the database');
reject();
}
Logger.info('Database connection tested and secure');
resolve();
});
});
await promise;
}
}
Database.users = require('./users').UserTools;

BIN
src/models/database/sqlite/database.sqlite Normal file
View File

Binary file not shown.

152
src/models/database/tools.js
View File

@@ -1,152 +0,0 @@
import {Database} from './database';
import {Logger} from '../logger';
export class DbTools extends Database {
static async getRow(table, id) {
let connection = Database.Connection;
let res;
let promise = new Promise((resolve, reject) => {
connection.query(`SELECT * FROM \`${table}\` WHERE \`${table}\`.\`id\` = '${id}';`, async(err, results, fields) => {
if (err) {
Logger.warn(`Error querying ${table} with ${id}`);
return -1;
reject();
}
res = results;
resolve();
});
});
await promise;
if (res[0]) {
return res[0];
} else {
return -1;
}
}
static async getID(table, column, term) {
let connection = Database.Connection;
let res;
let promise = new Promise((resolve, reject) => {
connection.query(`SELECT \`id\` FROM \`${table}\` WHERE \`${table}\`.\`${column}\` = '${term}';`, async(err, results, fields) => {
if (err) {
Logger.warn(`Error querying ${table}'s ${column} with ${term}`);
return -1;
reject();
}
res = results;
resolve();
});
});
await promise;
let id = 0;
if (res[0]) {
id = res[0].id;
} else {
id = 0;
}
return id;
}
static async createUser(id, username, password, email, phone, ip, token, lastupdated, admin, authcode) {
let connection = Database.Connection;
let promise = new Promise((resolve, reject) => {
connection.query(`INSERT INTO \`Users\` (\`id\`, \`username\`, \`password\`, \`email\`, \`phone\`, \`ip\`, \`token\`, \`lastupdated\`, \`verified\`, \`authcode\`, \`timeauthed\`,\`admin\`) VALUES ('${id}', '${username}', '${password}', '${email}', '${phone}', '${ip}', '${token}', '${lastupdated}', '0', '${authcode}', 'UNAUTHORISED', '${admin}');` , async(err, results, fields) => {
if (err) {
Logger.warn(`Error inserting user ${username}`);
return -1;
reject();
}
resolve();
});
});
await promise;
}
static async deleteUser(id) {
let connection = Database.Connection;
let promise = new Promise((resolve, reject) => {
connection.query(`DELETE FROM \`Users\` WHERE \`id\` = '${id}'`, async(err, results, fields) => {
if(err) {
Logger.warn(`Error deleting User at ID ${id}`);
return -1;
reject();
}
resolve();
});
});
await promise;
return 1;
}
static async updateUserIP(id, ip) {
let connection = Database.Connection;
let promise = new Promise((resolve, reject) => {
connection.query(`UPDATE \`Users\` SET \`ip\` = '${ip}' WHERE \`Users\`.\`id\` = '${id}'`, async(err, results, fields) => {
if(err) {
Logger.warn(`Error updating User ip at ID ${id}`);
return -1;
reject();
}
resolve();
});
});
await promise;
return 1;
}
static async authUser(id, timeauthed) {
let connection = Database.Connection;
let promise = new Promise((resolve, reject) => {
connection.query(`UPDATE \`Users\` SET \`verified\` = '1' WHERE \`Users\`.\`id\` = '${id}'`, async(err, results, fields) => {
if(err) {
Logger.warn(`Error authorizing User at ID ${id}`);
return -1;
reject();
}
resolve();
});
});
await promise;
let promise1 = new Promise((resolve, reject) => {
connection.query(`UPDATE \`Users\` SET \`timeauthed\` = '${timeauthed}' WHERE \`Users\`.\`id\` = '${id}'`, async(err, results, fields) => {
if(err) {
Logger.warn(`Error authorizing User at ID ${id}`);
return -1;
reject();
}
resolve();
});
});
await promise1;
return 1;
}
static async exec(cmd) {
let connection = Database.Connection;
let res;
let promise = new Promise((resolve, reject) => {
connection.query(cmd, async(err, results, fields) => {
if (err) {
Logger.warn(`Error executing ${cmd} on the database`);
return -1;
reject();
}
res = results;
resolve();
})
});
await promise;
return res;
}
}

11
src/models/database/users.js Normal file
View File

@@ -0,0 +1,11 @@
import Sequelize from 'sequelize';
import {BaseDatabase} from './baseDatabase';
import {Logger} from '../logger';
import {Config} from '../../config/config';
export class UserTools extends BaseDatabase {
static async testing() {
Logger.debug('Hello, world!');
}
}

30
src/models/logger.js
View File

@@ -1,29 +1,51 @@
const colours = require('colors/safe');
let LogLevel = 1;
export class Logger {
static SetLevel(level) {
LogLevel = level;
}
static get VERBOSE_LOGS() {return 0;}
static get DEBUG_LOGS() {return 1;}
static get INFO_LOGS() {return 2;}
static get WARN_LOGS() {return 3;}
static database(message) {
if (LogLevel > 0) return;
let d = new Date();
console.log('[' + d.toLocaleString() + '] ['
+ colours.magenta('SQLITE') + '] ' + message);
}
static debug(message) {
if (LogLevel > 1) return;
let d = new Date();
console.log('[' + d.toLocaleString() + '] ['
+ colours.cyan('DEBUG') + '] ' + message);
}
static info(message) {
if (!message) throw 'No message defined';
if (LogLevel > 2) return;
let d = new Date();
console.log('[' + d.toLocaleString() + '] ['
+ colours.green('INFO') + '] ' + message);
}
static warn(message) {
if (!message) throw 'No message defined';
if (LogLevel > 3) return;
let d = new Date();
console.log('[' + d.toLocaleString() + '] ['
+ colours.yellow('WARN') + '] ' + message);
}
static error(message) {
if (!message) throw 'No message defined';
let d = new Date();
console.log('[' + d.toLocaleString() + '] ['
+ colours.red('ERROR') + '] ' + message);
}
static panic(message) {
if (!message) throw 'No message defined';
let d = new Date();
console.log('[' + d.toLocaleString() + '] ['
+ colours.red('PANIC') + '] ' + message);