Joururi/spellsaurus
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- Added some school methods but will need to refactor the model calls

Browse Source
This commit is contained in:
Alexis
2020-06-06 23:35:11 +02:00
parent 3dbb95ab4d
commit ce9018f65e
6 changed files with 309 additions and 228 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
database/connection.js
View File

@@ -20,17 +20,4 @@ const knex = require('knex')({
})
const bookshelf = require('bookshelf')(knex)
const db = mysql.createConnection({
host: credentials.host,
user: credentials.user,
password: credentials.password,
database: credentials.database,
})
db.on('error', err => {
if (err.errno == 'ECONNRESET') {
console.log("The connection was reset during your request. Please try again later.");
}
})
module.exports = { db, bookshelf }
module.exports = { bookshelf }

4
models/SchoolValidation.js
View File

@@ -4,9 +4,9 @@ const School = {
"properties": {
"name": { "type": "string" },
"description": { "type": "string" },
"id_meta_school": { "type": "number" },
"meta_school_id": { "type": "number" },
},
"required": ["name", "description", "id_meta_school"]
"required": ["name", "description", "meta_school_id"]
}
module.exports = School

161
repositories/school-repository.js
View File

@@ -7,6 +7,18 @@ const Spells = require('./spell-repository')
const MetaSchoolRepository = require('./meta-school-repository')
const MetaSchools = new MetaSchoolRepository()
// Model validation
const Validator = require('jsonschema').Validator
const v = new Validator()
const SchoolModel = require("../models/SchoolValidation")
v.addSchema(SchoolModel, "/SchoolModel")
// Validations
const regexXSS = RegExp(/<[^>]*script/)
// Error handling
const { HttpError } = require('../models/Errors')
class SchoolRepository {
constructor() {
@@ -28,6 +40,155 @@ class SchoolRepository {
get model() {
return this._model
}
getAll() {
return new Promise((resolve, reject) => {
this._model.forge()
.fetchAll({ withRelated: ['meta_schools'] })
.then(v => {
resolve(v.toJSON({ omitPivot: true }))
})
.catch(err => {
console.log(err)
reject(new HttpError(500, "Couldn't get schools"))
})
})
}
getOne(id) {
return new Promise((resolve, reject) => {
this._model.forge()
.where({ 'id' : id })
.fetch({ withRelated: ['meta_schools']})
.then(v => {
resolve(v.toJSON({ omitPivot: true }))
})
.catch(err => {
console.log(err)
reject(new HttpError(500, "Couldn't get school"))
})
})
}
addOne(s) {
return new Promise((resolve, reject) => {
// Checks if body exists and if the model fits, and throws errors if it doesn't
if (this.isEmptyObject(s)) {
reject(new HttpError(403, "Error: School cannot be nothing !"))
} else if (!v.validate(s, SchoolModel).valid) {
reject(new HttpError(403, "Error: Schema is not valid - " + v.validate(s, SchoolModel).errors))
} else if (this.isXSSAttempt(s.name) || this.isXSSAttempt(s.description)) {
reject(new HttpError(403, 'Injection attempt detected, aborting the request.'))
} else {
bookshelf.transaction(t => {
return this._model.forge({
'name': s.name,
'description': s.description,
'meta_school_id': s.meta_school_id,
}).save(null, {
transacting: t
})
.catch(err => {
throw err
})
})
.then(v => {
return v.load(['meta_schools'])
})
.then(v => {
resolve(this.getOne(v.id))
})
.catch(err => {
console.log(err)
reject(new HttpError(500, "Insert School error"))
})
}
})
}
updateOne(id, s) {
return new Promise((resolve, reject) => {
// Checks if body exists and if the model fits, and throws errors if it doesn't
if (this.isEmptyObject(s)) {
reject(new HttpError(403, "Error: School cannot be nothing !"))
} else if (!v.validate(s, SchoolModel).valid) {
reject(new HttpError(403, "Error: Schema is not valid - " + v.validate(s, SchoolModel).errors))
} else if (this.isXSSAttempt(s.name) || this.isXSSAttempt(s.description)) {
reject(new HttpError(403, 'Injection attempt detected, aborting the request.'))
} else {
this._model.forge({id: id})
.fetch({require: true, withRelated: ['meta_schools']})
.then(v => {
bookshelf.transaction(t => {
return v.save({
'name': s.name,
'description': s.description,
'meta_school_id': s.meta_school_id
}, {
method: 'update',
transacting: t
})
.catch(err => {
console.log(err)
throw err
})
})
.then(v => {
return v.load(['meta_schools'])
})
.then(v => {
resolve(this.getOne(v.id))
})
.catch(err => {
console.log(err)
reject(new HttpError(500, "Update School error"))
})
})
.catch(err => {
console.log(err)
reject(new HttpError(404, "Couldn't get school"))
})
}
})
}
deleteOne(id) {
return new Promise((resolve, reject) => {
this._model.forge()
.where({ 'id' : id })
.fetch({require: true, withRelated: ['spells', 'meta_schools']})
.then(v => {
})
.then(() => {
resolve({
'message': 'School with ID ' + id + ' successfully deleted !'
})
})
.catch(err => {
console.log(err)
reject(new HttpError(404, "Couldn't get school"))
})
})
}
// Check if object is null
isEmptyObject = (obj) => {
if (Object.keys(obj).length === 0 && obj.constructor === Object) {
return true
} else {
return false
}
}
// Check if script injection attempt
isXSSAttempt = (string) => {
if (regexXSS.test(string)) {
return true
} else {
return false
}
}
}
module.exports = SchoolRepository

143
repositories/spell-repository.js
View File

@@ -132,7 +132,7 @@ class SpellRepository {
})
.catch(err => {
console.log(err)
reject(new HttpError(500, "Insert error"))
reject(new HttpError(500, "Insert Spell error"))
})
}
})
@@ -140,83 +140,92 @@ class SpellRepository {
updateOne(id, s) {
return new Promise((resolve, reject) => {
this._model.forge({id: id})
.fetch({require: true, withRelated: ['schools.meta_schools', 'variables', 'ingredients']})
.then(v => {
bookshelf.transaction(t => {
return v.save({
'name': s.name,
'description': s.description,
'level': s.level,
'charge' : s.charge,
'cost' : s.cost,
'is_ritual' : s.is_ritual
}, {
method: 'update',
transacting: t
})
// Detaches AND attaches pivot tables, dw about it
.tap(spell => {
if (s.schools) {
let schools = spell.related('school');
return spell.schools().detach(schools, { transacting: t});
}
return
})
.tap(spell => {
if (s.variables) {
let variables = spell.related('variable');
return spell.variables().detach(variables, { transacting: t});
}
return
})
.tap(spell => {
if (s.ingredients) {
let ingredients = spell.related('ingredient');
return spell.ingredients().detach(ingredients, { transacting: t});
}
})
.tap(spell => {
return spell
.schools()
.attach(s.schools, {
// Checks if body exists and if the model fits, and throws errors if it doesn't
if (this.isEmptyObject(s)) {
reject(new HttpError(403, "Error: Spell cannot be nothing !"))
} else if (!v.validate(s, SpellModel).valid) {
reject(new HttpError(403, "Error: Schema is not valid - " + v.validate(s, SpellModel).errors))
} else if (this.isXSSAttempt(s.name) || this.isXSSAttempt(s.description) || this.isXSSAttempt(s.cost)) {
reject(new HttpError(403, 'Injection attempt detected, aborting the request.'))
} else {
this._model.forge({id: id})
.fetch({require: true, withRelated: ['schools.meta_schools', 'variables', 'ingredients']})
.then(v => {
bookshelf.transaction(t => {
return v.save({
'name': s.name,
'description': s.description,
'level': s.level,
'charge' : s.charge,
'cost' : s.cost,
'is_ritual' : s.is_ritual
}, {
method: 'update',
transacting: t
});
})
// Detaches AND attaches pivot tables, dw about it
.tap(spell => {
if (s.schools) {
let schools = spell.related('school');
return spell.schools().detach(schools, { transacting: t});
}
return
})
.tap(spell => {
if (s.variables) {
let variables = spell.related('variable');
return spell.variables().detach(variables, { transacting: t});
}
return
})
.tap(spell => {
if (s.ingredients) {
let ingredients = spell.related('ingredient');
return spell.ingredients().detach(ingredients, { transacting: t});
}
})
.tap(spell => {
return spell
.schools()
.attach(s.schools, {
transacting: t
});
})
.tap(spell => {
return spell
.variables()
.attach(s.variables, {
transacting: t
});
})
.tap(spell => {
return spell
.ingredients()
.attach(s.ingredients, {
transacting: t
});
})
.catch(err => {
console.log(err)
throw err
})
})
.tap(spell => {
return spell
.variables()
.attach(s.variables, {
transacting: t
});
.then(v => {
return v.load(['schools.meta_schools', 'variables', 'ingredients'])
})
.tap(spell => {
return spell
.ingredients()
.attach(s.ingredients, {
transacting: t
});
.then(v => {
resolve(this.getOne(v.id))
})
.catch(err => {
console.log(err)
throw err
reject(new HttpError(500, "Update Spell error"))
})
})
.then(v => {
return v.load(['schools.meta_schools', 'variables', 'ingredients'])
})
.then(v => {
resolve(this.getOne(v.id))
})
.catch(err => {
console.log(err)
reject(new HttpError(500, "Update error"))
reject(new HttpError(404, "Couldn't get spell"))
})
})
.catch(err => {
console.log(err)
reject(new HttpError(404, "Couldn't get spell"))
})
}
})
}

212
routes/schools.js
View File

@@ -8,46 +8,21 @@ let router = express.Router()
const connection = require('../database/connection')
const db = connection.db
// Validations
const regexInt = RegExp(/^[1-9]\d*$/)
const regexXSS = RegExp(/<[^>]*script/)
// Repository
const SchoolRepository = require('../repositories/school-repository');
const Schools = new SchoolRepository();
// Model validation
const Validator = require('jsonschema').Validator
const v = new Validator()
const School = require("../models/SchoolValidation")
v.addSchema(School, "/SchoolModel")
const regexInt = RegExp(/^[1-9]\d*$/)
// Error handling
const { HttpError } = require('../models/Errors')
// ROUTES
// GET ALL ------------------
const getSchools = () => {
return new Promise((resolve, reject) => {
let query = "SELECT DISTINCT * FROM school"
db.query(query, async (err, result) => {
if (err) {
reject(new HttpError(500, 'Database error'))
} else if (result.length == 0) {
reject(new HttpError(404, 'No schools were found'))
}
// Loops over the results to fetch the associated tables
for (let i = 0; i < result.length; i++) {
try {
result[i] = await buildSchool(result[i])
} catch (err) {
reject(err)
}
}
resolve(result)
})
})
return Schools.getAll()
.catch(err => {
console.log(err)
throw err
})
}
@@ -70,23 +45,9 @@ router.get('/', async (req, res) => {
// GET ONE ------------------
const getSchool = (id) => {
return new Promise((resolve, reject) => {
let query = "SELECT * FROM school WHERE id = " + db.escape(id)
db.query(query, async (err, result) => {
if (err) {
reject(new HttpError(500, 'Database error'))
}
try {
result = buildSchool(result[0])
resolve(result)
} catch (err) {
reject(err)
}
})
})
return Schools.getOne(id)
.catch(err => {
console.log(err)
throw err
})
}
@@ -109,41 +70,9 @@ router.get('/:id/', async (req, res) => {
// CREATE ONE ------------------
const addSchool = (s) => {
return new Promise(async (resolve, reject) => {
// Checks if body exists and if the model fits, and throws errors if it doesn't
if (isEmptyObject(s)) {
reject(new HttpError(403, "Error: School cannot be nothing !"))
} else if (!v.validate(s, School).valid) {
reject(new HttpError(403, "Error: Schema is not valid - " + v.validate(s, School).errors))
} else if (isXSSAttempt(s.name) || isXSSAttempt(s.description)) {
reject(new HttpError(403, 'Injection attempt detected, aborting the request.'))
} else {
let query = `INSERT INTO school (name, description, id_meta_school) VALUES (${db.escape(s.name)}, ${db.escape(s.description)}, ${db.escape(s.id_meta_school)})`
db.query(query, (err, result) => {
if (err) {
if (err.errno == 1452) {
reject(new HttpError(404, "Error: No meta school matching this ID"))
} else {
reject(new HttpError(500, 'Database error'))
}
} else {
console.log(`Inserted "${s.name}" with ID ${result.insertId}, affecting ${result.affectedRows} row(s)`)
const new_school_id = result.insertId
getSchool(new_school_id)
.then(v => {
resolve(v)
})
.catch(err => {
reject(err)
})
}
})
}
}).catch(err => {
return Schools.addOne(s)
.catch(err => {
console.log(err)
throw err
})
}
@@ -163,79 +92,74 @@ router.post('/', async (req, res) => {
})
})
// Param validation for single school
// (check if id is int) (could be refactored)
router.param('id', (req, res, next, id) => {
const regex = RegExp(/^[1-9]\d*$/);
try {
if (regex.test(id)) {
next()
} else {
throw new HttpError(403, 'Provided ID must be an integer')
}
} catch (err) {
// UPDATE ONE ------------------
const updateSchool = (id, s) => {
return Schools.updateOne(id, s)
.catch(err => {
console.log(err)
throw err
})
}
router.put('/:id/', async (req, res) => {
updateSchool(req.params.id, req.body)
.then(v => {
res.setHeader('Content-Type', 'application/json;charset=utf-8')
res.send(JSON.stringify(v))
})
.catch(err => {
res.status(err.code).send(JSON.stringify(
{
"error": err.message,
"code": err.code
})
)
}
})
})
// SHARED FUNCTIONS ------------------
// Builds the associated infos for a given school object
const buildSchool = async (school) => {
// Fetches the school's parent school
let fetchMetaSchoolData = (s) => {
return new Promise((resolve, reject) => {
if (s == null) { reject(new HttpError(404, "Error: No school matching this ID"))}
let query =
"SELECT ms.id, ms.name " +
"FROM meta_school AS ms " +
"WHERE ms.id = " + s.id_meta_school
db.query(query, (err, result) => {
if (err) {
reject(new HttpError(500, 'Database error'))
} else {
delete s.id_meta_school
s.meta_school = result
resolve(s)
}
})
})
}
let s = fetchMetaSchoolData(school)
// DELETE ONE ------------------
const deleteSchool = (id) => {
return Schools.deleteOne(id)
.catch(err => {
console.log(err)
throw err
})
return s
}
router.delete('/:id/', async (req, res) => {
deleteSchool(req.params.id)
.then(v => {
res.setHeader('Content-Type', 'application/json;charset=utf-8')
res.send(JSON.stringify(v))
})
.catch(err => {
res.status(err.code).send(JSON.stringify(
{
"error": err.message,
"code": err.code
})
)
})
})
// Check if object is null
const isEmptyObject = (obj) => {
if (Object.keys(obj).length === 0 && obj.constructor === Object) {
return true
} else {
return false
}
}
// Check if script injection attempt
const isXSSAttempt = (string) => {
if (regexXSS.test(string)) {
return true
} else {
return false
}
}
module.exports = router
// Param validation for ID
// (check if id is int) (could be refactored)
router.param('id', (req, res, next, id) => {
try {
if (regexInt.test(id)) {
next()
} else {
throw new Error;
}
} catch (err) {
err = new HttpError(403, 'Provided ID must be an integer and not zero')
res.status(err.code).send(JSON.stringify(
{
"error": err.message,
"code": err.code
})
)
}
})
module.exports = router

2
routes/spells.js
View File

@@ -143,7 +143,7 @@ router.delete('/:id/', async (req, res) => {
})
// Param validation for single spell
// Param validation for ID
// (check if id is int) (could be refactored)
router.param('id', (req, res, next, id) => {
try {