Initial commit

src/libs/middlewares/checkVersion.js

+const curPath = process.cwd();
+const libs = `${process.cwd()}/libs`;
+const log = require(`${libs}/log`)(module);
+const chalk = require('chalk');
+const packageConf = require(`${curPath}/package.json`);
+
+module.exports = () => {
+    // Parse version number from strings such as 'v4.2.0' or `>=4.0.0'
+    function parseVersionNumber(versionString) {
+        return parseFloat(versionString.replace(/[^\d\.]/g, ''));
+    }
+    // Ensure minimum supported node version is used
+    const minNodeVersion = parseVersionNumber(packageConf.engines.node);
+    const currentNodeVersion = parseVersionNumber(process.version);
+    if (minNodeVersion > currentNodeVersion) {
+        log.error(chalk.red(`You must upgrade node to >=${minNodeVersion}.x to use simcaq-node!`));
+        return false;
+    } else {
+        log.info('Node version should work!');
+        return true;
+    }
+};

src/libs/middlewares/passport.js

+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));
+  }
+ */

src/libs/models/filters.js

+const mongoose = require('mongoose');
+const libs = `${process.cwd()}/libs`;
+const log = require(`${libs}/log`)(module);
+const Schema = mongoose.Schema;
+
+// set up a mongoose model
+var FilterSchema = new Schema({
+    name: {
+        type: String,
+        required: true
+    },
+    route: {
+        type: String,
+        required: true
+    },
+    url: {
+        type: String,
+        required: true
+    },
+    unfiltrable: {
+        type: String
+    },
+    lineable: {
+        available: {
+            type: Boolean
+        },
+        requiredNullFilters: [String]
+    },
+    columnable: {
+        available: {
+            type: Boolean
+        },
+        requiredNullFilters: [String],
+        forbidden: [String]
+    }
+});
+
+module.exports = mongoose.model('Filter', FilterSchema);

src/libs/models/indicator.js

+const mongoose = require('mongoose');
+const libs = `${process.cwd()}/libs`;
+const log = require(`${libs}/log`)(module);
+const Schema = mongoose.Schema;
+const Filters = require(`${libs}/models/filters`);
+
+// set up a mongoose model
+var IndicatorSchema = new Schema({
+    filters: {
+        type: [Schema.types.ObjectId],
+        ref: 'Filters'
+    },
+    name: {
+        type: String,
+        required: true
+    },
+    url: {
+        type: String,
+        required: true,
+        unique: true
+    },
+    active: {
+        type: Boolean,
+        required: true,
+        default: false
+    },
+    description: {
+        type: String,
+        required: true,
+        default: 'Lorem Ipsum'
+    },
+    route: {
+        type: String,
+        required: true
+    },
+    source: {
+        type: String,
+        required: true
+    },
+    noSchools: {
+        type: Boolean
+    }
+});
+
+module.exports = mongoose.model('Indicator', IndicatorSchema);

src/libs/models/message.js

+const mongoose = require('mongoose');
+const libs = `${process.cwd()}/libs`;
+const log = require(`${libs}/log`)(module);
+const Schema = mongoose.Schema;
+
+// set up a mongoose model
+var MessageSchema = new Schema({
+    author: {
+        name: {
+            type: String,
+            required: true
+        },
+        email: {
+            type: String,
+            required: true
+        }
+    },
+    read: {
+        type: Boolean,
+        required: true,
+        default: false
+    },
+    archived: {
+        type: Boolean,
+        required: true,
+        default: false
+    },
+    contents: {
+        type: String,
+        required: true
+    }
+});
+
+module.exports = mongoose.model('Message', MessageSchema);

src/libs/models/user.js

+const mongoose = require('mongoose');
+const bcrypt = require('bcrypt-nodejs');
+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, 'O campo Email é obrigatório.']
+    },
+    password: {
+        type: String,
+        required: [true, 'O campo Senha é obrigatório.']
+    },
+    name: {
+        type: String,
+        required: [true, 'O campo Nome é obrigatório.']
+    },
+    cpf:{
+        type: String,
+        unique: true,
+        required: [true, 'O campo CPF é obrigatório.']
+    },
+    schooling: {
+        type: String,
+        required: [true, 'O campo Escolaridade é obrigatório.']
+    },
+    course: {
+        type: String,
+    },
+    segment: {
+        type: String,
+        required: [true, 'O campo Segmento é obrigatório.']
+    },
+    role: {
+        type: String,
+        required: [true, 'O campo Função é obrigatório.']
+    },
+    institution_name: {
+        type: String,
+        required: [true, 'O campo Instituição em que trabalha é obrigatório.']
+    },
+    state: {
+        type: String,
+        required: [true, 'O campo Estado é obrigatório.']
+    },
+    city: {
+        type: String,
+        required: [true, 'O campo Cidade é obrigatório.']
+    },
+    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, null, 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);

src/libs/routes/api.js

+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, statusCodes: {include: [200]} }).middleware;
+
+const user = require(`${libs}/routes/user`);
+
+const message = require(`${libs}/routes/message`);
+
+api.get('/', (req, res) => {
+    res.json({ msg: 'SimCAQ API is running' });
+});
+
+api.use('/user', user);
+api.use('/message', message);
+
+module.exports = api;

src/libs/routes/message.js

+const express = require('express');
+
+const messageApp = express();
+
+const libs = `${process.cwd()}/libs`;
+
+const config = require(`${libs}/config`);
+
+const log = require(`${libs}/log`)(module);
+
+const Message = require(`${libs}/models/message`);
+
+messageApp.get('/', (req, res, next) => {
+    Message.find((err, messages) => {
+        if(err) {
+            res.status(500).json({error: 'Erro do servidor', text: 'O servidor encontrou um erro ao processar a requisição', err});
+        }
+        res.json(messages);
+    });
+});
+
+messageApp.put('/:id', (req, res, next) => {
+    Message.findById(req.params.id, (err, message) => {
+        if(!message) {
+            res.status(404).json({error: 'Não encontrado', text: 'Nenhuma mensagem foi encontrada', err});
+        }
+        if(!err) {
+            log.debug(req.body);
+            message.read = req.body.read | message.read;
+            message.archived = req.body.archived | message.archived;
+            message.save((err) => {
+                if(err) {
+                    res.status(500).json({error: 'Erro do servidor', text: 'O servidor encontrou um erro ao processar a requisição', err});
+                }
+                res.json(message);
+            });
+        } else {
+            res.status(500).json({error: 'Erro do servidor', text: 'O servidor encontrou um erro ao processar a requisição', err});
+        }
+    });
+});
+
+messageApp.post('/', (req, res, next) => {
+    let message = new Message({
+        author: {
+            name: req.body.name,
+            email: req.body.email
+        },
+        contents: req.body.contents
+    });
+
+    message.save((err) => {
+        if(err) {
+            res.status(500).json({error: 'Erro do servidor', text: 'O servidor encontrou um erro ao processar a requisição', err});
+        }
+        res.json(message);
+    })
+});
+
+module.exports = messageApp;

src/libs/routes/user.js

+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){
+        if(!emailSyntax(req.body.email)){
+            res.json({success: false, msg: 'O email informado é inválido.'});
+        } else {
+            next();
+        }
+    } 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){
+            let errArray = [];
+            let errMsg = '';
+            for (var e in err.errors) {
+                    errArray.push(err.errors[`${e}`].message);
+            }
+            for (var i = 0; i < errArray.length; i++) {
+                    if(i > 0){
+                        errMsg = '\n' + errMsg + errArray[i];
+                    }
+                    else{
+                        errMsg = errMsg + errArray[i];
+                    }
+            }
+            res.json({success: false, msg: errMsg});
+        }
+         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;

src/server.js

+const debug = require('debug')('simcaq-api');
+const libs = `${process.cwd()}/libs`;
+const config = require(`${libs}/config`);
+const log = require(`${libs}/log`)(module);
+const app = require(`${libs}/app`);
+const compatVersion = require(`${libs}/middlewares/checkVersion`);
+const cluster = require('cluster');
+
+// Check if Node version is compatible
+if (!compatVersion()) {
+    process.exit(1);
+}
+
+if (cluster.isMaster) {
+    log.info(`Master ${process.pid} is running`);
+
+    const numCPUs = require('os').cpus().length;
+    log.info(`Master will create ${numCPUs} workers`);
+    for (let i=0; i < numCPUs; i+=1) {
+        cluster.fork();
+    }
+
+    // Caso uma instâcia morra
+    cluster.on('exit',  (worker, code, signal) => {
+        log.info(`Worker ${worker.process.pid} died`);
+        // Revive a instância
+        cluster.fork();
+    });
+} else {
+    // 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';
+    // Set default ip: first environment variable IOP, then configuration and last '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}`);
+    });
+
+    log.info(`Worker ${cluster.worker.id} is running (${process.pid})`);
+
+    // For testing
+    module.exports = server;
+}

src/test/api.js

+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`);
+
+chai.use(chaiHttp);
+
+describe('API is running', () => {
+    it('should respond it\'s running', (done) => {
+        chai.request(server)
+            .get('/api/v1')
+            .end((err, res) => {
+                res.should.have.status(200);
+                res.should.be.json;
+                res.body.should.have.property('msg');
+                done();
+            })
+    });
+
+    it('should respond with 404 error', (done) => {
+        chai.request(server)
+            .get('/api/v1/thisrouteshouldgivea404')
+            .end((err, res) => {
+                res.should.have.status(404);
+                res.should.be.json;
+                res.body.should.have.property('error');
+                done();
+            })
+    });
+});