diff --git a/config.json.example b/config.json.example
index 5b2a49fdf244d7a7b54ce749d8eabe7546e5d3e1..ea9bd2f3a7c826ed36999cb360b748801d1445ef 100644
--- a/config.json.example
+++ b/config.json.example
@@ -1,21 +1,71 @@
{
- "port": 3000,
- "ip": "127.0.0.1",
- "debug" : false,
- "monetdb": {
- "host": "simcaqdb3.c3sl.ufpr.br",
- "port": 50000,
- "dbname": "simcaq_dev",
- "user": "monetdb",
- "password":"monetdb",
- "nrConnections": "16"
+ "development":
+ {
+ "port": 3000,
+ "ip": "127.0.0.1",
+ "debug" : true,
+ "monetdb": {
+ "host": "simcaqdb3.c3sl.ufpr.br",
+ "port": 50000,
+ "dbname": "simcaq_dev",
+ "user": "monetdb",
+ "password":"monetdb",
+ "nrConnections": "4"
+ },
+ "mongodb" : {
+ "uri": "mongodb://localhost/users",
+ "secret": "SimCAQC3SL"
+ },
+ "default": {
+ "api": {
+ "version" : "v1"
+ }
+ }
},
- "mongodb" : {
- "uri": "mongodb://localhost/users"
+ "test":
+ {
+ "port": 3000,
+ "ip": "127.0.0.1",
+ "debug" : true,
+ "monetdb": {
+ "host": "simcaqdb3.c3sl.ufpr.br",
+ "port": 50000,
+ "dbname": "simcaq_dev",
+ "user": "monetdb",
+ "password":"monetdb",
+ "nrConnections": "4"
+ },
+ "mongodb" : {
+ "uri": "mongodb://localhost/test_users",
+ "secret": "SimCAQC3SL"
+ },
+ "default": {
+ "api": {
+ "version" : "v1"
+ }
+ }
},
- "default": {
- "api": {
- "version" : "v1"
+ "production":
+ {
+ "port": 3000,
+ "ip": "127.0.0.1",
+ "debug" : false,
+ "monetdb": {
+ "host": "simcaqdb3.c3sl.ufpr.br",
+ "port": 50000,
+ "dbname": "simcaq_dev",
+ "user": "monetdb",
+ "password":"monetdb",
+ "nrConnections": "4"
+ },
+ "mongodb" : {
+ "uri": "mongodb://localhost/users",
+ "secret": "SimCAQC3SL"
+ },
+ "default": {
+ "api": {
+ "version" : "v1"
+ }
}
}
-}
\ No newline at end of file
+}
diff --git a/gulpfile.babel.js b/gulpfile.babel.js
index 563dfac93e840a304a15e10769deb69db755195d..acc0e918ad5bea19aad613165a84e547648520a6 100644
--- a/gulpfile.babel.js
+++ b/gulpfile.babel.js
@@ -73,7 +73,7 @@ gulp.task('pre-test', () => {
gulp.task('test', ['pre-test'], () => {
process.chdir('build');
- gulp.src('test/**/*.js', {read: false})
+ gulp.src(['test/**/*.js'], {read: false})
.pipe(mocha({timeout: 15000}))
.pipe(istanbul.writeReports())
.pipe(istanbul.enforceThresholds({
diff --git a/package.json b/package.json
index acc29cd2e3d6ff9a605fde13cfaa6774243b6307..a7056dc915f19875538b5f4de96bda8d4fa764d9 100644
--- a/package.json
+++ b/package.json
@@ -10,6 +10,7 @@
},
"dependencies": {
"apicache": "0.0.14",
+ "bcrypt": "^0.8.7",
"body-parser": "^1.13.1",
"chai": "^3.5.0",
"chai-http": "^3.0.0",
@@ -23,11 +24,13 @@
"faker": "^2.1.5",
"forever": "^0.15.2",
"js2xmlparser": "^1.0.0",
+ "jwt-simple": "^0.5.0",
"method-override": "^2.3.3",
"mocha": "^2.5.3",
"monetdb-pool": "0.0.8",
"mongoose": "^4.6.0",
"nconf": "^0.6.x",
+ "passport": "^0.3.2",
"squel": "^5.4.2",
"winston": "^2.2.0"
},
diff --git a/src/libs/app.js b/src/libs/app.js
index 37e02f87922011bf2c05f39b638b57a5c3c52e0c..18b46cf3f195879ce25d1edf2bcaa39a08afb6f3 100644
--- a/src/libs/app.js
+++ b/src/libs/app.js
@@ -10,12 +10,15 @@ const libs = `${process.cwd()}/libs`;
const log = require(`${libs}/log`)(module);
+process.env.NODE_ENV = process.env.NODE_ENV || 'development';
const config = require(`${libs}/config`);
-const cache = require('apicache').options({ debug: config.get('debug') }).middleware;
+const cache = require('apicache').options({ debug: config.debug }).middleware;
const app = express();
-const api = require(`${libs}/routes/api`);
+const api = require('./routes/api');
+
+const passport = require('passport');
const mongoose = require(`${libs}/db/mongoose`);
@@ -27,8 +30,6 @@ app.use(cookieParser());
// Enable Cross-Origin Resource Sharing (CORS)
app.use(cors());
app.use(methodOverride());
-// Enable cache for 1 day
-app.use(cache('1 day'));
// Enable maximum compression
app.use(compression(9));
// Middleware tha adds the squel object to req
diff --git a/src/libs/config.js b/src/libs/config.js
index 5aea5a9ca50efd0dac2253dd23690229431236dc..2c07d19e94ba2505205d613a9ac6d5596c388502 100644
--- a/src/libs/config.js
+++ b/src/libs/config.js
@@ -1,8 +1,5 @@
-const nconf = require('nconf');
+let conf = require(`${process.cwd()}/config.json`);
-// Exports the config.json as an object with get functions
-nconf.argv()
- .env()
- .file({ file: `${process.cwd()}/config.json` });
+conf = conf[process.env.NODE_ENV];
-module.exports = nconf;
+module.exports = conf;
diff --git a/src/libs/db/monet.js b/src/libs/db/monet.js
index dd7e620adcf5b6a1dbe29358697fa71a3970ea03..d19fb37dfac5ed68cc15c1762a822818dbbc82da 100644
--- a/src/libs/db/monet.js
+++ b/src/libs/db/monet.js
@@ -6,16 +6,16 @@ const config = require(`${libs}/config`);
// Connection options
const poolOptions = {
- nrConnections: config.get('monetdb:nrConnections'),
+ nrConnections: config.monetdb.nrConnections,
};
// Configuration options
const options = {
- host: config.get('monetdb:host'),
- port: config.get('monetdb:port'),
- dbname: config.get('monetdb:dbname'),
- user: config.get('monetdb:user'),
- password: config.get('monetdb:password'),
+ host: config.monetdb.host,
+ port: config.monetdb.port,
+ dbname: config.monetdb.dbname,
+ user: config.monetdb.user,
+ password: config.monetdb.password,
};
// Connection singleton
diff --git a/src/libs/db/mongoose.js b/src/libs/db/mongoose.js
index 30b4d4930c203537335c46b14bfb5e2958ace6bb..d8594158aba29c2c732e8e348bca7930fbb84e73 100644
--- a/src/libs/db/mongoose.js
+++ b/src/libs/db/mongoose.js
@@ -6,9 +6,12 @@ const log = require(`${libs}/log`)(module);
const mongoose = require('mongoose');
+mongoose.Promise = global.Promise;
+
module.exports = () => {
- const mongoUri = process.env.MONGO_URI || config.get('mongodb:uri');
- log.debug(`Connecting to MongDB on URI ${mongoUri}`);
+ // Get mongodb URI (ip and port) in config file
+ const mongoUri = process.env.MONGO_URI || config.mongodb.uri;
+ log.debug(`Connecting to MongoDB on URI ${mongoUri}`);
// Connection singleton
const db = mongoose.connect(mongoUri);
diff --git a/src/libs/log.js b/src/libs/log.js
index fbe7b1394464e06611cbcd91d69e33c022846923..ddf0303f8481514b047aa6678894316500d25a96 100644
--- a/src/libs/log.js
+++ b/src/libs/log.js
@@ -47,7 +47,7 @@ function logger(module) {
],
exitOnError: false,
});
- if (!config.get('debug')) {
+ if (!config.debug) {
log.remove('debug-log');
}
return log;
diff --git a/src/libs/middlewares/passport.js b/src/libs/middlewares/passport.js
new file mode 100644
index 0000000000000000000000000000000000000000..c939926099b845b641268d66e9d2bccf9085a043
--- /dev/null
+++ b/src/libs/middlewares/passport.js
@@ -0,0 +1,54 @@
+const JwtStrategy = require('passport-jwt').Strategy;
+const ExtractJwt = require('passport-jwt').ExtractJwt;
+const libs = `${process.cwd()}/libs`;
+const config = require(`${libs}/config`);
+const User = require(`${libs}/models/user`)
+
+module.exports = function(passport){
+ var opts = {};
+ opts.jwtFromRequest = ExtractJwt.fromAuthHeader();
+ opts.secretOrKey = config.get('mongodb:secret');
+ passport.use(new JwtStrategy(opts, function(jwt_payload, done){
+ User.find({email: jwt_payload.email}, function(err, user){
+ if (err) {
+ return done(err);
+ }
+
+ if (!user) {
+ return done(null, false, {message: 'Unknown user'});
+ }
+
+ return done(null, user);
+ });
+ }));
+};
+
+/* To check if a user has access to a route, one must use passport.authenticate() specifying 'JWT' as the strategy in the route declaration, like so:
+//pass passportfor configuration
+require('./config/passport')(passport);
+
+app.post('/route', passport.authenticate('jwt', { session: false}), function(req, res) { });
+
+the user object is then accessible via req.user
+----
+
+Another way to check if a user is authenticated, is to check the request header for the json web token, like so:
+
+getToken = function (headers) {
+ if (headers && headers.authorization) {
+ var parted = headers.authorization.split(' ');
+ if (parted.length === 2) {
+ return parted[1];
+ } else {
+ return null;
+ }
+ } else {
+ return null;
+ }
+};
+
+var token = getToken(req.headers);
+ if (token) {
+ var decoded = jwt.decode(token, config.get(mongodb.secret));
+ }
+ */
diff --git a/src/libs/models/simulation.js b/src/libs/models/simulation.js
new file mode 100644
index 0000000000000000000000000000000000000000..e70c93a9f88dea76d017744b15f3b3fe61b5ca21
--- /dev/null
+++ b/src/libs/models/simulation.js
@@ -0,0 +1,115 @@
+const mongoose = require('mongoose')
+
+const libs = `${process.cwd()}/libs`;
+const log = require(`${libs}/log`)(module);
+
+const Schema = mongoose.Schema;
+
+// Should define this somewhere else
+const MAX_SIMULATION_TIME = 10;
+
+
+let SimulationSchema = new Schema({
+ name: {
+ type: String,
+ required: true,
+ },
+ location: Object,
+ time: Number,
+ failure_rate: Array,
+ goals_care: Array,
+ goals_inclusion: Array,
+ enrollments: Array,
+ timestamp: Date,
+});
+
+SimulationSchema.methods.setTime = function (t) {
+ t = parseInt(t, 10);
+ if (!t || t > MAX_SIMULATION_TIME) {
+ // Throw an error?
+ return false;
+ }
+ this.time = t;
+ return true;
+};
+SimulationSchema.methods.setLocation = function (l) {
+ // Should sanitize
+ this.location = l;
+ return true;
+};
+SimulationSchema.methods.setFailureRate = function (fr) {
+ // Should sanitize
+ this.failure_rate = fr;
+ return true;
+};
+SimulationSchema.methods.setCareGoals = function (g) {
+ // Should sanitize
+ this.goals_care = g;
+ return true;
+};
+SimulationSchema.methods.setInclusionGoals = function (g) {
+ // Should sanitize
+ this.goals_inclusion = g;
+ return true;
+};
+SimulationSchema.methods.setEnrollments = function (e) {
+ try{
+ e = JSON.parse(e);
+ } catch (err) {
+ return false;
+ }
+ let success = true;
+ for(let i=0; i<e.length; i++){
+ if(!(e[i] instanceof Array)){
+ return false;
+ }
+ if(e[i].length !== this.time){
+ return false;
+ }
+ e[i].forEach((n, i, array) => {
+ if(n !== parseInt(n, 10)){
+ success = false;
+ }
+ });
+
+ }
+ if (success) this.enrollments = e;
+
+ return success;
+}
+SimulationSchema.methods.update = function (property, value) {
+ let success = true;
+ switch(property){
+ case 'time':
+ if (!this.setTime(value)) success = false;
+ break;
+ case 'location':
+ if (!this.setLocation(value)) success = false;
+ break;
+ case 'failure_rate':
+ if (!this.setFailureRate(value)) success = false;
+ break;
+ case 'goals_care':
+ if (!this.setCareGoals(value)) success = false;
+ break;
+ case 'goals_inclusion':
+ if (!this.setInclusionGoals(value)) success = false;
+ break;
+ case 'enrollments':
+ if (!this.setEnrollments(value)) success = false;
+ break;
+ case 'name':
+ this.name = value;
+ break;
+ }
+ return success;
+};
+
+SimulationSchema.methods.run = function () {
+ /* Runs the Simulation with given parameters */
+ // if (!this.name || !this.location || !this.time) {
+ // console.log('This is supposed to be an error.');
+ // }
+};
+
+module.exports = mongoose.model('Simulation', SimulationSchema);
diff --git a/src/libs/models/user.js b/src/libs/models/user.js
new file mode 100644
index 0000000000000000000000000000000000000000..8c4f92a204ef9c3b410fb656c16c4af9ad6c7152
--- /dev/null
+++ b/src/libs/models/user.js
@@ -0,0 +1,89 @@
+const mongoose = require('mongoose');
+const bcrypt = require('bcrypt');
+const libs = `${process.cwd()}/libs`;
+const log = require(`${libs}/log`)(module);
+const Schema = mongoose.Schema;
+
+// set up a mongoose model
+var UserSchema = new Schema({
+ email: {
+ type: String,
+ unique: true,
+ required: true
+ },
+ password: {
+ type: String,
+ required: true
+ },
+ name: {
+ type: String,
+ required: true
+ },
+ cpf:{
+ type: String,
+ unique: true,
+ required: true
+ },
+ schooling: {
+ type: String,
+ required: true
+ },
+ course: {
+ type: String,
+ },
+ segment: {
+ type: String,
+ required: true
+ },
+ role: {
+ type: String,
+ required: true
+ },
+ institution_name: {
+ type: String,
+ required: true
+ },
+ state: {
+ type: String,
+ required: true
+ },
+ city: {
+ type: String,
+ required: true
+ },
+ receive_emails: {
+ type: Boolean
+ }
+
+});
+
+UserSchema.pre('save', function (next) {
+ var user = this;
+ if (this.isModified('password') || this.isNew) {
+ bcrypt.genSalt(10, function (err, salt) {
+ if (err) {
+ return next(err);
+ }
+ bcrypt.hash(user.password, salt, function (err, hash) {
+ if (err) {
+ return next(err);
+ }
+ user.password = hash;
+ next();
+ });
+ });
+ } else {
+ return next();
+ }
+});
+
+UserSchema.methods.comparePassword = function (passw, cb) {
+ bcrypt.compare(passw, this.password, function (err, isMatch) {
+ if (err) {
+ return cb(err);
+ }
+ cb(null, isMatch);
+ });
+};
+
+module.exports = mongoose.model('User', UserSchema);
diff --git a/src/libs/routes/api.js b/src/libs/routes/api.js
index 0522a8d0a5cfda2bb3a6f663ed1a44d683e1ff54..2c29a24680987a9b6c572cf5fa4ba86bc0b0c83c 100644
--- a/src/libs/routes/api.js
+++ b/src/libs/routes/api.js
@@ -2,6 +2,12 @@ const express = require('express');
const api = express();
+const libs = `${process.cwd()}/libs`;
+
+const config = require(`${libs}/config`);
+
+const cache = require('apicache').options({ debug: config.debug }).middleware;
+
const enrollment = require('./enrollment');
const state = require('./state');
@@ -14,16 +20,22 @@ const school = require('./school');
const location = require('./location');
+const simulation = require('./simulation');
+
+const user = require('./user');
+
api.get('/', (req, res) => {
res.json({ msg: 'SimCAQ API is running' });
});
// mount API routes
-api.use('/enrollment', enrollment);
-api.use('/state', state);
-api.use('/region', region);
-api.use('/city', city);
-api.use('/school', school);
-api.use('/location', location);
+api.use('/user', user);
+api.use('/simulation', simulation);
+api.use('/enrollment', cache('1 day'), enrollment);
+api.use('/state', cache('15 day'), state);
+api.use('/region', cache('15 day'), region);
+api.use('/city', cache('15 day'), city);
+api.use('/school', cache('15 day'), school);
+api.use('/location', cache('1 day'), location);
module.exports = api;
diff --git a/src/libs/routes/simulation.js b/src/libs/routes/simulation.js
index d197b39d1c107935bef0775bcfce31ca4b7b75b5..6469d4d6b3df70077b9f38fca96c6ae479133022 100644
--- a/src/libs/routes/simulation.js
+++ b/src/libs/routes/simulation.js
@@ -1,47 +1,147 @@
const express = require('express');
+const simulationApp = express();
+
const libs = `${process.cwd()}/libs`;
+const log = require(`${libs}/log`)(module);
+
const squel = require('squel');
const query = require(`${libs}/middlewares/query`);
const response = require(`${libs}/middlewares/response`);
-const simulationApp = express();
-
-simulationApp.get('/', (req, res, next) => {
- req.sql = squel.select().from('simulacao').toParam();
- next();
-}, query, response('simulacao'));
-
-simulationApp.get('/:uid:/all', (req, res, next) => {
- // TODO: implement user checking
-
- req.sql = squel.select().from('simulacao').toParam();
- next();
-}, query, response('simulacao'));
-
-simulationApp.get('/:uid:/:simulation_id:/view', (req, res, next) => {
- // TODO: implement checking if the simulation belongs to the current user
-
- req.sql = squel.select().from('simulacao').toParam();
- next();
+const Simulation = require(`${libs}/models/simulation`);
+
+simulationApp.get('/', (req, res) => {
+ let out = { success: true, msg: 'controller working' };
+ out.result = new Array()
+ Simulation.find({}, function(err, sims) {
+ sims.forEach((sim) => {
+ out.result.push(sim);
+ });
+ res.send(out);
+ });
});
-simulationApp.get('/:uid:/:simulation_id:/delete', (req, res, next) => {
- // TODO: implement checking if the simulation belongs to the current user
+simulationApp.post('/', (req, res, next) => {
+ // This method must associate new entry with user.
+ /* Creates a new simulation. Requires a name. */
+ if (!req.body.name) {
+ res.send({ success: false, msg: 'Must send a name for new entry' });
+ } else {
+ next();
+ }
+}, (req, res) => {
+ let currentdate = new Date();
+ let newSimulation = new Simulation({
+ name: req.body.name,
+ timestamp: currentdate.getDate(),
+ });
+ newSimulation.save((err) => {
+ if (err) {
+ res.send({ success: false, msg: err });
+ } else {
+ res.send({
+ success: true,
+ msg: 'new sim created',
+ id: newSimulation._id,
+ });
+ }
+ });
+});
- req.sql = squel.select().from('simulacao').toParam();
- next();
+simulationApp.get('/:id', (req, res) => {
+ /* Can be used to check simulation construction status */
+ Simulation.findById(req.params.id, (err, simulation) => {
+ log.debug(req.params.id);
+ if (err) {
+ res.send({ success: false, msg: err });
+ return;
+ }
+
+ if (!simulation) {
+ res.send({ success: false, msg: 'Entry not found' });
+ } else {
+ res.send(simulation);
+ }
+ });
});
-simulationApp.get('/:uid:/:simulation_id:/edit', (req, res, next) => {
- // TODO: implement checking if the simulation belongs to the current user
+simulationApp.post('/:id', (req, res, next) => {
+ if (!Object.keys(req.body).length) {
+ res.send({ success: false, msg: 'No field informed to update' });
+ } else {
+ next();
+ }
+}, (req, res, next) => {
+ let simulation = Simulation.findById(req.params.id, (err, simulation) => {
+ if (err) {
+ res.send({ success: false, msg: err });
+ } else {
+ if (!simulation) {
+ res.send({ success: false, msg: 'Entry not found' });
+ } else {
+ req.simulation = simulation;
+ next();
+ }
+ }
+ });
+}, (req, res) => {
+ for (let property in req.body) {
+ if (Simulation.schema.tree.hasOwnProperty(property)) {
+ if(!req.simulation.update(property, req.body[property])){
+ res.send({
+ success: false,
+ msg: 'Invalid format for ' + property,
+ });
+ return ;
+ }
+ } else {
+ res.send({
+ success: false,
+ msg: 'Unknown property ' + property,
+ });
+ return ;
+ }
+ }
+ req.simulation.save((err) => {
+ if (err) {
+ res.send({ success: false, msg: err });
+ } else {
+ res.send({
+ success: true,
+ msg: 'sim updated',
+ id: req.simulation._id,
+ });
+ }
+ });
+});
- req.sql = squel.select().from('simulacao').toParam();
- next();
+simulationApp.delete('/:id', (req, res, next) => {
+ let simulation = Simulation.findById(req.params.id, (err, simulation) => {
+ if (err) {
+ res.send({ success: false, msg: err });
+ } else {
+ if (!simulation) {
+ res.send({ success: false, msg: 'Entry not found' });
+ } else {
+ next();
+ }
+ }
+ });
+}, (req, res) => {
+ Simulation.remove({"_id": req.params.id}, (err) => {
+ if (err) {
+ res.send({ success: false, msg: err });
+ } else {
+ res.send({
+ success: true,
+ msg: 'sim removed',
+ });
+ }
+ });
});
module.exports = simulationApp;
-
diff --git a/src/libs/routes/user.js b/src/libs/routes/user.js
new file mode 100644
index 0000000000000000000000000000000000000000..eb1732b18f6a04a74c6799ac81d7a4ca027c8e82
--- /dev/null
+++ b/src/libs/routes/user.js
@@ -0,0 +1,194 @@
+const express = require('express');
+
+const userApp = express();
+
+const libs = `${process.cwd()}/libs`;
+
+const config = require(`${libs}/config`);
+
+const log = require(`${libs}/log`)(module);
+
+const User = require(`${libs}/models/user`);
+
+const jwt = require('jwt-simple');
+
+const required_fields = ["email", "password", "name", "cpf", "schooling", "segment", "role", "institution_name", "state", "city"];
+
+
+function emailSyntax(email) {
+ const regex = /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
+ return regex.test(email);
+}
+
+userApp.post('/', (req, res, next) => {
+ if (!req.body.email) {
+ res.json({success: false, msg: 'O campo Email é obrigatório.'});
+ } else {
+ next();
+ }
+
+}, (req, res, next) => {
+ if (!req.body.password) {
+ res.json({success: false, msg: 'O campo Senha é obrigatório.'});
+ } else {
+ next();
+ }
+
+}, (req, res, next) => {
+ if(!emailSyntax(req.body.email)){
+ res.json({success: false, msg: 'O email informado é inválido.'});
+ } else {
+ next();
+ }
+
+}, (req, res, next) => {
+ if (!req.body.name) {
+ res.json({success: false, msg: 'O campo Nome é obrigatório.'});
+ } else {
+ next();
+ }
+
+}, (req, res, next) => {
+ if (!req.body.cpf) {
+ res.json({success: false, msg: 'O campo CPF é obrigatório.'});
+ } else {
+ next();
+ }
+
+}, (req, res, next) => {
+ if (!req.body.schooling) {
+ res.json({success: false, msg: 'O campo Escolaridade é obrigatório.'});
+ } else {
+ next();
+ }
+
+}, (req, res, next) => {
+ if (!req.body.segment) {
+ res.json({success: false, msg: 'O campo Segmento é obrigatório.'});
+ } else {
+ next();
+ }
+
+}, (req, res, next) => {
+ if (!req.body.role) {
+ res.json({success: false, msg: 'O campo Função é obrigatório.'});
+ } else {
+ next();
+ }
+
+}, (req, res, next) => {
+ if (!req.body.institution_name) {
+ res.json({success: false, msg: 'O campo Instituição em que trabalha é obrigatório.'});
+ } else {
+ next();
+ }
+
+}, (req, res, next) => {
+ if (!req.body.city) {
+ res.json({success: false, msg: 'O campo Cidade é obrigatório.'});
+ } else {
+ next();
+ }
+
+}, (req, res, next) => {
+ if (!req.body.state) {
+ res.json({success: false, msg: 'O campo Estado é obrigatório.'});
+ } else {
+ next();
+ }
+
+}, (req, res, next) => {
+ User.count({'email': req.body.email}, function(err, count){
+ if (err){
+ log.error('MongoDB error: ' + err);
+ res.json({success: false, msg: 'Um erro ocorreu no banco de dados.'});
+ }
+ if(count){
+ res.json({success: false, msg: 'O email informado já está cadastrado.'});
+ } else {
+ next();
+ }
+ });
+
+}, (req, res, next) => {
+ User.count({'cpf': req.body.cpf}, function(err, count){
+ if (err){
+ log.error('MongoDB error: ' + err);
+ res.json({success: false, msg: 'Um erro ocorreu no banco de dados.'});
+ }
+ if(count){
+ res.json({success: false, msg: 'O CPF informado já está cadastrado.'});
+ } else {
+ next();
+ }
+ });
+
+}, (req, res, next) => {
+ var newUser = new User({
+ email: req.body.email,
+ password: req.body.password,
+ name: req.body.name,
+ cpf: req.body.cpf,
+ schooling: req.body.schooling,
+ course: req.body.course,
+ segment: req.body.segment,
+ role: req.body.role,
+ institution_name: req.body.institution_name,
+ state: req.body.state,
+ city: req.body.city,
+ receive_emails: req.body.receive_emails
+ });
+
+ // save the user
+ newUser.save((err) => {
+ if (err) {
+ res.json({success: false, msg: 'Um erro ocorreu no banco de dados.'});
+ } else {
+ res.json({success: true, msg: 'Usuário cadastrado com sucesso!'});
+ }
+ });
+});
+
+userApp.post('/authenticate', (req, res, next) => {
+ if (!req.body.email) {
+ res.json({success: false, msg: 'O campo Email é obrigatório.'});
+ } else {
+ next();
+ }
+
+}, (req, res, next) => {
+ if (!req.body.password) {
+ res.json({success: false, msg: 'O campo Senha é obrigatório.'});
+ } else {
+ next();
+ }
+
+}, (req, res, next) => {
+ User.findOne({
+ email: req.body.email
+ }, (err, user) => {
+ if (err) throw err;
+
+ if(!user){
+ res.json({success: false, msg: 'O Email informado não está cadastrado.'});
+ }
+ else {
+ user.comparePassword(req.body.password, (err, isMatch) => {
+ if (isMatch && !err) {
+ var secret = config.mongodb.secret;
+
+ // if user is found and password is right create a token
+ var token = jwt.encode(user, secret);
+
+ //returns user info including token as json
+ res.json({success: true, token: 'JWT ' + token, msg: 'Usuário autenticado com sucesso'});
+ }
+ else {
+ res.json({success: false, msg: 'A Senha informada é inválida.'});
+ }
+ });
+ }
+ });
+});
+
+module.exports = userApp;
diff --git a/src/server.js b/src/server.js
index 0eef8dfa5fb4764522f0b1c0be02da239603d347..4e097f28a4053050757c6329e19e225e0424b961 100644
--- a/src/server.js
+++ b/src/server.js
@@ -8,12 +8,14 @@ const log = require(`${libs}/log`)(module);
const app = require(`${libs}/app`);
+// Set default port: first environment variable PORT, then configuration and last 3000
+app.set('port', process.env.PORT || config.port || 3000);
process.env.NODE_ENV = process.env.NODE_ENV || 'development';
-app.set('port', process.env.PORT || config.get('port') || 3000);
+app.set('port', process.env.PORT || config.port || 3000);
// Set default ip: first environment variable IOP, then configuration and last '127.0.0.1'
-app.set('ip', process.env.IP || config.get('ip') || '127.0.0.1');
+app.set('ip', process.env.IP || config.ip || '127.0.0.1');
const server = app.listen(app.get('port'), () => {
log.info(`Express server listening on port ${server.address().port}`);
diff --git a/src/test/auth.js b/src/test/auth.js
new file mode 100644
index 0000000000000000000000000000000000000000..67b9d186230e80828f88c85a6fbc53489f5e4acf
--- /dev/null
+++ b/src/test/auth.js
@@ -0,0 +1,228 @@
+process.env.NODE_ENV = 'test';
+
+const chai = require('chai');
+
+const dirtyChai = require('dirty-chai');
+
+chai.use(dirtyChai);
+
+const chaiXml = require('chai-xml');
+
+chai.use(chaiXml);
+
+const chaiHttp = require('chai-http');
+
+const assert = chai.assert;
+
+const expect = chai.expect;
+
+const should = chai.should(); // actually call the function
+
+const libs = `${process.cwd()}/libs`;
+
+const server = require(`${libs}/app`);
+
+const mongoose = require('../libs/db/mongoose');
+//const Simulation = require('../libs/models/simulation');
+const User = require('../libs/models/user');
+
+chai.use(chaiHttp);
+describe('Authenticates a user', () => {
+
+ beforeEach(() => {
+ User.remove({}, (err) => {
+ console.log('Test collection purged');
+ });
+ });
+
+ it('should authenticate a user', (done) => {
+ let newUser = new User();
+
+ newUser.email = 'lorem@ipsum.com';
+ newUser.password = '123mudar';
+ newUser.name = 'Gute';
+ newUser.cpf = '08236017907';
+ newUser.schooling = 'Doutorado';
+ newUser.course = 'Ciência da Computação';
+ newUser.segment = 'Comunidade acadêmica';
+ newUser.role = 'Pesquisador';
+ newUser.institution_name = 'UFPR';
+ newUser.state = 'PR';
+ newUser.city = 'Curitiba';
+
+ newUser.save((err) => {
+ if (err) {
+ console.log('MongoDB error:' + err);
+ }
+ }).then(function(newuser){
+ chai.request(server)
+ .post('/api/v1/user/authenticate')
+ .set('content-type', 'application/x-www-form-urlencoded')
+ .set('x-apicache-bypass', 'true')
+ .send({email: 'lorem@ipsum.com',
+ password: '123mudar'})
+ .end((err, res) => {
+ let token;
+
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(true);
+ res.body.should.have.property('token');
+ token = res.body.token;
+ token.substr(0, 3).should.equal('JWT');
+ done();
+ });
+ });
+ });
+
+ it('should not authenticate a user with wrong password', (done) => {
+ let newUser = new User();
+
+ newUser.email = 'lorem@ipsum.com';
+ newUser.password = '123mudar';
+ newUser.name = 'Gute';
+ newUser.cpf = '08236017907';
+ newUser.schooling = 'Doutorado';
+ newUser.course = 'Ciência da Computação';
+ newUser.segment = 'Comunidade acadêmica';
+ newUser.role = 'Pesquisador';
+ newUser.institution_name = 'UFPR';
+ newUser.state = 'PR';
+ newUser.city = 'Curitiba';
+
+ newUser.save((err) => {
+ if (err) {
+ console.log('MongoDB error:' + err);
+ }
+ }).then(function(newuser){
+ chai.request(server)
+ .post('/api/v1/user/authenticate')
+ .set('content-type', 'application/x-www-form-urlencoded')
+ .set('x-apicache-bypass', 'true')
+ .send({email: 'lorem@ipsum.com',
+ password: 'umasenhaerrada'})
+ .end((err, res) => {
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ res.body.should.have.property('msg');
+ res.body.msg.should.equal('A Senha informada é inválida.')
+ done();
+ });
+ });
+ });
+
+ it('should not authenticate a user with wrong email', (done) => {
+ let newUser = new User();
+
+ newUser.email = 'lorem@ipsum.com';
+ newUser.password = '123mudar';
+ newUser.name = 'Gute';
+ newUser.cpf = '08236017907';
+ newUser.schooling = 'Doutorado';
+ newUser.course = 'Ciência da Computação';
+ newUser.segment = 'Comunidade acadêmica';
+ newUser.role = 'Pesquisador';
+ newUser.institution_name = 'UFPR';
+ newUser.state = 'PR';
+ newUser.city = 'Curitiba';
+
+ newUser.save((err) => {
+ if (err) {
+ console.log('MongoDB error:' + err);
+ }
+ }).then(function(newuser){
+ chai.request(server)
+ .post('/api/v1/user/authenticate')
+ .set('content-type', 'application/x-www-form-urlencoded')
+ .set('x-apicache-bypass', 'true')
+ .send({email: 'dolor@ipsum.com',
+ password: '123mudar'})
+ .end((err, res) => {
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ res.body.should.have.property('msg');
+ res.body.msg.should.equal('O Email informado não está cadastrado.')
+ done();
+ });
+ });
+ });
+
+ it('should not authenticate a user with missing email', (done) => {
+ let newUser = new User();
+
+ newUser.email = 'lorem@ipsum.com';
+ newUser.password = '123mudar';
+ newUser.name = 'Gute';
+ newUser.cpf = '08236017907';
+ newUser.schooling = 'Doutorado';
+ newUser.course = 'Ciência da Computação';
+ newUser.segment = 'Comunidade acadêmica';
+ newUser.role = 'Pesquisador';
+ newUser.institution_name = 'UFPR';
+ newUser.state = 'PR';
+ newUser.city = 'Curitiba';
+
+ newUser.save((err) => {
+ if (err) {
+ console.log('MongoDB error:' + err);
+ }
+ }).then(function(newuser){
+ chai.request(server)
+ .post('/api/v1/user/authenticate')
+ .set('content-type', 'application/x-www-form-urlencoded')
+ .set('x-apicache-bypass', 'true')
+ .send({password: '123mudar'})
+ .end((err, res) => {
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ res.body.should.have.property('msg');
+ res.body.msg.should.equal('O campo Email é obrigatório.')
+ done();
+ });
+ });
+ });
+
+ it('should not authenticate a user with missing password', (done) => {
+ let newUser = new User();
+
+ newUser.email = 'lorem@ipsum.com';
+ newUser.password = '123mudar';
+ newUser.name = 'Gute';
+ newUser.cpf = '08236017907';
+ newUser.schooling = 'Doutorado';
+ newUser.course = 'Ciência da Computação';
+ newUser.segment = 'Comunidade acadêmica';
+ newUser.role = 'Pesquisador';
+ newUser.institution_name = 'UFPR';
+ newUser.state = 'PR';
+ newUser.city = 'Curitiba';
+
+ newUser.save((err) => {
+ if (err) {
+ console.log('MongoDB error:' + err);
+ }
+ }).then(function(newuser){
+ chai.request(server)
+ .post('/api/v1/user/authenticate')
+ .set('content-type', 'application/x-www-form-urlencoded')
+ .set('x-apicache-bypass', 'true')
+ .send({email:'lorem@ipsum.com'})
+ .end((err, res) => {
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ res.body.should.have.property('msg');
+ res.body.msg.should.equal('O campo Senha é obrigatório.')
+ done();
+ });
+ });
+ });
+});
diff --git a/src/test/simulation.js b/src/test/simulation.js
new file mode 100644
index 0000000000000000000000000000000000000000..a9349256b29bc20068eb74b0172e15d0dbe28937
--- /dev/null
+++ b/src/test/simulation.js
@@ -0,0 +1,869 @@
+process.env.NODE_ENV = 'test';
+
+const chai = require('chai');
+
+const dirtyChai = require('dirty-chai');
+
+chai.use(dirtyChai);
+
+const chaiXml = require('chai-xml');
+
+chai.use(chaiXml);
+
+const chaiHttp = require('chai-http');
+
+const assert = chai.assert;
+
+const expect = chai.expect;
+
+const should = chai.should(); // actually call the function
+
+const libs = `${process.cwd()}/libs`;
+
+const server = require(`${libs}/app`);
+
+const mongoose = require('../libs/db/mongoose');
+const Simulation = require('../libs/models/simulation');
+const User = require('../libs/models/user');
+
+chai.use(chaiHttp);
+describe('Requires a simulation', () => {
+ let newSimulation;
+
+ beforeEach(() => {
+ Simulation.remove({}, (err) => {
+ console.log('Test collection purged');
+ });
+ });
+
+ it('should create a new simulation', (done) => {
+ chai.request(server)
+ .post('/api/v1/simulation')
+ .set('content-type', 'application/x-www-form-urlencoded')
+ .set('x-apicache-bypass', 'true')
+ .send({ name: 'test_entry' })
+ .end((err, res) => {
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('id');
+ res.body.id.should.be.a('string');
+ Simulation.findById(res.body.id, (err, simulation) => {
+ simulation.should.have.property('name');
+ simulation.name.should.be.a('string');
+ simulation.name.should.equal('test_entry');
+ done();
+ });
+ });
+ });
+ it('should not create a nameless simulation', (done) => {
+ chai.request(server)
+ .post('/api/v1/simulation')
+ .set('content-type', 'application/x-www-form-urlencoded')
+ .set('x-apicache-bypass', 'true')
+ .end((err, res) => {
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.not.have.property('id');
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ Simulation.findById(res.body.id, (err, simulation) => {
+ expect(simulation).to.not.exist;
+ done();
+ });
+ });
+ });
+ it('should find an existing simulation', (done) => {
+ newSimulation = new Simulation();
+ newSimulation.name = 'test';
+ newSimulation.save((err, sim) => {
+ let id = sim._id;
+ chai.request(server)
+ .get(`/api/v1/simulation/${id}`)
+ .end((err, res) => {
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('_id');
+ res.body._id.should.be.a('string');
+ res.body.should.have.property('name');
+ res.body._id.should.be.a('string');
+ done();
+ });
+ });
+ });
+ it('should not find an unexisting simulation', (done) => {
+ newSimulation = new Simulation();
+ let id = newSimulation._id;
+ chai.request(server)
+ .get(`/api/v1/simulation/${id}`)
+ .end((err, res) => {
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ done();
+ });
+ });
+ it('should update an existing simulation\'s location', (done) => {
+ newSimulation = new Simulation();
+ newSimulation.name = 'test';
+ newSimulation.save((err, sim) => {
+ let id = sim._id;
+ chai.request(server)
+ .post(`/api/v1/simulation/${id}`)
+ .send({ location: 5 })
+ .end((err, res) => {
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('id');
+ res.body.id.should.be.a('string');
+ Simulation.findById(res.body.id, (err, simulation) => {
+ simulation.should.have.property('name');
+ simulation.name.should.be.a('string');
+ simulation.name.should.equal('test');
+ simulation.should.have.property('location');
+ simulation.location.should.be.a('number');
+ simulation.location.should.equal(5);
+ done();
+ });
+ });
+ });
+ });
+ it('should update multiple fields on a single request', (done) => {
+ newSimulation = new Simulation();
+ newSimulation.name = 'test';
+ newSimulation.save((err, sim) => {
+ let id = sim._id;
+ chai.request(server)
+ .post(`/api/v1/simulation/${id}`)
+ .send({
+ name: 'new_name',
+ location: 5,
+ time: 3,
+ failure_rate: [0.1, 0.2, 0.3],
+ goals_care: [0.3, 0.2, 0.1],
+ goals_inclusion: [0.8, 0.9, 1]
+ })
+ .end((err, res) => {
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('id');
+ res.body.id.should.be.a('string');
+ Simulation.findById(res.body.id, (err, simulation) => {
+ simulation.should.have.property('name');
+ simulation.name.should.be.a('string');
+ simulation.name.should.equal('new_name');
+ simulation.should.have.property('location');
+ simulation.location.should.be.a('number');
+ simulation.location.should.equal(5);
+ simulation.should.have.property('time');
+ simulation.time.should.be.a('number');
+ simulation.time.should.equal(3);
+ simulation.should.have.property('failure_rate');
+ simulation.failure_rate.should.be.a('array');
+ simulation.failure_rate.length.should.equal(3);
+ simulation.should.have.property('goals_care');
+ simulation.goals_care.should.be.a('array');
+ simulation.goals_care.length.should.equal(3);
+ simulation.should.have.property('goals_inclusion');
+ simulation.goals_inclusion.should.be.a('array');
+ simulation.goals_inclusion.length.should.equal(3);
+ done();
+ });
+ });
+ });
+ });
+ it('should not update an unexisting simulation', (done) => {
+ newSimulation = new Simulation();
+ let id = newSimulation._id;
+ chai.request(server)
+ .post(`/api/v1/simulation/${id}`)
+ .send({ location: 5 })
+ .end((err, res) => {
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ done();
+ });
+ });
+ it('should update an existing simulation\'s time', (done) => {
+ newSimulation = new Simulation();
+ newSimulation.name = 'test';
+ newSimulation.save((err, sim) => {
+ let id = sim._id;
+ chai.request(server)
+ .post(`/api/v1/simulation/${id}`)
+ .send({ time: 5 })
+ .end((err, res) => {
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('id');
+ res.body.id.should.be.a('string');
+ Simulation.findById(res.body.id, (err, simulation) => {
+ simulation.should.have.property('name');
+ simulation.name.should.be.a('string');
+ simulation.should.have.property('time');
+ simulation.time.should.be.a('number');
+ simulation.time.should.equal(5);
+ done();
+ });
+ });
+ });
+ });
+ it('should not change results for empty post requests', (done) => {
+ newSimulation = new Simulation();
+ newSimulation.name = 'test';
+ newSimulation.save((err, sim) => {
+ let id = sim._id;
+ chai.request(server)
+ .post(`/api/v1/simulation/${id}`)
+ .end((err, res) => {
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ done();
+ });
+ });
+ });
+ it('should not update in case of invalid field', (done) => {
+ newSimulation = new Simulation();
+ newSimulation.name = 'test';
+ newSimulation.save((err, sim) => {
+ let id = sim._id;
+ chai.request(server)
+ .post(`/api/v1/simulation/${id}`)
+ .send({
+ name: 'other_name',
+ totally_not_valid_value_for_an_entry: 'not hacking this api',
+ })
+ .end((err, res) => {
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ Simulation.findById(id, (err, simulation) => {
+ simulation.name.should.equal('test');
+ done();
+ });
+ });
+ });
+ });
+ it('should include consistent enrollment tables', (done) => {
+ newSimulation = new Simulation();
+ newSimulation.name = 'test';
+ newSimulation.save((err, sim) => {
+ let id = sim._id;
+ chai.request(server)
+ .post(`/api/v1/simulation/${id}`)
+ .send({
+ time: 5,
+ enrollments: "[[100, 150, 200, 250, 300]]",
+ })
+ .end((err, res) => {
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('id');
+ res.body.id.should.be.a('string');
+ Simulation.findById(res.body.id, (err, simulation) => {
+ simulation.should.have.property('name');
+ simulation.name.should.be.a('string');
+ simulation.should.have.property('time');
+ simulation.time.should.be.a('number');
+ simulation.time.should.equal(5);
+ done();
+ });
+ });
+ });
+ });
+ it('should not accept an invalid time', (done) => {
+ newSimulation = new Simulation();
+ newSimulation.name = 'test';
+ newSimulation.save((err, sim) => {
+ let id = sim._id;
+ chai.request(server)
+ .post(`/api/v1/simulation/${id}`)
+ .send({
+ time: "I'm an inocent time entry, don't mind me",
+ })
+ .end((err, res) => {
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ });
+ done();
+ });
+ });
+ it('should not accept enrollments table different than provided time', (done) => {
+ newSimulation = new Simulation();
+ newSimulation.name = 'test';
+ newSimulation.save((err, sim) => {
+ let id = sim._id;
+ chai.request(server)
+ .post(`/api/v1/simulation/${id}`)
+ .send({
+ time: 5,
+ enrollments: "[[1,2,3]]",
+ })
+ .end((err, res) => {
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ done();
+ });
+ });
+ });
+ it('should not include arrays of non arrays as enrollments', (done) => {
+ newSimulation = new Simulation();
+ newSimulation.name = 'test';
+ newSimulation.save((err, sim) => {
+ let id = sim._id;
+ chai.request(server)
+ .post(`/api/v1/simulation/${id}`)
+ .send({
+ time: 5,
+ enrollments: "[\"Tomato\"]",
+ })
+ .end((err, res) => {
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ done();
+ });
+ });
+ });
+ it('should not accept non array enrollments', (done) => {
+ newSimulation = new Simulation();
+ newSimulation.name = 'test';
+ newSimulation.save((err, sim) => {
+ let id = sim._id;
+ chai.request(server)
+ .post(`/api/v1/simulation/${id}`)
+ .send({
+ time: 5,
+ enrollments: "Am I still wanted here?",
+ })
+ .end((err, res) => {
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ done();
+ });
+ });
+ });
+ it('should not accept an enrollment with anything other than a number', (done) => {
+ newSimulation = new Simulation();
+ newSimulation.name = 'test';
+ newSimulation.save((err, sim) => {
+ let id = sim._id;
+ chai.request(server)
+ .post(`/api/v1/simulation/${id}`)
+ .send({
+ time: 5,
+ enrollments: "[[1,2,\"malicious payload\",4,5]]",
+ })
+ .end((err, res) => {
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ done();
+ });
+ });
+ });
+ it('should delete an entry', (done) => {
+ newSimulation = new Simulation();
+ newSimulation.name = 'test';
+ newSimulation.save((err, sim) => {
+ let id = sim._id;
+ chai.request(server)
+ .delete(`/api/v1/simulation/${id}`)
+ .end((err, res) => {
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(true);
+ done();
+ });
+ });
+ });
+ it('should not delete an unexisting entry', (done) => {
+ let sim = new Simulation();
+ let id = sim._id;
+ chai.request(server)
+ .delete(`/api/v1/simulation/${id}`)
+ .end((err, res) => {
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ done();
+ });
+ });
+});
+
+describe('Saves a user', () => {
+
+ beforeEach(() => {
+ User.remove({}, (err) => {
+ console.log('Test collection purged');
+ });
+ });
+
+ it('should create a new user', (done) => {
+ chai.request(server)
+ .post('/api/v1/user')
+ .set('content-type', 'application/x-www-form-urlencoded')
+ .set('x-apicache-bypass', 'true')
+ .send({email: 'lorem@ipsum.com',
+ password: '123mudar',
+ name: 'Tequila Baby',
+ cpf: '48303270737',
+ schooling: 'Doutorado',
+ course: 'Ciência da Computação',
+ segment: 'Comunidade acadêmica',
+ role: 'Pesquisador',
+ institution_name: 'UFPR',
+ state: 'PR',
+ city: 'Cutiriba'})
+ .end((err, res) =>{
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(true);
+ User.findOne({'email': 'lorem@ipsum.com'}, (err, user) => {
+ if (err){
+ console.log('MongoDB error: ' + err);
+ }
+
+ user.should.have.property('email');
+ done();
+ });
+ });
+ });
+
+ it('should not create a user with an email that is already in use', (done) => {
+ let newUser = new User();
+
+ newUser.email = 'lorem@ipsum.com';
+ newUser.password = '123mudar';
+ newUser.name = 'Gute';
+ newUser.cpf = '08236017907';
+ newUser.schooling = 'Doutorado';
+ newUser.course = 'Ciência da Computação';
+ newUser.segment = 'Comunidade acadêmica';
+ newUser.role = 'Pesquisador';
+ newUser.institution_name = 'UFPR';
+ newUser.state = 'PR';
+ newUser.city = 'Curitiba';
+
+ newUser.save((err) => {
+ if (err) {
+ console.log('MongoDB error:' + err);
+ }
+ }).then(function(newuser){
+ chai.request(server)
+ .post('/api/v1/user')
+ .set('content-type', 'application/x-www-form-urlencoded')
+ .set('x-apicache-bypass', 'true')
+ .send({email: 'lorem@ipsum.com',
+ password: '123mudar',
+ name: 'Tequila Baby',
+ cpf: '48303270737',
+ schooling: 'Doutorado',
+ course: 'Ciência da Computação',
+ segment: 'Comunidade acadêmica',
+ role: 'Pesquisador',
+ institution_name: 'UFPR',
+ state: 'PR',
+ city: 'Cutiriba'})
+ .end((err, res) =>{
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ res.body.should.have.property('msg');
+ res.body.msg.should.equal('O email informado já está cadastrado.');
+ User.findOne({'cpf': '48303270737'}, (err, user) => {
+ expect(user).to.not.exist;
+ done();
+ });
+ });
+ });
+ });
+
+ it('should not create a user with a CPF that is already in use', (done) => {
+ let newUser = new User();
+
+ newUser.email = 'lorem@ipsum.com';
+ newUser.password = '123mudar';
+ newUser.name = 'Gute';
+ newUser.cpf = '08236017907';
+ newUser.schooling = 'Doutorado';
+ newUser.course = 'Ciência da Computação';
+ newUser.segment = 'Comunidade acadêmica';
+ newUser.role = 'Pesquisador';
+ newUser.institution_name = 'UFPR';
+ newUser.state = 'PR';
+ newUser.city = 'Curitiba';
+
+ newUser.save((err) => {
+ if (err) {
+ console.log('MongoDB error:' + err);
+ }
+ }).then(function(newuser){
+ chai.request(server)
+ .post('/api/v1/user')
+ .set('content-type', 'application/x-www-form-urlencoded')
+ .set('x-apicache-bypass', 'true')
+ .send({email: 'dolor@ipsum.com',
+ password: '123mudar',
+ name: 'Tequila Baby',
+ cpf: '08236017907',
+ schooling: 'Doutorado',
+ course: 'Ciência da Computação',
+ segment: 'Comunidade acadêmica',
+ role: 'Pesquisador',
+ institution_name: 'UFPR',
+ state: 'PR',
+ city: 'Cutiriba'})
+ .end((err, res) =>{
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ res.body.should.have.property('msg');
+ res.body.msg.should.equal('O CPF informado já está cadastrado.');
+ User.findOne({'email': 'dolor@ipsum.com'}, (err, user) => {
+ expect(user).to.not.exist;
+ done();
+ });
+ });
+ });
+ });
+
+ it('should not save an user without email', (done) => {
+ chai.request(server)
+ .post('/api/v1/user')
+ .set('content-type', 'application/x-www-form-urlencoded')
+ .set('x-apicache-bypass', 'true')
+ .send({password: '123mudar',
+ name: 'Tequila Baby',
+ cpf: '48303270737',
+ schooling: 'Doutorado',
+ course: 'Ciência da Computação',
+ segment: 'Comunidade acadêmica',
+ role: 'Pesquisador',
+ institution_name: 'UFPR',
+ state: 'PR',
+ city: 'Cutiriba'})
+ .end((err, res) =>{
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ res.body.should.have.property('msg');
+ res.body.msg.should.equal('O campo Email é obrigatório.');
+ User.findOne({'cpf': '48303270737'}, (err, user) => {
+ expect(user).to.not.exist;
+ done();
+ });
+ });
+ });
+
+ it('should not save an user without password', (done) => {
+ chai.request(server)
+ .post('/api/v1/user')
+ .set('content-type', 'application/x-www-form-urlencoded')
+ .set('x-apicache-bypass', 'true')
+ .send({email: 'lorem@ipsum.com',
+ name: 'Tequila Baby',
+ cpf: '48303270737',
+ schooling: 'Doutorado',
+ course: 'Ciência da Computação',
+ segment: 'Comunidade acadêmica',
+ role: 'Pesquisador',
+ institution_name: 'UFPR',
+ state: 'PR',
+ city: 'Cutiriba'})
+ .end((err, res) =>{
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ res.body.should.have.property('msg');
+ res.body.msg.should.equal('O campo Senha é obrigatório.');
+ User.findOne({'cpf': '48303270737'}, (err, user) => {
+ expect(user).to.not.exist;
+ done();
+ });
+ });
+ });
+
+ it('should not save an user with invalid email', (done) => {
+ chai.request(server)
+ .post('/api/v1/user')
+ .set('content-type', 'application/x-www-form-urlencoded')
+ .set('x-apicache-bypass', 'true')
+ .send({email: 'notavalidemail',
+ password: '123mudar',
+ name: 'Tequila Baby',
+ cpf: '48303270737',
+ schooling: 'Doutorado',
+ course: 'Ciência da Computação',
+ segment: 'Comunidade acadêmica',
+ role: 'Pesquisador',
+ institution_name: 'UFPR',
+ state: 'PR',
+ city: 'Cutiriba'})
+ .end((err, res) =>{
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ res.body.should.have.property('msg');
+ res.body.msg.should.equal('O email informado é inválido.');
+ User.findOne({'cpf': '48303270737'}, (err, user) => {
+ expect(user).to.not.exist;
+ done();
+ });
+ });
+ });
+
+ it('should not save an user without name', (done) => {
+ chai.request(server)
+ .post('/api/v1/user')
+ .set('content-type', 'application/x-www-form-urlencoded')
+ .set('x-apicache-bypass', 'true')
+ .send({email: 'lorem@ipsum.com',
+ password: '123mudar',
+ cpf: '48303270737',
+ schooling: 'Doutorado',
+ course: 'Ciência da Computação',
+ segment: 'Comunidade acadêmica',
+ role: 'Pesquisador',
+ institution_name: 'UFPR',
+ state: 'PR',
+ city: 'Cutiriba'})
+ .end((err, res) =>{
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ res.body.should.have.property('msg');
+ res.body.msg.should.equal('O campo Nome é obrigatório.');
+ User.findOne({'cpf': '48303270737'}, (err, user) => {
+ expect(user).to.not.exist;
+ done();
+ });
+ });
+ });
+
+ it('should not save an user without CPF', (done) => {
+ chai.request(server)
+ .post('/api/v1/user')
+ .set('content-type', 'application/x-www-form-urlencoded')
+ .set('x-apicache-bypass', 'true')
+ .send({email: 'lorem@ipsum.com',
+ password: '123mudar',
+ name: 'Tequila baby',
+ schooling: 'Doutorado',
+ course: 'Ciência da Computação',
+ segment: 'Comunidade acadêmica',
+ role: 'Pesquisador',
+ institution_name: 'UFPR',
+ state: 'PR',
+ city: 'Cutiriba'})
+ .end((err, res) =>{
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ res.body.should.have.property('msg');
+ res.body.msg.should.equal('O campo CPF é obrigatório.');
+ User.findOne({'email': 'lorem@ipsum.com'}, (err, user) => {
+ expect(user).to.not.exist;
+ done();
+ });
+ });
+ });
+
+ it('should not save an user without segment', (done) => {
+ chai.request(server)
+ .post('/api/v1/user')
+ .set('content-type', 'application/x-www-form-urlencoded')
+ .set('x-apicache-bypass', 'true')
+ .send({email: 'lorem@ipsum.com',
+ password: '123mudar',
+ name: 'Tequila baby',
+ schooling: 'Doutorado',
+ cpf: '48303270737',
+ course: 'Ciência da Computação',
+ role: 'Pesquisador',
+ institution_name: 'UFPR',
+ state: 'PR',
+ city: 'Cutiriba'})
+ .end((err, res) =>{
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ res.body.should.have.property('msg');
+ res.body.msg.should.equal('O campo Segmento é obrigatório.');
+ User.findOne({'email': 'lorem@ipsum.com'}, (err, user) => {
+ expect(user).to.not.exist;
+ done();
+ });
+ });
+ });
+
+ it('should not save an user without schooling', (done) => {
+ chai.request(server)
+ .post('/api/v1/user')
+ .set('content-type', 'application/x-www-form-urlencoded')
+ .set('x-apicache-bypass', 'true')
+ .send({email: 'lorem@ipsum.com',
+ password: '123mudar',
+ name: 'Tequila baby',
+ cpf: '48303270737',
+ course: 'Ciência da Computação',
+ segment: 'Comunidade acadêmica',
+ role: 'Pesquisador',
+ institution_name: 'UFPR',
+ state: 'PR',
+ city: 'Cutiriba'})
+ .end((err, res) =>{
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ res.body.should.have.property('msg');
+ res.body.msg.should.equal('O campo Escolaridade é obrigatório.');
+ User.findOne({'email': 'lorem@ipsum.com'}, (err, user) => {
+ expect(user).to.not.exist;
+ done();
+ });
+ });
+ });
+
+ it('should not save an user without role', (done) => {
+ chai.request(server)
+ .post('/api/v1/user')
+ .set('content-type', 'application/x-www-form-urlencoded')
+ .set('x-apicache-bypass', 'true')
+ .send({email: 'lorem@ipsum.com',
+ password: '123mudar',
+ name: 'Tequila baby',
+ schooling: 'Doutorado',
+ cpf: '48303270737',
+ course: 'Ciência da Computação',
+ segment: 'Comunidade acadêmica',
+ institution_name: 'UFPR',
+ state: 'PR',
+ city: 'Cutiriba'})
+ .end((err, res) =>{
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ res.body.should.have.property('msg');
+ res.body.msg.should.equal('O campo Função é obrigatório.');
+ User.findOne({'email': 'lorem@ipsum.com'}, (err, user) => {
+ expect(user).to.not.exist;
+ done();
+ });
+ });
+ });
+
+ it('should not save an user without institution', (done) => {
+ chai.request(server)
+ .post('/api/v1/user')
+ .set('content-type', 'application/x-www-form-urlencoded')
+ .set('x-apicache-bypass', 'true')
+ .send({email: 'lorem@ipsum.com',
+ password: '123mudar',
+ name: 'Tequila baby',
+ schooling: 'Doutorado',
+ cpf: '48303270737',
+ course: 'Ciência da Computação',
+ segment: 'Comunidade acadêmica',
+ role: 'Pesquisador',
+ state: 'PR',
+ city: 'Cutiriba'})
+ .end((err, res) =>{
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ res.body.should.have.property('msg');
+ res.body.msg.should.equal('O campo Instituição em que trabalha é obrigatório.');
+ User.findOne({'email': 'lorem@ipsum.com'}, (err, user) => {
+ expect(user).to.not.exist;
+ done();
+ });
+ });
+ });
+
+ it('should not save an user without city', (done) => {
+ chai.request(server)
+ .post('/api/v1/user')
+ .set('content-type', 'application/x-www-form-urlencoded')
+ .set('x-apicache-bypass', 'true')
+ .send({email: 'lorem@ipsum.com',
+ password: '123mudar',
+ name: 'Tequila baby',
+ schooling: 'Doutorado',
+ cpf: '48303270737',
+ course: 'Ciência da Computação',
+ segment: 'Comunidade acadêmica',
+ institution_name: 'UFPR',
+ role: 'Pesquisador',
+ state: 'PR'})
+ .end((err, res) =>{
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ res.body.should.have.property('msg');
+ res.body.msg.should.equal('O campo Cidade é obrigatório.');
+ User.findOne({'email': 'lorem@ipsum.com'}, (err, user) => {
+ expect(user).to.not.exist;
+ done();
+ });
+ });
+ });
+
+ it('should not save an user without state', (done) => {
+ chai.request(server)
+ .post('/api/v1/user')
+ .set('content-type', 'application/x-www-form-urlencoded')
+ .set('x-apicache-bypass', 'true')
+ .send({email: 'lorem@ipsum.com',
+ password: '123mudar',
+ name: 'Tequila baby',
+ schooling: 'Doutorado',
+ cpf: '48303270737',
+ course: 'Ciência da Computação',
+ segment: 'Comunidade acadêmica',
+ institution_name: 'UFPR',
+ role: 'Pesquisador',
+ city: 'Cutiriba'})
+ .end((err, res) =>{
+ res.should.have.status(200);
+ res.should.be.json;
+ res.body.should.have.property('success');
+ res.body.success.should.equal(false);
+ res.body.should.have.property('msg');
+ res.body.msg.should.equal('O campo Estado é obrigatório.');
+ User.findOne({'email': 'lorem@ipsum.com'}, (err, user) => {
+ expect(user).to.not.exist;
+ done();
+ });
+ });
+ });
+
+});