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

database/connection.js

@@ -20,17 +20,4 @@ const knex = require('knex')({
 })
 const bookshelf = require('bookshelf')(knex)
 
-const db = mysql.createConnection({
+module.exports = { bookshelf }
-    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 }

models/SchoolValidation.js

@@ -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

repositories/school-repository.js

@@ -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

repositories/spell-repository.js

@@ -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})
+            // Checks if body exists and if the model fits, and throws errors if it doesn't
-            .fetch({require: true, withRelated: ['schools.meta_schools', 'variables', 'ingredients']})
+            if (this.isEmptyObject(s)) {
-            .then(v => {
+                reject(new HttpError(403, "Error: Spell cannot be nothing !"))
-                bookshelf.transaction(t => {
+            } else if (!v.validate(s, SpellModel).valid) {
-                    return v.save({
+                reject(new HttpError(403, "Error: Schema is not valid - " + v.validate(s, SpellModel).errors))
-                        'name': s.name,
+            } else if (this.isXSSAttempt(s.name) || this.isXSSAttempt(s.description) || this.isXSSAttempt(s.cost)) {
-                        'description': s.description,
+                reject(new HttpError(403, 'Injection attempt detected, aborting the request.'))
-                        'level': s.level,
+            } else {
-                        'charge' : s.charge,
+                this._model.forge({id: id})
-                        'cost' : s.cost,
+                .fetch({require: true, withRelated: ['schools.meta_schools', 'variables', 'ingredients']})
-                        'is_ritual' : s.is_ritual
+                .then(v => {
-                    }, {
+                    bookshelf.transaction(t => {
-                        method: 'update',
+                        return v.save({
-                        transacting: t
+                            'name': s.name,
-                    })
+                            'description': s.description,
-                    // Detaches AND attaches pivot tables, dw about it
+                            'level': s.level,
-                    .tap(spell => {
+                            'charge' : s.charge,
-                        if (s.schools) {
+                            'cost' : s.cost,
-                            let schools = spell.related('school');
+                            'is_ritual' : s.is_ritual
-                            return spell.schools().detach(schools, { transacting: t});
+                        }, {
-                        }
+                            method: 'update',
-                        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
-                        });
+                        })
+                        // 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 => {
+                    .then(v => {
-                        return spell
+                        return v.load(['schools.meta_schools', 'variables', 'ingredients'])
-                        .variables()
-                        .attach(s.variables, {
-                            transacting: t
-                        });
                     })
-                    .tap(spell => {
+                    .then(v => {
-                        return spell
+                        resolve(this.getOne(v.id))
-                        .ingredients()
-                        .attach(s.ingredients, {
-                            transacting: t
-                        });
                     })
                     .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"))
-            })
         })
     }
 

routes/schools.js

@@ -8,46 +8,21 @@ let router = express.Router()
 const connection = require('../database/connection')
 const db = connection.db
 
-// Validations
+// Repository
-const regexInt = RegExp(/^[1-9]\d*$/)
+const SchoolRepository = require('../repositories/school-repository');
-const regexXSS = RegExp(/<[^>]*script/)
+const Schools = new SchoolRepository();
 
-// Model validation
+const regexInt = RegExp(/^[1-9]\d*$/)
-const Validator = require('jsonschema').Validator
-const v = new Validator()
-const School = require("../models/SchoolValidation")
-v.addSchema(School, "/SchoolModel")
 
 // Error handling
 const { HttpError } = require('../models/Errors')
 
-
 // ROUTES
 // GET ALL ------------------
 const getSchools = () => {
-    return new Promise((resolve, reject) => {
+    return Schools.getAll()
-
-        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)
-        })
-    })
     .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) => {
+    return Schools.getOne(id)
-
-        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)
-            }
-        })
-    })
     .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) => {
+    return Schools.addOne(s)
-
+    .catch(err => {
-        // Checks if body exists and if the model fits, and throws errors if it doesn't
+        console.log(err)
-        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 => {
         throw err
     })
 }
@@ -163,79 +92,74 @@ router.post('/', async (req, res) => {
     })
 })
 
-// Param validation for single school
+// UPDATE ONE ------------------
-// (check if id is int) (could be refactored)
+const updateSchool = (id, s) => {
-router.param('id', (req, res, next, id) => {
+    return Schools.updateOne(id, s)
-    const regex = RegExp(/^[1-9]\d*$/);
+    .catch(err => {
-    try {
+        console.log(err)
-        if (regex.test(id)) {
+        throw err
-            next()
+    })
-        } else {
+}
-            throw new HttpError(403, 'Provided ID must be an integer')
+router.put('/:id/', async (req, res) => {
-        }
+    updateSchool(req.params.id, req.body)
-    } catch (err) {
+    .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
+// DELETE ONE ------------------
-const buildSchool = async (school) => {
+const deleteSchool = (id) => {
-
+    return Schools.deleteOne(id)
-    // 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)
     .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
+// Param validation for ID
-const isEmptyObject = (obj) => {
+    // (check if id is int) (could be refactored)
-    if (Object.keys(obj).length === 0 && obj.constructor === Object) {
+    router.param('id', (req, res, next, id) => {
-        return true
+        try {
-    } else {
+            if (regexInt.test(id)) {
-        return false
+                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
+                })
+            )
+        }
+    })
     
-// Check if script injection attempt
+    module.exports = router
-const isXSSAttempt = (string) => {
-    if (regexXSS.test(string)) {
-        return true
-    } else {
-        return false
-    }
-}
     
-module.exports = router

routes/spells.js

@@ -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 {