372 lines
10 KiB
JavaScript
372 lines
10 KiB
JavaScript
import mysql from 'mysql';
|
|
import semver from 'semver';
|
|
|
|
import { fatal, getVersion, stripTimezone } from './utils';
|
|
import { NotFoundError, attachNoun } from './errors';
|
|
|
|
const DATABASE = 'chronos';
|
|
|
|
export default class Database {
|
|
constructor(options) {
|
|
this.connection = mysql.createConnection(options);
|
|
this.connection.connect();
|
|
|
|
this.checkAndMigrate();
|
|
}
|
|
|
|
async getSchools() {
|
|
return this.query(`
|
|
SELECT id, name, domain
|
|
FROM school
|
|
`);
|
|
}
|
|
async getSchoolWithAuth(id) {
|
|
return this.query(`
|
|
SELECT *
|
|
FROM auth RIGHT JOIN school
|
|
ON auth.school = school.id
|
|
WHERE school.${isNaN(parseInt(id, 10)) ? 'domain' : 'id'} = ?
|
|
`, [id], {
|
|
required: true,
|
|
})
|
|
.then(results => ({
|
|
id: results[0].id,
|
|
name: results[0].name,
|
|
domain: results[0].domain,
|
|
auth: results[0].type ? results.map(r => Object.assign(r, {
|
|
school: undefined,
|
|
name: undefined,
|
|
domain: undefined,
|
|
})) : [],
|
|
}))
|
|
.catch(attachNoun('School'));
|
|
}
|
|
|
|
// eslint-disable-next-line class-methods-use-this
|
|
async getUsers(school) {
|
|
return this.query(`
|
|
SELECT id, name
|
|
FROM user
|
|
WHERE user.school = ?
|
|
`, [school]);
|
|
}
|
|
async getUser(school, id) {
|
|
return this.query(`
|
|
SELECT *
|
|
FROM user
|
|
WHERE user.school = ?
|
|
AND user.id = ?
|
|
`, [school, id], {
|
|
single: true,
|
|
})
|
|
.catch(attachNoun('User'));
|
|
}
|
|
async getUserByEmail(school, email) {
|
|
// assumes unique email
|
|
return this.query(`
|
|
SELECT *
|
|
FROM user
|
|
WHERE user.school = ?
|
|
AND user.email = ?
|
|
`, [school, email], {
|
|
single: true,
|
|
})
|
|
.catch(attachNoun('User'));
|
|
}
|
|
async getUserGroups(school, id) {
|
|
return this.query(`
|
|
SELECT group_.*
|
|
FROM member, group_
|
|
WHERE member.group_ = group_.id
|
|
AND member.user = ?
|
|
`, [id])
|
|
.catch(attachNoun('Group'));
|
|
}
|
|
|
|
async getGroups(school) {
|
|
return this.query(`
|
|
SELECT group_.*
|
|
FROM user, member, group_
|
|
WHERE member.group_ = group_.id
|
|
AND member.user = user.id
|
|
AND user.school = ?
|
|
`, [school]);
|
|
}
|
|
async createGroup(school, data) {
|
|
console.log(data);
|
|
const group = await this.query(`
|
|
INSERT INTO group_ (name, type)
|
|
VALUES (?, ?)
|
|
`, [data.name, data.type]);
|
|
if (data.type === 'MEN') {
|
|
await this.query(`
|
|
INSERT INTO group_mentor (id, level, year)
|
|
VALUES (?, ?, ?)
|
|
`, [group.insertId, data.mentor_level, data.mentor_year]);
|
|
}
|
|
const insertMember = u => this.query(`
|
|
INSERT INTO member (user, group_)
|
|
VALUES (?, ?)
|
|
`, [u, group.insertId]);
|
|
return Promise.all(data.members.map(insertMember));
|
|
}
|
|
async getGroup(school, id) {
|
|
const getGroup = this.query(`
|
|
SELECT *
|
|
FROM group_
|
|
WHERE group_.id = ?
|
|
`, [id], {
|
|
required: true,
|
|
single: true,
|
|
}).catch(attachNoun('Group'));
|
|
const getMembers = this.query(`
|
|
SELECT user.*
|
|
FROM member, user
|
|
WHERE member.user = user.id
|
|
AND member.group_ = ?
|
|
`, [id]);
|
|
const getEventsOnce = this.query(`
|
|
SELECT *
|
|
FROM event_once
|
|
WHERE event_once.group_ = ?
|
|
`, [id]);
|
|
const getEventsWeekly = this.query(`
|
|
SELECT *
|
|
FROM event_weekly
|
|
WHERE event_weekly.group_ = ?
|
|
`, [id]);
|
|
return Promise.all([getGroup, getMembers, getEventsOnce, getEventsWeekly])
|
|
.then(results => Object.assign({}, results[0], {
|
|
members: results[1].map(m => Object.assign(m, {
|
|
pwd_hash: undefined,
|
|
oid_id: undefined,
|
|
})),
|
|
eventsOnce: results[2],
|
|
eventsWeekly: results[3],
|
|
}));
|
|
}
|
|
|
|
async createEventWeekly(school, group, data) {
|
|
console.log(data.starttime);
|
|
return this.query(`
|
|
INSERT INTO event_weekly (group_, name, day, starttime, endtime)
|
|
VALUES (?, ?, ?, ?, ?)
|
|
`, [group, data.name, data.day, stripTimezone(data.starttime), stripTimezone(data.endtime)]);
|
|
}
|
|
|
|
async createEventOnce(school, group, data) {
|
|
console.log(data.starttime);
|
|
return this.query(`
|
|
INSERT INTO event_once (group_, name, start, end)
|
|
VALUES (?, ?, ?, ?)
|
|
`, [group, data.name, stripTimezone(data.start), stripTimezone(data.end)]);
|
|
}
|
|
async getEventOnce(school, group, id) {
|
|
return this.query(`
|
|
SELECT *
|
|
FROM event_once
|
|
WHERE event_once.group_ = ?
|
|
AND event_once.id = ?
|
|
`, [group, id]);
|
|
}
|
|
|
|
// eslint-disable-next-line
|
|
async getEventClashesWith(school, group, id) {
|
|
// TODO
|
|
}
|
|
|
|
async getUserEventsBetween(school, user, start, end) {
|
|
// oh shit
|
|
const getEventsOnce = this.query(`
|
|
SELECT event_once.*
|
|
FROM member, event_once
|
|
WHERE member.group_ = event_once.group_
|
|
AND member.user = ?
|
|
|
|
AND (
|
|
(event_once.start >= ? AND event_once.start <= ?)
|
|
OR
|
|
(event_once.end >= ? AND event_once.end <= ?)
|
|
)
|
|
`, [user, stripTimezone(start), stripTimezone(end), stripTimezone(start), stripTimezone(end)]);
|
|
const getEventsWeekly = this.query(`
|
|
SELECT event_weekly.*
|
|
FROM member, event_weekly
|
|
WHERE member.group_ = event_weekly.group_
|
|
AND member.user = ?
|
|
`, [user]);
|
|
return Promise.all([getEventsOnce, getEventsWeekly])
|
|
.then(results => ({ eventsOnce: results[0], eventsWeekly: results[1] }));
|
|
}
|
|
|
|
query(query, values, options = {}) {
|
|
console.log('QUERY:', query.replace(/[\n\t]+/g, ' ').replace(/^ /g, '').replace(/ $/g, ''));
|
|
return new Promise((resolve, reject) => {
|
|
this.connection.query(query, values, (err, results, fields) => {
|
|
if (err) {
|
|
reject(err);
|
|
} else if ((options.required || options.single) && results.length < 1) {
|
|
reject(new NotFoundError());
|
|
}
|
|
if (options.single) {
|
|
resolve(results[0], fields);
|
|
} else {
|
|
resolve(results, fields);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
async checkAndMigrate() {
|
|
return this.query(`CREATE DATABASE IF NOT EXISTS ${DATABASE}`)
|
|
.then(() => this.query(`USE ${DATABASE}`))
|
|
.then(() => this.query('SELECT * FROM options WHERE option = ?', ['VERSION'])
|
|
.then(result => this.migrate(result[0] ? result[0].value : null))
|
|
.catch(() => this.migrate()))
|
|
.catch(err => fatal(err));
|
|
}
|
|
|
|
async migrate(oldVersion) {
|
|
if (semver.satisfies(oldVersion, '~1')) {
|
|
// database is up-to-date
|
|
return true;
|
|
} else if (semver.satisfies(oldVersion, '~0')) { // lmao forces database migration
|
|
return true;
|
|
// database needs to be updated
|
|
// return this.query(`DROP DATABASE ${DATABASE}`)
|
|
// .then(() => this.checkAndMigrate());
|
|
}
|
|
// database does not exist
|
|
|
|
// create tables
|
|
const tables = [
|
|
`CREATE TABLE options (
|
|
option VARCHAR(12) NOT NULL,
|
|
value VARCHAR(64) NOT NULL,
|
|
PRIMARY KEY (option)
|
|
)`,
|
|
`CREATE TABLE school (
|
|
id INT NOT NULL AUTO_INCREMENT,
|
|
name VARCHAR(64) NOT NULL,
|
|
domain VARCHAR(32),
|
|
PRIMARY KEY (id)
|
|
)`,
|
|
`CREATE TABLE auth (
|
|
school INT NOT NULL,
|
|
id INT NOT NULL,
|
|
type CHAR(3) NOT NULL,
|
|
oid_meta VARCHAR(128),
|
|
oid_cid VARCHAR(64),
|
|
oid_csecret VARCHAR(64),
|
|
PRIMARY KEY (school, id),
|
|
FOREIGN KEY (school) REFERENCES school(id) ON DELETE CASCADE ON UPDATE CASCADE
|
|
)`,
|
|
`CREATE TABLE holiday (
|
|
id INT NOT NULL AUTO_INCREMENT,
|
|
name VARCHAR(64) NOT NULL,
|
|
start DATETIME NOT NULL,
|
|
end DATETIME NOT NULL,
|
|
PRIMARY KEY (id)
|
|
)`,
|
|
`CREATE TABLE observes (
|
|
school INT NOT NULL,
|
|
holiday INT NOT NULL,
|
|
FOREIGN KEY (school) REFERENCES school(id) ON DELETE CASCADE ON UPDATE CASCADE,
|
|
FOREIGN KEY (holiday) REFERENCES holiday(id) ON DELETE CASCADE ON UPDATE CASCADE
|
|
)`,
|
|
`CREATE TABLE user (
|
|
school INT NOT NULL,
|
|
id INT AUTO_INCREMENT NOT NULL,
|
|
name VARCHAR(64),
|
|
email VARCHAR(64),
|
|
oid_id VARCHAR(64),
|
|
pwd_hash VARCHAR(64),
|
|
role CHAR(3),
|
|
PRIMARY KEY (id),
|
|
FOREIGN KEY (school) REFERENCES school(id) ON DELETE CASCADE ON UPDATE CASCADE
|
|
)`,
|
|
`CREATE TABLE group_ (
|
|
id INT AUTO_INCREMENT NOT NULL,
|
|
name VARCHAR(64) NOT NULL,
|
|
type CHAR(3),
|
|
PRIMARY KEY (id)
|
|
)`,
|
|
`CREATE TABLE group_mentor (
|
|
id INT NOT NULL,
|
|
level TINYINT NOT NULL,
|
|
year YEAR(4) NOT NULL,
|
|
PRIMARY KEY (id),
|
|
FOREIGN KEY (id) REFERENCES group_(id) ON DELETE CASCADE ON UPDATE CASCADE
|
|
)`,
|
|
`CREATE TABLE member (
|
|
user INT NOT NULL,
|
|
group_ INT NOT NULL,
|
|
FOREIGN KEY (user) REFERENCES user(id) ON DELETE CASCADE ON UPDATE CASCADE,
|
|
FOREIGN KEY (group_) REFERENCES group_(id) ON DELETE CASCADE ON UPDATE CASCADE
|
|
)`,
|
|
`CREATE TABLE event_once (
|
|
group_ INT NOT NULL,
|
|
id INT AUTO_INCREMENT NOT NULL,
|
|
name VARCHAR(64) NOT NULL,
|
|
start DATETIME NOT NULL,
|
|
end DATETIME NOT NULL,
|
|
PRIMARY KEY (id),
|
|
FOREIGN KEY (group_) REFERENCES group_(id) ON DELETE CASCADE ON UPDATE CASCADE
|
|
)`,
|
|
`CREATE TABLE attachment (
|
|
event_once INT NOT NULL,
|
|
id INT NOT NULL,
|
|
PRIMARY KEY (event_once, id),
|
|
FOREIGN KEY (event_once) REFERENCES event_once(id) ON DELETE CASCADE ON UPDATE CASCADE
|
|
)`,
|
|
`CREATE TABLE event_weekly (
|
|
group_ INT NOT NULL,
|
|
id INT AUTO_INCREMENT NOT NULL,
|
|
name VARCHAR(64) NOT NULL,
|
|
day TINYINT NOT NULL,
|
|
starttime TIME NOT NULL,
|
|
endtime TIME NOT NULL,
|
|
PRIMARY KEY (id),
|
|
FOREIGN KEY (group_) REFERENCES group_(id) ON DELETE CASCADE ON UPDATE CASCADE
|
|
)`,
|
|
`CREATE TABLE ignored (
|
|
user INT NOT NULL,
|
|
event_weekly INT NOT NULL,
|
|
FOREIGN KEY (user) REFERENCES user(id) ON DELETE CASCADE ON UPDATE CASCADE,
|
|
FOREIGN KEY (event_weekly) REFERENCES event_weekly(id) ON DELETE CASCADE ON UPDATE CASCADE
|
|
)`,
|
|
];
|
|
for (let i = 0; i < tables.length; i += 1) {
|
|
// eslint-disable-next-line no-await-in-loop
|
|
await this.query(tables[i]);
|
|
}
|
|
|
|
// set version number
|
|
await this.query(`
|
|
INSERT INTO options (option, value)
|
|
VALUES ('version', '${getVersion()}')
|
|
`);
|
|
|
|
// TODO: Build admin interface to add schools and school owner
|
|
// add first school
|
|
const firstSchool = await this.query(`
|
|
INSERT INTO school (name, domain)
|
|
VALUES (?, ?)
|
|
`, ['NUS High School', 'nushigh.edu.sg']);
|
|
await this.query(`
|
|
INSERT INTO user (school, name, email, pwd_hash, role)
|
|
VALUES (?, ?, ?, ?, ?)
|
|
`, [firstSchool.insertId, 'Ambrose Chua', 'h1310031@nushigh.edu.sg', '', 'OWN']);
|
|
|
|
// eslint-disable-next-line global-require
|
|
const fs = require('fs');
|
|
const tmpsettings = JSON.parse(fs.readFileSync('oid_settings.json', 'utf8'));
|
|
await this.query(`
|
|
INSERT INTO auth (school, type, oid_meta, oid_cid, oid_csecret)
|
|
VALUES (?, ?, ?, ?, ?)
|
|
`, [firstSchool.insertId, 'OID', tmpsettings.oid_meta, tmpsettings.oid_cid, tmpsettings.oid_csecret]);
|
|
|
|
return true;
|
|
}
|
|
}
|