diff --git a/config.json.example b/config.json.example
deleted file mode 100644
index 1fa157c1e562f3843ef2f44bf60e1793fbf9c1e7..0000000000000000000000000000000000000000
--- a/config.json.example
+++ /dev/null
@@ -1,157 +0,0 @@
-{
- "development":
- {
- "port": 3000,
- "ip": "127.0.0.1",
- "debug" : true,
- "monetdb": {
- "host": "simcaqdb3.c3sl.ufpr.br",
- "port": 50000,
- "dbname": "simcaq",
- "user": "monetdb",
- "password":"monetdb",
- "nrConnections": "4"
- },
- "cdn" : {
- "url": "http://simcaqdb3.c3sl.ufpr.br:3000",
- "download": "https://simcaqdev.c3sl.ufpr.br/download/"
- },
- "mongodb" : {
- "uri": "mongodb://localhost/dev_users"
- },
- "monq": {
- "uri": "mongodb://localhost/dev_monq"
- },
- "default": {
- "api": {
- "version" : "v1"
- },
- "lde": {
- "url": "http://ldedev.c3sl.ufpr.br/#"
- },
- "simcaq": {
- "url": "http://simcaqdev.c3sl.ufpr.br/#"
- }
- },
- "email": {
- "host": "SMTP.office365.com",
- "port": 587,
- "secureConnection": false,
- "auth": {
- "user": "dadoseducacionais@ufpr.br",
- "pass": "COLOCAR_A_SENHA_AQUI"
- },
- "tls": {
- "ciphers": "SSLv3"
- },
- "from": "\"Laboratório de Dados Educacionais\" <dadoseducacionais@ufpr.br>"
- },
- "security": {
- "tokenLife": 3600
- }
- },
- "test":
- {
- "port": 3000,
- "ip": "127.0.0.1",
- "debug" : true,
- "monetdb": {
- "host": "simcaqdb3.c3sl.ufpr.br",
- "port": 50000,
- "dbname": "simcaq",
- "user": "monetdb",
- "password":"monetdb",
- "nrConnections": "4"
- },
- "cdn" : {
- "url": "http://simcaqdb3.c3sl.ufpr.br:3000",
- "download": "https://simcaqdev.c3sl.ufpr.br/download/"
- },
- "mongodb" : {
- "uri": "mongodb://localhost/test_users",
- "secret": "SimCAQC3SL"
- },
- "monq": {
- "uri": "mongodb://localhost/test_monq"
- },
- "default": {
- "api": {
- "version" : "v1"
- },
- "lde": {
- "url": "http://ldedev.c3sl.ufpr.br/#"
- },
- "simcaq": {
- "url": "http://simcaqdev.c3sl.ufpr.br/#"
- }
- },
- "email": {
- "host": "SMTP.office365.com",
- "port": 587,
- "secureConnection": false,
- "auth": {
- "user": "dadoseducacionais@ufpr.br",
- "pass": "COLOCAR_A_SENHA_AQUI"
- },
- "tls": {
- "ciphers": "SSLv3"
- },
- "from": "\"Laboratório de Dados Educacionais\" <dadoseducacionais@ufpr.br>"
- },
- "security": {
- "tokenLife": 3600
- }
- },
- "production":
- {
- "port": 3000,
- "ip": "127.0.0.1",
- "debug" : false,
- "monetdb": {
- "host": "simcaqdb3.c3sl.ufpr.br",
- "port": 50000,
- "dbname": "simcaq",
- "user": "monetdb",
- "password":"monetdb",
- "nrConnections": "4"
- },
- "cdn" : {
- "url": "http://simcaqdb3.c3sl.ufpr.br:7000",
- "download": "https://simcaq.c3sl.ufpr.br/download/"
- },
- "mongodb" : {
- "uri": "mongodb://localhost/users",
- "secret": "SimCAQC3SL"
- },
- "monq": {
- "uri": "mongodb://localhost/monq"
- },
- "default": {
- "api": {
- "version" : "v1"
- },
- "lde": {
- "url": "http://lde.c3sl.ufpr.br/#"
- },
- "simcaq": {
- "url": "http://simcaq.c3sl.ufpr.br/#"
- }
- },
- "email": {
- "host": "SMTP.office365.com",
- "port": 587,
- "secureConnection": false,
- "auth": {
- "user": "dadoseducacionais@ufpr.br",
- "pass": "COLOCAR_A_SENHA_AQUI"
- },
- "tls": {
- "ciphers": "SSLv3"
- },
- "from": "\"Laboratório de Dados Educacionais\" <dadoseducacionais@ufpr.br>"
- },
- "security": {
- "tokenLife": 3600
- }
- }
-}
diff --git a/package.json b/package.json
index 7dfdb851bb284b14fde47cfb150526dd37da0626..ee49663181dfbe88f1567fc0f31877f519e1b57e 100644
--- a/package.json
+++ b/package.json
@@ -19,6 +19,7 @@
"babel-core": "^6.26.3",
"babel-preset-es2015": "^6.24.1",
"babel-register": "^6.26.0",
+ "bcrypt": "^5.1.0",
"bcrypt-nodejs": "0.0.3",
"body-parser": "^1.18.3",
"chai": "^3.5.0",
@@ -51,6 +52,7 @@
"mocha": "^3.5.3",
"monetdb-pool": "0.0.8",
"mongoose": "^4.13.17",
+ "multer": "^1.4.5-lts.1",
"natives": "^1.1.6",
"nconf": "^0.8.5",
"node-uuid": "^1.4.8",
@@ -60,7 +62,10 @@
"passport": "^0.3.2",
"passport-http-bearer": "^1.0.1",
"passport-oauth2-client-password": "^0.1.2",
+ "pg": "^8.10.0",
"request": "^2.88.0",
+ "sequelize": "^6.31.0",
+ "sequelize-cli": "^6.6.0",
"sqlstring": "^2.3.1",
"squel": "^5.12.2",
"winston": "^2.4.4"
diff --git a/script_req.sh b/script_req.sh
new file mode 100755
index 0000000000000000000000000000000000000000..125204b86fb256e0608e25f161dccddb4cbc1ddc
--- /dev/null
+++ b/script_req.sh
@@ -0,0 +1,10 @@
+curl -X 'POST' \
+ 'http://10.254.221.20:3000/api/v1//auth/token' \
+ -H 'accept: application/json' \
+ -H 'Content-Type: application/json' \
+ -d '{
+ "email": "eduardomsouza@ufpr.br",
+ "password": "teste123",
+ "client_secret": "LDE",
+ "grant_type": "password"
+}'
\ No newline at end of file
diff --git a/src/libs/api_mongo.txt b/src/libs/api_mongo.txt
new file mode 100644
index 0000000000000000000000000000000000000000..58f659659e0ed9d275a7375126a840823d782e20
--- /dev/null
+++ b/src/libs/api_mongo.txt
@@ -0,0 +1,6 @@
+*downloads.js
+*resetToken.js (V)
+*pqr.js
+*simulation.js
+*user.js (V)
+*verifyToken.js (V)
diff --git a/src/libs/app.js b/src/libs/app.js
index 9f1851050788f7494c1ef14ec530f255668bfcb0..bab5e52d57d27260c16c60719855c60f4be71255 100644
--- a/src/libs/app.js
+++ b/src/libs/app.js
@@ -19,10 +19,6 @@ const api_v2 = require('./routes_v2/api');
const passport = require('passport');
-const mongoose = require(`${libs}/db/mongoose`);
-
-const db = mongoose();
-
require(`${libs}/middlewares/passport`);
app.use(bodyParser.json({limit: '50mb'}));
diff --git a/src/libs/db/mongoose.js b/src/libs/db/mongoose.js
deleted file mode 100644
index f9d2ed8ef59767e262f77fa21e2a93d444139145..0000000000000000000000000000000000000000
--- a/src/libs/db/mongoose.js
+++ /dev/null
@@ -1,21 +0,0 @@
-const libs = `${process.cwd()}/libs`;
-
-const config = require(`${libs}/config`);
-
-const log = require(`${libs}/log`)(module);
-
-const mongoose = require('mongoose');
-
-mongoose.Promise = global.Promise;
-
-module.exports = () => {
- // Get mongodb URI (ip and port) in config file
- const mongoUri = process.env.MONGO_URI || config.mongodb.uri;
- log.info(`Connecting to MongoDB on URI ${mongoUri}`);
- // Connection singleton
- const db = mongoose.connect(mongoUri);
-
- mongoose.connection.once('open', () => { log.info("MongoDB connected"); });
-
- return db;
-};
diff --git a/src/libs/db/postgres.js b/src/libs/db/postgres.js
new file mode 100644
index 0000000000000000000000000000000000000000..c60d28c6932491dbee5ba88a5f86412d707cda23
--- /dev/null
+++ b/src/libs/db/postgres.js
@@ -0,0 +1,8 @@
+const Sequelize = require('sequelize');
+
+// if you are using postgres, your DB URL will look like this
+const DATABASE_URL = 'postgres://postgres:postgres@localhost:5432/postgres'
+
+const db = new Sequelize(DATABASE_URL)
+
+module.exports = db
\ No newline at end of file
diff --git a/src/libs/middlewares/authorize.js b/src/libs/middlewares/authorize.js
new file mode 100644
index 0000000000000000000000000000000000000000..592c193bedc33e136d23f95019cc0c0515ca7455
--- /dev/null
+++ b/src/libs/middlewares/authorize.js
@@ -0,0 +1,39 @@
+const express = require('express');
+
+const pubApp = express();
+
+const libs = `${process.cwd()}/libs`;
+
+const PermissionRole = require(`${libs}/models/permissionRole`)
+
+const mapPermission = {
+ 'criar publicacao': '1',
+ 'editar publicacao': '2',
+ 'apagar publicacao': '3',
+ 'criar atividade': '4',
+ 'editar atividade': '5',
+ 'apagar atividade': '6',
+}
+
+function authorized(permission) {
+ return async function (req, res, next) {
+ const permission_id = mapPermission[permission]
+ const userRole = req.user.role_id; // Assuming user role is stored in req.user.role
+ const hasPermission = await PermissionRole.findOne({where:{role_id:userRole, permission_id: permission_id}}).catch(function (err) {
+ if (err) {
+ log.error(err);
+ return next({ err });
+ }
+ });
+ if (hasPermission) {
+ // User has permission, proceed to next middleware or route handler
+ next();
+ } else {
+ // User does not have permission, return unauthorized response
+ res.status(403).json({ message: 'Unauthorized' });
+ }
+ };
+}
+
+module.exports = authorized
+
diff --git a/src/libs/middlewares/downloadDatabase.js b/src/libs/middlewares/downloadDatabase.js
index c4672ff0bf5d925d7d8d0466a260d3025fbc4e09..6f2dec6fb0271e43dce8580794b8c766c3ba9c9c 100644
--- a/src/libs/middlewares/downloadDatabase.js
+++ b/src/libs/middlewares/downloadDatabase.js
@@ -10,11 +10,11 @@ const config = require(`${libs}/config`);
const Download = require(`${libs}/models/download`);
-module.exports = function download(table, mappingTable) {
+module.exports = function download(table, mapping_table) {
return (req, res, next) => {
// First, query the mapping
- execute(`SELECT target_name, name FROM ${mappingTable}`, undefined, (err, result) => {
- if(err) {
+ execute(`SELECT target_name, name FROM ${mapping_table}`, undefined, (err, result) => {
+ if (err) {
log.error(err.stack);
next(new Error('Request could not be satisfied due to a database error.'));
} else {
@@ -23,7 +23,7 @@ module.exports = function download(table, mappingTable) {
result.forEach((field) => {
req.sql.field(`CASE ${table}.${field.name} WHEN true THEN 1 WHEN false THEN 0 ELSE ${table}.${field.name} END AS ${field.target_name}`);
// req.sql.field(table + '.' + field.name, field.target_name);
- if(header === '') header += field.target_name;
+ if (header === '') header += field.target_name;
else header = header + ';' + field.target_name;
});
@@ -36,53 +36,51 @@ module.exports = function download(table, mappingTable) {
header
};
- request.post(config.cdn.url + '/api/v1/file', {form}, (err, response, body) => {
- if(err) {
+ request.post(config.cdn.url + '/api/v1/file', { form }, async (err, response, body) => {
+ if (err) {
log.error(err);
- return res.json({error: err});
+ return res.json({ error: err });
}
- Download.findOne({query: req.sql.toString()}, (err, download) => {
- if(download) {
- download.updatedAt = Date.now();
- if(download.userId != req.user._id) {
- let dl = new Download({
- userId: req.user._id,
- table,
- name: req.query.name,
- mappingTable,
- query: req.sql.toString(),
- status: 'Enviando',
- expired: false
- });
- console.log(dl);
- dl.save((err) => {
- if(err) log.error(err);
- });
- }
- } else {
- download = new Download({
- userId: req.user._id,
+ let download = await Download.findOne({ where: { query: req.sql.toString() } }).catch(function (err) {
+ if (err) {
+ log.error(err);
+ }
+ })
+ if (download) {
+ download.updated_at = new Date();
+ if (download.user_id != req.user.id) {
+ let dl = await Download.create({
+ user_id: req.user.id,
table,
name: req.query.name,
- mappingTable,
- query: req.sql.toString(),
+ mapping_table,
query: req.sql.toString(),
status: 'Enviando',
expired: false
});
- console.log(download);
+ console.log(dl);
+ dl.save().catch(function (err) {
+ if (err) log.error(err);
+ });
}
-
- download.save((err) => {
- if(err) {
- log.error(err);
- }
- res.json({msg: 'Wait for download email', waitForIt: true});
+ } else {
+ download = await Download.create({
+ user_id: req.user.id,
+ table,
+ name: req.query.name,
+ mapping_table,
+ query: req.sql.toString(),
+ status: 'Enviando',
+ expired: false
});
- });
+ console.log(download);
+ }
+
+ await download.save()
+ res.json({ msg: 'Wait for download email', waitForIt: true });
});
- }
+ };
});
}
-};
\ No newline at end of file
+}
\ No newline at end of file
diff --git a/src/libs/middlewares/multer.config.js b/src/libs/middlewares/multer.config.js
new file mode 100644
index 0000000000000000000000000000000000000000..d4c7263fcb7c80451d81242186ce3c881a458b69
--- /dev/null
+++ b/src/libs/middlewares/multer.config.js
@@ -0,0 +1,6 @@
+const multer = require('multer');
+
+var storage = multer.memoryStorage()
+var upload = multer({storage: storage});
+
+module.exports = upload;
diff --git a/src/libs/middlewares/oauth2.js b/src/libs/middlewares/oauth2.js
index cc9a45ede4a3158bc055166202c6d20fb84a6dff..f5f4b658a4146276b5e06cd1849aa336f687043e 100644
--- a/src/libs/middlewares/oauth2.js
+++ b/src/libs/middlewares/oauth2.js
@@ -7,11 +7,15 @@ const libs = `${process.cwd()}/libs`;
const config = require(`${libs}/config`);
const log = require(`${libs}/log`)(module);
-const db = require(`${libs}/db/mongoose`);
const User = require(`${libs}/models/user`);
const AccessToken = require(`${libs}/models/accessToken`);
const RefreshToken = require(`${libs}/models/refreshToken`);
+const origin_to_secret = {
+ 'SimCAQ': 'FcmZp9bZpk8yxSJA',
+ 'LDE': 'LDE'
+};
+
// create OAuth 2.0 server
let aserver = oauth2orize.createServer()
@@ -23,86 +27,73 @@ let errFn = (cb, err) => {
}
// Destroys any old tokens and generates a new access and refresh token
-let generateTokens = (data, done) => {
+let generateTokens = (userId, clientId,userRole, done) => {
// curries in `done` callback so we don't need to pass it
- let errorHandler = errFn.bind(undefined, done);
- let refreshToken;
let refreshTokenValue;
- let token;
let tokenValue;
+ let admin = false;
- RefreshToken.remove(data, errorHandler);
- AccessToken.remove(data, errorHandler);
+ RefreshToken.destroy({where:{"user_id": userId, "client_id": clientId}});
+ AccessToken.destroy({where:{"user_id": userId, "client_id": clientId}});
tokenValue = crypto.randomBytes(32).toString('hex');
refreshTokenValue = crypto.randomBytes(32).toString('hex');
- data.token = tokenValue;
- token = new AccessToken(data);
-
- data.token = refreshTokenValue;
- refreshToken = new RefreshToken(data);
+ AccessToken.create({
+ user_id:userId,
+ client_id:clientId,
+ token:tokenValue
+ })
- refreshToken.save(errorHandler);
+ let refreshed_token = refreshTokenValue;
- token.save((err) => {
- if (err) {
- log.error(err);
- return done(err);
- }
- done(null, tokenValue, refreshTokenValue, {
- 'expires_in': config.security.tokenLife
- });
+ RefreshToken.create({
+ user_id:userId,
+ client_id:clientId,
+ token:refreshed_token
})
-};
+ if(userRole == 1){
+ admin = true;
+ }
+ done(null, tokenValue, refreshTokenValue, {'admin': admin},{
+ 'expires_in': config.security.tokenLife
+ });
-// Exchange username & password for access token.
-aserver.exchange(oauth2orize.exchange.password((client, username, password, scope, done) => {
- User.findOne({ email: username }, (err, user) => {
- if (err) {
- return done(err);
- }
+};
- if (!user || !user.checkPassword(password)) {
- return done(null, false);
- }
- var model = {
- userId: user._id,
- clientId: client._id
- };
- log.info(`Gerando token para usuário ${user.name}`);
- generateTokens(model, done);
- })
+// Exchange username & password for access token.
+aserver.exchange(oauth2orize.exchange.password(function(client, username, password, scope, done) {
+ User.findOne({
+ where: {email:username}
+ }).then(function(user) {
+ if(user == null|| !user.checkPassword(user, password)){
+ return done(null, false);
+ }
+
+ if(origin_to_secret[user.dataValues.origin] != client.client_secret){
+ console.log("Erro de client_secret");
+ return done(null, false);
+ }
+ log.info(`Gerando token para usuário ${user.name}`);
+ generateTokens(user.dataValues.id, client.id, user.dataValues.role_id, done);
+ }).catch(function(error) {
+ return done(error);
+ });
+ }));
-}));
// Exchange refreshToken for access token.
aserver.exchange(oauth2orize.exchange.refreshToken((client, refreshToken, scope, done) =>{
- RefreshToken.findOne({ token: refreshToken, clientId: client._id }, (err, token) => {
- if (err) {
- return done(err);
- }
-
+ RefreshToken.findOne({where: {token: refreshToken, client_id: client.id }}).then(function(token){
if (!token) {
return done(null, false);
}
-
- User.findById(token.userId, (err, user) => {
- if (err) {
- log.error(err);
- return done(err);
- }
+ User.findByPk(token.user_id).then(function(user){
if (!user) {
return done(null, false);
}
-
- var model = {
- userId: user._id,
- clientId: client._id
- };
-
- generateTokens(model, done);
+ generateTokens(user.id, client.id, done);
})
})
}))
@@ -114,8 +105,14 @@ aserver.exchange(oauth2orize.exchange.refreshToken((client, refreshToken, scope,
// exchange middleware will be invoked to handle the request. Clients must
// authenticate when making requests to this endpoint.
+
+// ,function(err, user) {
+// if (err) { console.log("Erro de autenticação"); }
+// if (!user) { console.log("Erro de usuario ausente");}
+// }
+
exports.token = [
passport.authenticate(['oauth2-client-password'], { session: false }),
aserver.token(),
aserver.errorHandler()
-];
+];
\ No newline at end of file
diff --git a/src/libs/middlewares/passport.js b/src/libs/middlewares/passport.js
index ab895a9604072e3b77a6384ac0c0f9066dcf6753..7e8d5120f6ea9d258e98f76621d252218c84a3c7 100644
--- a/src/libs/middlewares/passport.js
+++ b/src/libs/middlewares/passport.js
@@ -8,60 +8,51 @@ const config = require(`${libs}/config`);
const User = require(`${libs}/models/user`);
const Client = require(`${libs}/models/client`);
const AccessToken = require(`${libs}/models/accessToken`);
-const RefreshToken = require(`${libs}/models/refreshToken`);
-const email = require(`${libs}/middlewares/email`);
-passport.use(new ClientPasswordStrategy( (clientId, clientSecret, done) => {
- Client.findOne({ _id: clientId }, (err, client) => {
- if (err) {
- return done(err);
- }
+passport.use(new ClientPasswordStrategy(
+ function (client_id, client_secret, done) {
+ Client.findOne({
+ where: { id: client_id }
+ }).then(function (client) {
if (!client) {
+ console.log("Erro de cliente");
return done(null, false);
}
-
- if (client.clientSecret !== clientSecret) {
+ if (client.client_secret !== client_secret) {
+ console.log("Erro de Chave Secreta");
return done(null, false);
}
-
return done(null, client);
- })
+ }).catch(function (error) {
+ return done(error);
+ });
}
));
-passport.use(new BearerStrategy( (accessToken, done) => {
- AccessToken.findOne({ token: accessToken }, (err, token) => {
- if (err) {
- return done(err);
- }
-
- if (!token) {
- return done(null, false);
- }
-
- if( Math.round((Date.now()-token.created)/1000) > config.security.tokenLife) {
- AccessToken.remove({ token: accessToken }, (err) => {
- if (err) {
- return done(err);
- }
- });
+passport.use(new BearerStrategy(async (accessToken, done) => {
+ const token = await AccessToken.findOne({ where: { token: accessToken } })
+ if (!token) {
+ console.log("ERRO Token");
+ return done(null, false);
+ }
- return done(null, false, { msg: 'Token expired' });
+ if (Math.round((Date.now() - token.created) / 1000) > config.security.tokenLife) {
+ AccessToken.destroy({where:{ token: accessToken} }).catch(function (err) {
+ if (err) {
+ log.error(err);
+ return next({ err });
}
+ });
- User.findById(token.userId, function(err, usuario) {
- if (err) {
- return done(err);
- }
-
- if (!usuario) {
- return done(null, false, { msg: 'Unknown user' });
- }
-
- var info = { scope: '*' };
- done(null, usuario, info);
- })
- })
+ return done(null, false, { msg: 'Token expired' });
}
-));
+ User.findByPk(token.user_id).then(function (usuario) {
+ if (!usuario) {
+ console.log("ERRO NAO USUARIO");
+ return done(null, false, { msg: 'Unknown user' });
+ }
+ var info = { scope: '*' };
+ done(null, usuario, info);
+ })
+}));
diff --git a/src/libs/models/accessToken.js b/src/libs/models/accessToken.js
index daab5898a66b952f72359d9685e951b1acf980b7..54e4a4ba8e3b375e2bd0a4b73414e4d59096974d 100644
--- a/src/libs/models/accessToken.js
+++ b/src/libs/models/accessToken.js
@@ -1,29 +1,32 @@
-const mongoose = require('mongoose');
-const Schema = mongoose.Schema;
+const Sequelize = require("sequelize");
+const db = require('../db/postgres.js')
const libs = `${process.cwd()}/libs`;
const User = require(`${libs}/models/user`);
const Client = require(`${libs}/models/client`);
-let AccessToken = new Schema({
- userId: {
- type: Schema.Types.ObjectId,
- required: true,
- ref: 'User'
+var AccessToken = db.define("AccessToken",{
+ user_id: {
+ type: Sequelize.STRING,
+ allowNull: false
},
- clientId: {
- type: Schema.Types.ObjectId,
- required: true,
- ref: 'Client'
+ client_id:{
+ type: Sequelize.STRING,
+ allowNull: false
},
- token: {
- type: String,
+ token:{
+ type: Sequelize.STRING,
+ allowNull: false,
unique: true,
- required: true
+ primaryKey: true
},
- createdAt: {
- type: Date,
- default: Date.now
- }
-});
+ created_at:{
+ type: Sequelize.DATE,
+ defaultValue: Date.now
+ }},
+ {timestamps: false}
+);
-module.exports = mongoose.model('AccessToken', AccessToken);
+AccessToken.hasOne(User, { foreignKey: 'id' });
+AccessToken.hasOne(Client, { foreignKey: 'id' });
+
+module.exports = AccessToken;
diff --git a/src/libs/models/activity.js b/src/libs/models/activity.js
new file mode 100644
index 0000000000000000000000000000000000000000..92fc6f087fba744219badcd69ad7785b2d4b3b61
--- /dev/null
+++ b/src/libs/models/activity.js
@@ -0,0 +1,80 @@
+const Sequelize = require("sequelize");
+const db = require('../db/postgres.js');
+const libs = `${process.cwd()}/libs`;
+
+var Activity = db.define("Activity",{
+ id:{
+ type: Sequelize.STRING,
+ allowNull:false,
+ unique: true,
+ primaryKey: true
+ },
+ type:{
+ type: Sequelize.STRING,
+ allowNull:false
+ },
+ title:{
+ type: Sequelize.STRING,
+ allowNull:false,
+ },
+ subtitle:{
+ type: Sequelize.STRING
+ },
+ date:{
+ type: Sequelize.STRING,
+ allowNull:false
+ },
+ authors:{
+ type: Sequelize.STRING,
+ },
+ text:{
+ type: Sequelize.STRING,
+ allowNull: false
+ },
+ name_headline:{
+ type: Sequelize.STRING,
+ allowNull:false
+ },
+ resume_headline:{
+ type:Sequelize.STRING,
+ allowNull:false
+ },
+ date_headline:{
+ type: Sequelize.STRING,
+ allowNull:false
+ },
+ local_headline:{
+ type:Sequelize.STRING,
+ allowNull:false
+ },
+ additional_headline:{
+ type:Sequelize.STRING
+ },
+ is_draft:{
+ type:Sequelize.BOOLEAN,
+ allowNull:false,
+ defaultValue: true
+ },
+ is_headline:{
+ type:Sequelize.BOOLEAN,
+ allowNull: false,
+ defaultValue: false
+ }
+
+},
+{timestamps: false});
+
+Activity.generateObjectId = function(){
+ var timestamp = (new Date().getTime() / 1000 | 0).toString(16);
+ return timestamp + 'xxxxxxxxxxxxxxxx'.replace(/[x]/g, function() {
+ return (Math.random() * 16 | 0).toString(16);
+ }).toLowerCase();
+}
+
+const setObjectId = act => {
+ act.id = Activity.generateObjectId()
+};
+
+Activity.beforeCreate(setObjectId);
+
+module.exports = Activity;
\ No newline at end of file
diff --git a/src/libs/models/client.js b/src/libs/models/client.js
index 8ac80d8d158705f63efbbecc72de37d1fef6a3ac..b4eabcbca46ed440b8655cc77b6b5b147e35c54c 100644
--- a/src/libs/models/client.js
+++ b/src/libs/models/client.js
@@ -1,17 +1,24 @@
-const mongoose = require('mongoose');
-const Schema = mongoose.Schema;
+const Sequelize = require("sequelize");
+const db = require('../db/postgres.js');
-let Client = new Schema({
- name: {
- type: String,
+var Client = db.define("client",{
+ id:{
+ type: Sequelize.STRING,
+ allowNull:false,
unique: true,
- required: true
+ primaryKey: true
},
- clientSecret: {
- type: String,
- required: true,
+ name:{
+ type: Sequelize.STRING,
+ allowNull:false,
unique: true
- }
-});
+ },
+ client_secret:{
+ type: Sequelize.STRING,
+ allowNull:false,
+ unique:true
+ },
+},
+{timestamps: false});
-module.exports = mongoose.model('Client', Client);
+module.exports = Client;
\ No newline at end of file
diff --git a/src/libs/models/download.js b/src/libs/models/download.js
index 989896d9a2b6547c11c9b1bc71019db3bb7617a5..3d59249aad2592bf6ae5f7bcc668bdd71d0de1f6 100644
--- a/src/libs/models/download.js
+++ b/src/libs/models/download.js
@@ -1,53 +1,60 @@
-const mongoose = require('mongoose');
-const Schema = mongoose.Schema;
+const Sequelize = require("sequelize");
+const crypto = require('crypto');
+const db = require('../db/postgres.js');
const libs = `${process.cwd()}/libs`;
-const log = require(`${libs}/log`)(module);
const User = require(`${libs}/models/user`);
-let Download = new Schema({
- userId: {
- type: Schema.Types.ObjectId,
- required: true,
- ref: 'User'
- },
- table: {
- type: String,
- required: true
- },
- name: {
- type: String,
- required: true
- },
- mappingTable: {
- type: String,
- required: true
+var Download = db.define("Download",{
+ id:{
+ type: Sequelize.INTEGER,
+ allowNull: false,
+ autoIncrement: true,
+ unique: true,
+ primaryKey: true
+ },
+ user_id: {
+ type: Sequelize.STRING,
+ allowNull: false
+ },
+ table:{
+ type: Sequelize.STRING,
+ allowNull: false,
+ },
+ name:{
+ type: Sequelize.STRING,
+ allowNull: false,
+ },
+ mapping_table:{
+ type: Sequelize.STRING,
+ allowNull:false
},
query: {
- type: String,
- required: true
+ type: Sequelize.STRING,
+ allowNull:false
},
- createdAt: {
- type: Date,
- required: true,
- default: Date.now
- },
- updatedAt: {
- type: Date,
- required: true,
- default: Date.now
+ created_at:{
+ type: Sequelize.DATE,
+ defaultValue: Date.now
+ },
+ updated_at: {
+ type: Sequelize.DATE,
+ defaultValue: Date.now
},
status: {
- type: String
+ type: Sequelize.STRING
},
size: {
- type: Number
+ type: Sequelize.NUMBER
},
expired: {
- type: Boolean
+ type: Sequelize.BOOLEAN
},
link: {
- type: String
- }
-});
+ type: Sequelize.STRING,
+ }},
+ {timestamps: false}
+);
+
+Download.hasOne(User,{ foreignKey: 'id' });
-module.exports = mongoose.model('Download', Download);
+module.exports = Download
diff --git a/src/libs/models/file.js b/src/libs/models/file.js
new file mode 100644
index 0000000000000000000000000000000000000000..aa6ba077e60ae1b400e401d470f46aa7f2bc53e3
--- /dev/null
+++ b/src/libs/models/file.js
@@ -0,0 +1,39 @@
+
+const Sequelize = require("sequelize");
+const db = require('../db/postgres.js');
+const libs = `${process.cwd()}/libs`;
+
+var File = db.define("File",{
+ id: {
+ type: Sequelize.STRING,
+ allowNull:false,
+ unique: true,
+ primaryKey: true
+ },
+ type:{
+ type: Sequelize.STRING
+ },
+ name: {
+ type: Sequelize.STRING
+ },
+ data: {
+ type: Sequelize.BLOB('long')
+ }
+},
+{timestamps: false});
+
+File.generateObjectId = function(){
+ var timestamp = (new Date().getTime() / 1000 | 0).toString(16);
+ return timestamp + 'xxxxxxxxxxxxxxxx'.replace(/[x]/g, function() {
+ return (Math.random() * 16 | 0).toString(16);
+ }).toLowerCase();
+}
+
+const setObjectId = file => {
+ file.id = File.generateObjectId()
+};
+
+File.beforeCreate(setObjectId);
+
+module.exports=File;
+
diff --git a/src/libs/models/permission.js b/src/libs/models/permission.js
new file mode 100644
index 0000000000000000000000000000000000000000..ba35c4ce57dcb2f4655cb038d76814f4d54933f8
--- /dev/null
+++ b/src/libs/models/permission.js
@@ -0,0 +1,39 @@
+const Sequelize = require("sequelize");
+const db = require('../db/postgres.js');
+const libs = `${process.cwd()}/libs`;
+const Role = require(`${libs}/models/role`);
+
+var Permission = db.define("PermissionRole",{
+ id:{
+ type: Sequelize.STRING,
+ allowNull:false,
+ unique: true,
+ primaryKey: true
+ },
+ permission_name:{
+ type: Sequelize.STRING,
+ allowNull:false,
+ },
+ permission_description:{
+ type: Sequelize.STRING,
+ allowNull:false
+ }
+},
+{timestamps: false});
+
+Permission.generateObjectId = function(){
+ var timestamp = (new Date().getTime() / 1000 | 0).toString(16);
+ return timestamp + 'xxxxxxxxxxxxxxxx'.replace(/[x]/g, function() {
+ return (Math.random() * 16 | 0).toString(16);
+ }).toLowerCase();
+}
+
+const setObjectId = permission => {
+ permission.id = Permission.generateObjectId()
+};
+
+Permission.beforeCreate(setObjectId);
+
+
+module.exports = Permission;
+
diff --git a/src/libs/models/permissionRole.js b/src/libs/models/permissionRole.js
new file mode 100644
index 0000000000000000000000000000000000000000..e415acc697f2db9af4be231efdb8e855cbd9ec53
--- /dev/null
+++ b/src/libs/models/permissionRole.js
@@ -0,0 +1,29 @@
+const Sequelize = require("sequelize");
+const db = require('../db/postgres.js');
+const libs = `${process.cwd()}/libs`;
+const Role = require(`${libs}/models/role`);
+const Permission = require(`${libs}/models/permission`);
+
+var PermissionRole = db.define("PermissionRole",{
+ id:{
+ type: Sequelize.INTEGER,
+ allowNull:false,
+ unique: true,
+ primaryKey: true
+ },
+ role_id:{
+ type: Sequelize.INTEGER,
+ allowNull:false,
+ },
+ permission_id:{
+ type: Sequelize.INTEGER,
+ allowNull:false
+ }
+},
+{timestamps: false});
+
+PermissionRole.hasMany(Role, {foreignKey: 'id'});
+PermissionRole.hasMany(Permission, {foreignKey: 'id'});
+
+module.exports = PermissionRole;
+
diff --git a/src/libs/models/pqr.js b/src/libs/models/pqr.js
index f92703188323cef17807f70f1f2198b54a13aa1b..2a9fb9dd657d13494efd9d57fa3f1a0c59a3c59d 100644
--- a/src/libs/models/pqr.js
+++ b/src/libs/models/pqr.js
@@ -1,16 +1,19 @@
-const mongoose = require('mongoose')
+const Sequelize = require("sequelize");
+const db = require('../db/postgres.js');
-const libs = `${process.cwd()}/libs`;
-const log = require(`${libs}/log`)(module);
-const User = require(`${libs}/models/user`);
-
-const Schema = mongoose.Schema;
-
-let PQRSchema = new Schema({
+var PQR = db.define("pqr",{
+ id:{
+ type: Sequelize.INTEGER,
+ allowNull: false,
+ unique: true,
+ primaryKey: true
+ },
content: {
- type: String,
- required: true,
+ type: Sequelize.STRING,
+ allowNull: false
}
-});
+},
+{timestamps: false});
+
-module.exports = mongoose.model('PQR', PQRSchema);
+module.exports = PQR;
diff --git a/src/libs/models/publication.js b/src/libs/models/publication.js
new file mode 100644
index 0000000000000000000000000000000000000000..bd537bc0825b44a0e79d384e5bf631537784ef69
--- /dev/null
+++ b/src/libs/models/publication.js
@@ -0,0 +1,83 @@
+const Sequelize = require("sequelize");
+const db = require('../db/postgres.js');
+const libs = `${process.cwd()}/libs`;
+
+var Publication = db.define("Publication",{
+ id:{
+ type: Sequelize.STRING,
+ allowNull:false,
+ unique: true,
+ primaryKey: true
+ },
+ filter:{
+ type: Sequelize.ENUM("Artigo", "Tese", "Dissertação", "Relatório", "Periódico"),
+ allowNull:false,
+ validate: {
+ notNull: { msg: "O campo categoria é obrigatória e aceita apenas os valores 'Artigo', 'Tese', 'Dissertação', 'Relatório', 'Periódico."},
+ isIn:{
+ args: [["Artigo", "Tese", "Dissertação", "Relatório", "Periódico"]],
+ msg: "O campo categoria é obrigatória e aceita apenas os valores 'Artigo', 'Tese', 'Dissertação', 'Relatório', 'Periódico'."
+ }
+ }
+ },
+ title:{
+ type: Sequelize.STRING,
+ allowNull:false,
+ },
+ authors:{
+ type: Sequelize.STRING,
+ allowNull:false
+ },
+ organization:{
+ type: Sequelize.STRING,
+ allowNull:false
+ },
+ year:{
+ type:Sequelize.STRING,
+ allowNull:false
+ },
+ text:{
+ type: Sequelize.ENUM("Baixar","Acessar"),
+ allowNull:false,
+ validate: {
+ notNull: { msg: "O campo origem é obrigatória e aceita apenas os valores 'Baixar', 'Acessar'."},
+ isIn:{
+ args: [["Baixar", "Acessar"]],
+ msg: "O campo origem é obrigatória e aceita apenas os valores 'Baixar', 'Acessar'."}
+ }
+ },
+ link:{
+ type: Sequelize.STRING
+ },
+ upload:{
+ type: Sequelize.STRING
+ },
+ is_draft:{
+ type:Sequelize.BOOLEAN,
+ allowNull:false,
+ defaultValue: true
+ },
+ is_headline:{
+ type:Sequelize.BOOLEAN,
+ allowNull: false,
+ defaultValue: false
+ }
+},{timestamp:true,
+ createdAt: 'created_at',
+ updatedAt: 'updated_at'}
+);
+
+Publication.generateObjectId = function(){
+ var timestamp = (new Date().getTime() / 1000 | 0).toString(16);
+ return timestamp + 'xxxxxxxxxxxxxxxx'.replace(/[x]/g, function() {
+ return (Math.random() * 16 | 0).toString(16);
+ }).toLowerCase();
+}
+
+const setObjectId = pb => {
+ pb.id = Publication.generateObjectId()
+};
+
+Publication.beforeCreate(setObjectId);
+
+module.exports = Publication;
\ No newline at end of file
diff --git a/src/libs/models/refreshToken.js b/src/libs/models/refreshToken.js
index c5f8fd63cdd30733bb60f341e6617420d945b037..aebdd9b2ec4d8e32acb6e8a03c1264b88305b9a7 100644
--- a/src/libs/models/refreshToken.js
+++ b/src/libs/models/refreshToken.js
@@ -1,30 +1,33 @@
-const mongoose = require('mongoose');
-const Schema = mongoose.Schema;
+const Sequelize = require("sequelize");
const libs = `${process.cwd()}/libs`;
+const db = require('../db/postgres.js');
const User = require(`${libs}/models/user`);
const Client = require(`${libs}/models/client`);
-let RefreshToken = new Schema({
- userId: {
- type: Schema.Types.ObjectId,
- required: true,
- ref: 'User'
+var RefreshToken = db.define("RefreshToken",{
+ user_id: {
+ type: Sequelize.STRING,
+ allowNull: false
},
- clientId: {
- type: Schema.Types.ObjectId,
- required: true,
- ref: 'Client'
+ client_id:{
+ type: Sequelize.STRING,
+ allowNull: false
},
- token: {
- type: String,
+ token:{
+ type: Sequelize.STRING,
+ allowNull: false,
unique: true,
- required: true
+ primaryKey: true
},
- createdAt: {
- type: Date,
- default: Date.now
- }
-});
+ created_at:{
+ type: Sequelize.DATE,
+ defaultValue: Date.now
+ }},
+ {timestamps: false}
+);
-module.exports = mongoose.model('RefreshToken', RefreshToken);
+RefreshToken.hasOne(User, { foreignKey: 'id' });
+RefreshToken.hasOne(Client, { foreignKey: 'id' });
+
+module.exports = RefreshToken;
diff --git a/src/libs/models/resetToken.js b/src/libs/models/resetToken.js
index 322d528188a78525b4e003a65c6355fc0c2039c6..dca5488a85842a84ccc06c1afc02dc4c34f7ae69 100644
--- a/src/libs/models/resetToken.js
+++ b/src/libs/models/resetToken.js
@@ -1,46 +1,38 @@
-const mongoose = require('mongoose');
-const Schema = mongoose.Schema;
+const Sequelize = require("sequelize");
const libs = `${process.cwd()}/libs`;
-const log = require(`${libs}/log`)(module);
+const db = require('../db/postgres.js');
const User = require(`${libs}/models/user`);
const uuid = require('node-uuid');
-let ResetToken = new Schema({
- userId: {
- type: Schema.Types.ObjectId,
- required: true,
- ref: 'User'
+var ResetToken = db.define("ResetToken",{
+ user_id: {
+ type: Sequelize.STRING,
+ allowNull: false
},
- token: {
- type: String,
- required: true
+ token:{
+ type: Sequelize.STRING,
+ allowNull: false,
+ unique: true,
+ primaryKey: true
},
- reset: {
- type: Boolean,
- required: true,
- default: false
+ reset:{
+ type: Sequelize.BOOLEAN,
+ allowNull: false,
+ defaultValue: false
},
- createdAt: {
- type: Date,
- required: true,
- default: Date.now
- }
-});
+ created_at:{
+ type: Sequelize.DATE,
+ defaultValue: Date.now
+ }},
+ {timestamps: false}
+);
-ResetToken.methods.createResetToken = function (done) {
- let resetToken = this;
- let token = uuid.v4();
- resetToken.set('token', token);
- resetToken.reset = false;
- resetToken.save(function(err) {
- if (err)
- return done(err);
- return done(null, token);
- })
-}
-ResetToken.methods.hasExpired = function () {
+ResetToken.prototype.hasExpired = function () {
var now = new Date();
return (now - this.createdAt) > 86400; //Expire if token is 1 day old
};
-module.exports = mongoose.model('ResetToken', ResetToken);
+ResetToken.hasOne(User,{ foreignKey: 'id' });
+
+
+module.exports = ResetToken
diff --git a/src/libs/models/role.js b/src/libs/models/role.js
new file mode 100644
index 0000000000000000000000000000000000000000..d594b061a5dd082a26c2bf41f4d80e6b78214230
--- /dev/null
+++ b/src/libs/models/role.js
@@ -0,0 +1,23 @@
+const Sequelize = require("sequelize");
+const db = require('../db/postgres.js');
+
+var Role = db.define("Role",{
+ id:{
+ type: Sequelize.INTEGER,
+ allowNull:false,
+ unique: true,
+ primaryKey: true
+ },
+ role_name:{
+ type: Sequelize.STRING,
+ allowNull:false,
+ },
+ // token:{
+ // type: Sequelize.STRING,
+ // allowNull:false,
+ // }
+},
+{timestamps: false});
+
+module.exports = Role;
+
diff --git a/src/libs/models/simulation.js b/src/libs/models/simulation.js
index f1d3b0bd2448fe7640affd57e3d33d330ad7912c..21d2de89547e34a8118ab2579b410a44ff969d0e 100644
--- a/src/libs/models/simulation.js
+++ b/src/libs/models/simulation.js
@@ -1,34 +1,39 @@
-const mongoose = require('mongoose')
+const Sequelize = require("sequelize");
+const db = require('../db/postgres.js')
+const User = require(`./user.js`);
-const libs = `${process.cwd()}/libs`;
-const log = require(`${libs}/log`)(module);
-const User = require(`${libs}/models/user`);
-
-const Schema = mongoose.Schema;
-
-let SimulationSchema = new Schema({
- userId: {
- type: Schema.Types.ObjectId,
- required: true,
- ref: 'User'
+var Simulation = db.define("Simulation",{
+ id:{
+ type: Sequelize.INTEGER,
+ allowNull: false,
+ autoIncrement: true,
+ unique: true,
+ primaryKey: true
},
- content: {
- type: String,
- required: true,
+ user_id: {
+ type: Sequelize.STRING,
+ allowNull: false
+ },
+ content:{
+ type: Sequelize.STRING,
+ allowNull: false
},
name: {
- type: String
+ type: Sequelize.STRING,
},
- createdAt: {
- type: Date,
- required: true,
- default: Date.now
+ created_at:{
+ type: Sequelize.DATE,
+ allowNull: false,
+ defaultValue: Date.now
},
- updatedAt: {
+ updated_at: {
type: Date,
required: true,
default: Date.now
}
-});
+},
+{timestamps: false});
+
+Simulation.hasOne(User,{ foreignKey: 'id' });
-module.exports = mongoose.model('Simulation', SimulationSchema);
+module.exports = Simulation;
diff --git a/src/libs/models/user.js b/src/libs/models/user.js
index be62f4a5cf87074e2f84695f3d1e190c20b8c118..405909eb1e39ea94a0b283aed9c1fedf8295ec25 100644
--- a/src/libs/models/user.js
+++ b/src/libs/models/user.js
@@ -1,119 +1,202 @@
-const mongoose = require('mongoose');
-const crypto = require('crypto')
+const Sequelize = require("sequelize");
+const crypto = require('crypto');
+const db = require('../db/postgres.js');
const libs = `${process.cwd()}/libs`;
-const log = require(`${libs}/log`)(module);
-const Schema = mongoose.Schema;
+const Role = require(`${libs}/models/role`);
-// set up a mongoose model
-var UserSchema = new Schema({
- email: {
- type: String,
+// set up a sequelize model
+var User = db.define("User",{
+ id:{
+ type: Sequelize.STRING,
+ allowNull:false,
unique: true,
- required: [true, 'O campo Email é obrigatório.']
+ primaryKey: true
},
- hashedPassword: {
- type: String,
- required: [true, 'O campo Senha é obrigatório.']
+ email: {
+ type: Sequelize.STRING,
+ allowNull: false,
+ unique: true,
+ validate: {
+ notNull: { msg: "O campo Email é obrigatório." },
+ notEmpty: { msg: "O campo Email é obrigatório." }
+ }
},
- salt: {
- type: String,
- required: true
+ password:{
+ type: Sequelize.VIRTUAL
},
- name: {
- type: String,
- required: [true, 'O campo Nome é obrigatório.']
+ hashed_password:{
+ type: Sequelize.STRING,
+ allowNull: false,
},
- nickname: {
- type: String,
- required: [true, 'O campo Apelido é obrigatório.']
+ salt: {
+ type: Sequelize.STRING,
+ allowNull: false,
+ },
+ name:{
+ type: Sequelize.STRING,
+ allowNull: false,
+ validate: {
+ notNull: { msg: "O campo Nome é obrigatório." },
+ notEmpty: { msg: "O campo Nome é obrigatório." }
+ }
+ },
+ nickname:{
+ type: Sequelize.STRING,
+ allowNull: false,
+ validate: {
+ notNull: { msg: "O campo Apelido é obrigatório." },
+ notEmpty: { msg: "O campo Apelido é obrigatório." }
+ }
},
cpf:{
- type: String,
+ type: Sequelize.STRING,
+ allowNull: false,
unique: true,
- required: [true, 'O campo CPF é obrigatório.']
+ validate: {
+ notNull: { msg: "O campo CPF é obrigatório." },
+ notEmpty: { msg: "O campo CPF é obrigatório." }
+ }
},
cep:{
- type: String,
- required: [true, 'O campo CEP é obrigatório.']
- },
- schooling: {
- type: String,
- required: [true, 'O campo Formação é obrigatório.']
- },
- course: {
- type: String,
- },
- complement: {
- type: String,
- },
- address: {
- type: String,
- },
- phone: {
- type: String,
- },
- segment: {
- type: String,
- required: [true, 'O campo Segmento é obrigatório.']
- },
- role: {
- type: String,
- required: [true, 'O campo Função é obrigatório.']
- },
- institutionName: {
- type: String,
- required: [true, 'O campo Instituição em que trabalha ou estuda é obrigatório.']
- },
- state: {
- type: String,
- required: [true, 'O campo Estado é obrigatório.']
- },
- city: {
- type: String,
- required: [true, 'O campo Cidade é obrigatório.']
- },
- receiveEmails: {
- type: Boolean
- },
- createdAt: {
- type: Date,
- default: Date.now
- },
- origin: {
- type: String,
- enum: ['LDE', 'SimCAQ', 'MAPFOR'],
- required: [true, 'O campo origem é obrigatória e aceita apenas os valores "LDE", "SimCAQ" e "MAPFOR"']
- },
- verified: {
- type: Boolean,
- default: false
- },
- citesegment: {
- type: String
- },
- citerole: {
- type: String
- },
- admin: {
- type: Boolean,
- default: false
+ type: Sequelize.STRING,
+ allowNull: false,
+ validate: {
+ notNull: { msg: "O campo CEP é obrigatório." },
+ notEmpty: { msg: "O campo CEP é obrigatório." }
+ }
+ },
+ schooling:{
+ type: Sequelize.STRING,
+ allowNull: false,
+ validate: {
+ notNull: { msg: "O campo Formação é obrigatório." },
+ notEmpty: { msg: "O campo Formação é obrigatório." }
+ }
+ },
+ course:{
+ type: Sequelize.STRING,
+ },
+ complement:{
+ type: Sequelize.STRING
+ },
+ address:{
+ type: Sequelize.STRING,
+ },
+ phone:{
+ type: Sequelize.STRING,
+ },
+ segment:{
+ type: Sequelize.STRING,
+ allowNull: false,
+ validate: {
+ notNull: { msg: "O campo Segmento é obrigatório." },
+ notEmpty: { msg: "O campo Segmento é obrigatório." }
+ }
+ },
+ role:{
+ type: Sequelize.STRING,
+ allowNull: false,
+ validate: {
+ notNull: { msg: "O campo Função é obrigatório." },
+ notEmpty: { msg: "O campo Função é obrigatório." }
+ }
+ },
+ institution_name:{
+ type: Sequelize.STRING,
+ allowNull: false,
+ validate: {
+ notNull: { msg: "O campo Instituição em que trabalha ou estuda é obrigatório." },
+ notEmpty: { msg: "O campo Instituição em que trabalha ou estuda é obrigatório." }
+ }
+ },
+ state:{
+ type: Sequelize.STRING,
+ allowNull: false,
+ validate: {
+ notNull: { msg: "O campo Estado é obrigatório." },
+ notEmpty: { msg: "O campo Estado é obrigatório." }
+ }
+ },
+ city:{
+ type: Sequelize.STRING,
+ allowNull: false,
+ validate: {
+ notNull: { msg: "O campo Cidade é obrigatório." },
+ notEmpty: { msg: "O campo Cidade é obrigatório." }
+ }
+ },
+ receive_email:{
+ type: Sequelize.BOOLEAN,
+ },
+ created_at:{
+ type: Sequelize.DATE,
+ defaultValue: Date.now
+ },
+ origin:{
+ type: Sequelize.ENUM("LDE", "SimCAQ", "MAPFOR"),
+ allowNull:false,
+ validate: {
+ notNull: { msg: "O campo origem é obrigatória e aceita apenas os valores 'LDE', 'SimCAQ' e 'MAPFOR'."},
+ notEmpty: { msg: "O campo origem é obrigatória e aceita apenas os valores 'LDE', 'SimCAQ' e 'MAPFOR'."}
+ }
+ },
+ verified:{
+ type: Sequelize.BOOLEAN,
+ defaultValue:false
+ },
+ citesegment:{
+ type: Sequelize.STRING,
+ },
+ citerole:{
+ type: Sequelize.STRING
+ },
+ admin:{
+ type: Sequelize.BOOLEAN,
+ defaultValue:false
+ },
+ role_id:{
+ type: Sequelize.NUMBER,
+ allowNull:false,
+ defaultValue: 0
}
-});
+},
+ {timestamps: false}
+);
+
+User.hasOne(Role, {foreignKey: 'id'});
+
+User.generateSalt = function() {
+ return crypto.randomBytes(128).toString('hex');
+}
+
+User.encryptPassword = function(password, salt) {
+ return crypto.pbkdf2Sync(password+'', salt, 10000, 512, 'sha512').toString('hex');
+}
+
+User.generateObjectId = function(){
+ var timestamp = (new Date().getTime() / 1000 | 0).toString(16);
+ return timestamp + 'xxxxxxxxxxxxxxxx'.replace(/[x]/g, function() {
+ return (Math.random() * 16 | 0).toString(16);
+ }).toLowerCase();
+}
+
+const setSaltAndPassword = user => {
+ if (user.changed('password')) {
+ user.salt = User.generateSalt()
+ user.hashed_password = User.encryptPassword(user.password, user.salt).toString('hex');
+ }
+}
-UserSchema.methods.encryptPassword = function(password) {
- return crypto.pbkdf2Sync(password+'', this.salt, 10000, 512, 'sha512');
+const setObjectId = user => {
+ user.id = User.generateObjectId()
};
-UserSchema.virtual('password').set(function(password) {
- this._plainPassword = password+'';
- this.salt = crypto.randomBytes(128).toString('hex');
- this.hashedPassword = this.encryptPassword(password).toString('hex');
-}).get(function() {
- return this._plainPassword;
-});
+User.beforeCreate(setSaltAndPassword)
+User.beforeCreate(setObjectId)
+User.beforeUpdate(setSaltAndPassword)
-UserSchema.methods.checkPassword = function(password) {
- return this.encryptPassword(password).toString('hex') === this.hashedPassword;
+User.prototype.checkPassword = function(user, enteredPassword) {
+ return User.encryptPassword(enteredPassword, user.salt) === user.hashed_password
}
-module.exports = mongoose.model('User', UserSchema);
+module.exports = User;
diff --git a/src/libs/models/userActivity.js b/src/libs/models/userActivity.js
new file mode 100644
index 0000000000000000000000000000000000000000..2c1f8b56003b6e05243e4746ef6185cedad7df1b
--- /dev/null
+++ b/src/libs/models/userActivity.js
@@ -0,0 +1,29 @@
+const Sequelize = require("sequelize");
+const db = require('../db/postgres.js');
+const libs = `${process.cwd()}/libs`;
+const User = require(`${libs}/models/user`);
+const Activity = require(`${libs}/models/activity`);
+
+var userActivity = db.define("userActivity",{
+ id:{
+ type: Sequelize.INTEGER,
+ allowNull:false,
+ unique: true,
+ primaryKey: true
+ },
+ user_id:{
+ type: Sequelize.STRING,
+ allowNull:false,
+ },
+ activity_id:{
+ type: Sequelize.STRING,
+ allowNull:false
+ }
+},
+{timestamps: false});
+
+userActivity.hasMany(User, {foreignKey: 'id'});
+userActivity.hasMany(Activity, {foreignKey: 'id'});
+
+module.exports = userActivity;
+
diff --git a/src/libs/models/userPublication.js b/src/libs/models/userPublication.js
new file mode 100644
index 0000000000000000000000000000000000000000..654dd3c33827fb926fa4b5d1e7e48241a03689df
--- /dev/null
+++ b/src/libs/models/userPublication.js
@@ -0,0 +1,29 @@
+const Sequelize = require("sequelize");
+const db = require('../db/postgres.js');
+const libs = `${process.cwd()}/libs`;
+const User = require(`${libs}/models/user`);
+const Publication = require(`${libs}/models/publication`);
+
+var userPublication = db.define("userPublication",{
+ id:{
+ type: Sequelize.INTEGER,
+ allowNull:false,
+ unique: true,
+ primaryKey: true
+ },
+ user_id:{
+ type: Sequelize.STRING,
+ allowNull:false,
+ },
+ publication_id:{
+ type: Sequelize.STRING,
+ allowNull:false
+ }
+},
+{timestamps: false});
+
+userPublication.hasMany(User, {foreignKey: 'id'});
+userPublication.hasMany(Publication, {foreignKey: 'id'});
+
+module.exports = userPublication;
+
diff --git a/src/libs/models/verificationToken.js b/src/libs/models/verificationToken.js
index ef7e109e16364874ea7d3f4b07b6e19ce74c3eae..9038cac1961db16f3f88522c89efe089243a3819 100644
--- a/src/libs/models/verificationToken.js
+++ b/src/libs/models/verificationToken.js
@@ -1,41 +1,31 @@
-const mongoose = require('mongoose');
-const Schema = mongoose.Schema;
-const libs = `${process.cwd()}/libs`;
-const log = require(`${libs}/log`)(module);
-const User = require(`${libs}/models/user`);
+const Sequelize = require("sequelize");
+const db = require('../db/postgres.js')
+const User = require(`./user.js`);
const uuid = require('node-uuid');
-let VerificationToken = new Schema({
- userId: {
- type: Schema.Types.ObjectId,
- required: true,
- ref: 'User'
+var VerificationToken = db.define("VerificationToken",{
+ user_id: {
+ type: Sequelize.STRING,
+ allowNull: false
},
- token: {
- type: String,
- required: true
+ token:{
+ type: Sequelize.STRING,
+ allowNull: false,
+ primaryKey: true
},
- verified: {
- type: Boolean,
- required: true,
- default: false
+ verified:{
+ type: Sequelize.BOOLEAN,
+ allowNull: false,
+ defaultValue: false
},
- createdAt: {
- type: Date,
- required: true,
- default: Date.now
+ created_at:{
+ type: Sequelize.DATE,
+ allowNull: false,
+ defaultValue: Date.now
}
-});
+},
+{timestamps: false});
-VerificationToken.methods.createVerificationToken = function(done) {
- let verificationToken = this;
- let token = uuid.v4();
- verificationToken.set('token', token);
- verificationToken.verified = false;
- verificationToken.save(function(err) {
- if (err) return done(err);
- return done(null, token);
- })
-}
+VerificationToken.hasOne(User,{ foreignKey: 'id' });
-module.exports = mongoose.model('VerificationToken', VerificationToken);
+module.exports = VerificationToken;
diff --git a/src/libs/routes_v1/activity.js b/src/libs/routes_v1/activity.js
new file mode 100644
index 0000000000000000000000000000000000000000..51ef67ea1ae60d35636dc42f3770f62b0fd9b29b
--- /dev/null
+++ b/src/libs/routes_v1/activity.js
@@ -0,0 +1,207 @@
+const express = require('express');
+
+const activityApp = express();
+
+const libs = `${process.cwd()}/libs`;
+
+const config = require(`${libs}/config`);
+
+const log = require(`${libs}/log`)(module);
+
+const Activity = require(`${libs}/models/activity`);
+
+const response = require(`${libs}/middlewares/response`);
+
+const email = require(`${libs}/middlewares/email`);
+
+const passport = require('passport');
+
+const fileWorker = require('./file.controller.js');
+
+let upload = require('../middlewares/multer.config.js');
+
+const authorized = require(`${libs}/middlewares/authorize.js`);
+
+function emailSyntax(email) {
+ const regex = /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
+ return regex.test(email);
+}
+
+activityApp.get('/', async (req, res, next) => {
+ const page = parseInt(req.query.page) || 1;
+ const pageSize = parseInt(req.query.pageSize) || 5;
+ try {
+ const totalCount = await Activity.count();
+ const offset = (page - 1) * pageSize;
+
+ const acts = await Activity.findAll({
+ offset,
+ limit: pageSize,
+ order:[
+ ['date', 'DESC']]
+ });
+
+ res.json({
+ page,
+ pageSize,
+ totalCount,
+ data: acts,
+ });
+ } catch (error) {
+ console.error(error);
+ res.status(500).json({ error: 'An error occurred' });
+ }
+});
+
+activityApp.get('/drafts', async (req, res, next) => {
+ const page = parseInt(req.query.page) || 1;
+ const pageSize = parseInt(req.query.pageSize) || 5;
+ try {
+ const totalCount = await Activity.count({where: {
+ is_draft: true
+ }});
+ const offset = (page - 1) * pageSize;
+
+ const acts = await Activity.findAll({
+ offset,
+ limit: pageSize,
+ where: {
+ is_draft: true
+ },
+ order:[
+ ['date', 'DESC']]
+ });
+
+ res.json({
+ page,
+ pageSize,
+ totalCount,
+ data: acts,
+ });
+ } catch (error) {
+ console.error(error);
+ res.status(500).json({ error: 'An error occurred' });
+ }
+ });
+
+activityApp.get('/:id', (req, res, next) => {
+ Activity.findByPk(req.params.id).then((act) => {
+ if (!act) {
+ res.statusCode = 404;
+ res.json({ msg: "A atividade não está cadastrada" });
+ } else {
+ req.result = act.toJSON();
+ next();
+ }
+ }).catch(function (err) {
+ log.error(err);
+ return next(err);
+ });
+}, response('activity'));
+
+
+function transformDateFormat(dateString) {
+ // Split the date string into day, month, and year components
+ var parts = dateString.split('/');
+
+ // Extract day, month, and year values
+ var day = parts[0];
+ var month = parts[1];
+ var year = parts[2];
+
+ // Concatenate the components in "yyyy/mm/dd" format
+ var transformedDate = year + '/' + month + '/' + day;
+
+ return transformedDate;
+}
+
+
+
+activityApp.post('/', passport.authenticate('bearer', { session: false }), authorized('criar atividade'), async (req, res, next) => {
+ console.log(req.body);
+ let act = await Activity.create({
+ id: 0,
+ type:req.body.tipo,
+ title: req.body.titulo,
+ subtitle: req.body.subtitulo,
+ date: transformDateFormat(req.body.dataDePostagem),
+ authors:req.body.autor,
+ text: req.body.texto,
+ name_headline: req.body.nome,
+ resume_headline: req.body.resumo,
+ date_headline: transformDateFormat(req.body.dataAtividade),
+ local_headline: req.body.local,
+ additional_headline: req.body.informacoes,
+ is_draft: req.body.rascunho,
+ is_headline: req.body.is_headline
+ }).catch(function (err) {
+ log.error(err);
+ let errors = [];
+ for (let errName in err.errors) {
+ errors.push(err.errors[errName].message);
+ }
+ log.error(errors);
+ res.statusCode = 400;
+ return res.json({ err, errors });
+ // handle error;
+ });
+ if(!act){
+ res.statusCode = 400;
+ return res;
+ }
+ req.result = act.toJSON();
+ next();
+}, response('activity'));
+
+activityApp.put('/:id', passport.authenticate('bearer', { session: false }), authorized('editar atividade'), async (req, res, next) => {
+ let act = await Activity.findByPk(req.params.id).catch(function (err) {
+ if (err) {
+ log.error(err);
+ return next({ err });
+ }
+ })
+ if (!act) {
+ res.statusCode = 404;
+ return next({
+ err: {
+ message: 'Atividade não encontrada'
+ }
+ });
+ }
+ console.log("TEste");
+ act.type = req.body.type || act.type;
+ act.title = req.body.title || act.title;
+ act.subtitle = req.body.subtitle || act.subtitle;
+ act.date = req.body.date || act.date;
+ act.authors = req.body.autores || act.authors;
+ act.text= req.body.text || act.text;
+ act.name_headline= req.body.name_headline || act.name_headline;
+ act.resume_headline= req.body.resume_headline || act.resume_headline;
+ act.date_headline= req.body.date_headline || act.date_headline;
+ act.local_headline= req.body.local_headline || act.local_headline;
+ act.additional_headline= req.body.additional_headline || act.additional_headline;
+ act.is_draft= req.body.is_draft || act.is_draft;
+ act.is_headline= req.body.is_headline || act.is_headline;
+
+ act.save().catch(err => {
+ if (err) {
+ log.error(err);
+ return next({ message: 'Erro ao atualizar publicacao' });
+ }
+ })
+ let activity = act.toJSON();
+ res.json({ activity: activity});
+
+});
+
+activityApp.delete('/:id', passport.authenticate('bearer', { session: false }), authorized('editar atividade'), async (req, res, next) => {
+ await Activity.destroy({where:{id:req.params.id}}).catch(function (err) {
+ if (err) {
+ log.error(err);
+ return next({ err });
+ }
+});
+ return next({ msg: 'Activity Deleted', status: 200 });
+});
+
+module.exports = activityApp;
diff --git a/src/libs/routes_v1/api.js b/src/libs/routes_v1/api.js
index 4b6a56309deb7c253c77353b95c1bb8f9054f285..75a8e663f013e2716c8f01fdd99225b2265fb51e 100644
--- a/src/libs/routes_v1/api.js
+++ b/src/libs/routes_v1/api.js
@@ -18,6 +18,7 @@ You should have received a copy of the GNU General Public License
along with simcaq-node. If not, see <https://www.gnu.org/licenses/>.
*/
+
const express = require('express');
const api = express();
@@ -26,6 +27,8 @@ const libs = `${process.cwd()}/libs`;
const config = require(`${libs}/config`);
+const test = require('./test');
+
const classes = require('./class');
const enrollment = require('./enrollment');
@@ -134,11 +137,16 @@ const message = require(`${libs}/routes_v1/message`);
const courseStudents = require(`${libs}/routes_v1/courseStudents`);
+const publication = require(`${libs}/routes_v1/publication`);
+
+const activity = require(`${libs}/routes_v1/activity`);
+
api.get('/', (req, res) => {
res.json({ msg: 'SimCAQ API v1 is running' });
});
// mount API routes_v1
+api.use('/test', test);
api.use('/user', user);
api.use('/simulation', simulation);
api.use('/class', classes);
@@ -193,4 +201,10 @@ api.use('/universityLocalOffer', universityLocalOffer);
api.use('/message', message);
api.use('/course_students', courseStudents);
+//Publication
+api.use('/publication', publication);
+
+//Activity
+api.use('/activity', activity);
+
module.exports = api;
diff --git a/src/libs/routes_v1/downloads.js b/src/libs/routes_v1/downloads.js
index 2ec83b9ee7ffa82bbaf3e873c949c842dd6b6ab1..cd6cad0b127ce0186ba204aab70b9e5638b57813 100644
--- a/src/libs/routes_v1/downloads.js
+++ b/src/libs/routes_v1/downloads.js
@@ -8,46 +8,43 @@ const log = require(`${libs}/log`)(module);
const Download = require(`${libs}/models/download`);
-const User = require(`${libs}/models/user`);
-
const passport = require('passport');
const request = require(`request`);
const config = require(`${libs}/config`);
-downloadApp.get('/', passport.authenticate('bearer', {session: false}), (req, res, next) => {
- request.get(config.cdn.url + '/api/v1/file', (err, response, body) => {
+downloadApp.get('/', passport.authenticate('bearer', { session: false }), (req, res, next) => {
+ request.get(config.cdn.url + '/api/v1/file', async (err, response, body) => {
let cdn = JSON.parse(body);
- Download.find({userId: req.user._id}, (err, downloads) => {
+ const downloads = await Download.findAll({ where: { user_id: req.user.id } }).catch(function (err) {
if (err) {
log.error(err);
return next(err);
}
-
- if(!downloads) {
- res.statusCode = 404;
- return res.json({msg: 'Nenhum download encontrado'});
- } else {
- downloads.forEach((dl) => {
- for(let i = 0; i < cdn.length; ++i) {
- if(cdn[i].query == dl.query) {
- dl.status = cdn[i].expired ? 'Expirado' : 'Enviado';
- dl.size = cdn[i].size;
- dl.expired = cdn[i].expired;
- dl.updatedAt = cdn[i].lastAccess;
- dl.link = config.cdn.download + '/' + cdn[i]._id;
-
- dl.save((err) => {
- if(err) log.error(err);
- });
- return;
- }
- }
- });
- }
- res.json(downloads);
});
+ if (!downloads) {
+ res.statusCode = 404;
+ return res.json({ msg: 'Nenhum download encontrado' });
+ } else {
+ downloads.forEach((dl) => {
+ for (let i = 0; i < cdn.length; ++i) {
+ if (cdn[i].query == dl.query) {
+ dl.status = cdn[i].expired ? 'Expirado' : 'Enviado';
+ dl.size = cdn[i].size;
+ dl.expired = cdn[i].expired;
+ dl.updatedAt = cdn[i].lastAccess;
+ dl.link = config.cdn.download + '/' + cdn[i]._id;
+
+ dl.save((err) => {
+ if (err) log.error(err);
+ });
+ return;
+ }
+ }
+ });
+ }
+ res.json(downloads);
});
});
diff --git a/src/libs/routes_v1/file.controller.js b/src/libs/routes_v1/file.controller.js
new file mode 100644
index 0000000000000000000000000000000000000000..06464342676c391e309e061ace568b4390e3515b
--- /dev/null
+++ b/src/libs/routes_v1/file.controller.js
@@ -0,0 +1,41 @@
+var stream = require('stream');
+const libs = `${process.cwd()}/libs`;
+const File = require(`${libs}/models/file`);
+
+exports.uploadFile = async (_file) => {
+ let file = await File.create({
+ id: 0,
+ type: _file.mimetype,
+ name: _file.originalname,
+ data: _file.buffer
+ }).catch(err => {
+ console.log(err);
+ res.json({msg: 'Error', detail: err});
+ });
+ return file.id;
+}
+
+exports.listAllFiles = (req, res) => {
+ File.findAll({attributes: ['id', 'name']}).then(files => {
+ res.json(files);
+ }).catch(err => {
+ console.log(err);
+ res.json({msg: 'Error', detail: err});
+ });
+}
+
+exports.downloadFile = (req, res) => {
+ File.findByPk(req.params.id).then(file => {
+ var fileContents = Buffer.from(file.data, "base64");
+ var readStream = new stream.PassThrough();
+ readStream.end(fileContents);
+
+ res.set('Content-disposition', 'attachment; filename=' + file.name);
+ res.set('Content-Type', file.type);
+
+ readStream.pipe(res);
+ }).catch(err => {
+ console.log(err);
+ res.json({msg: 'Error', detail: err});
+ });
+}
diff --git a/src/libs/routes_v1/publication.js b/src/libs/routes_v1/publication.js
new file mode 100644
index 0000000000000000000000000000000000000000..1eff1f6b814ed6309fe78ec9ab23d8e7ffe5c25a
--- /dev/null
+++ b/src/libs/routes_v1/publication.js
@@ -0,0 +1,207 @@
+const express = require('express');
+
+const pubApp = express();
+
+const libs = `${process.cwd()}/libs`;
+
+const config = require(`${libs}/config`);
+
+const log = require(`${libs}/log`)(module);
+
+const Publication = require(`${libs}/models/publication`);
+
+const File = require(`${libs}/models/file`);
+
+const response = require(`${libs}/middlewares/response`);
+
+const email = require(`${libs}/middlewares/email`);
+
+const passport = require('passport');
+
+const fileWorker = require('./file.controller.js');
+
+let upload = require('../middlewares/multer.config.js');
+
+const authorized = require(`${libs}/middlewares/authorize.js`);
+
+function emailSyntax(email) {
+ const regex = /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
+ return regex.test(email);
+}
+
+pubApp.get('/', async (req, res, next) => {
+ const page = parseInt(req.query.page) || 1; // Current page number
+ const pageSize = parseInt(req.query.pageSize) || 5; // Number of items per page
+ try {
+ const totalCount = await Publication.count();
+ const offset = (page - 1) * pageSize;
+
+ const publis = await Publication.findAll({
+ offset,
+ limit: pageSize,
+ });
+
+ res.json({
+ page,
+ pageSize,
+ totalCount,
+ data: publis,
+ });
+ } catch (error) {
+ console.error(error);
+ res.status(500).json({ error: 'An error occurred' });
+ }
+});
+
+pubApp.get('/drafts', async (req, res, next) => {
+ const page = parseInt(req.query.page) || 1; // Current page number
+ const pageSize = parseInt(req.query.pageSize) || 5; // Number of items per page
+
+ try {
+ // Count total number of items
+ const totalCount = await Publication.count({ where: {
+ is_draft: true
+ }});
+
+ // Calculate offset based on page and pageSize
+ const offset = (page - 1) * pageSize;
+
+ // Query the database with pagination options
+ const drafts = await Publication.findAll({
+ offset,
+ limit: pageSize,
+ where: {
+ is_draft: true
+ }
+ });
+
+ res.json({
+ page,
+ pageSize,
+ totalCount,
+ data: drafts,
+ });
+ } catch (error) {
+ console.error(error);
+ res.status(500).json({ error: 'An error occurred' });
+ }
+});
+
+
+pubApp.get('/:id', async (req, res, next) => {
+ let pb = await Publication.findByPk(req.params.id).catch(function (err) {
+ log.error(err);
+ return next(err);}
+ );
+ if (!pb) {
+ res.statusCode = 404;
+ res.json({ msg: "A publicação não está cadastrada" });
+ }
+ else {
+ let publ = pb.toJSON();
+ publ.Filename = null;
+ const file_ = await File.findByPk(pb.upload).catch((err) => {
+ log.error(err);
+ return next(err);
+ });
+ if(file_){
+ publ.Filename = file_.name;
+ }
+ req.result = publ;
+ next();
+ }
+ }, response('publication'));
+
+pubApp.post('/', passport.authenticate('bearer', { session: false }), authorized('criar publicacao'), upload.single('file'), async (req, res, next) => {
+ let _file_id = null
+ if(req.file){
+ _file_id = await fileWorker.uploadFile(req.file);
+ if(!_file_id)
+ console.log("NAO ARQUIVO");}
+ let data = JSON.parse(req.body.data);
+ let pb = await Publication.create({
+ id: 0,
+ filter: data.categoria,
+ title: data.title,
+ authors: data.autores,
+ organization: data.organizacao,
+ year: data.ano,
+ text: data.texto,
+ link: data.link,
+ upload: _file_id,
+ is_draft: data.rascunho,
+ is_homepage: data.homepage
+ }).catch(function (err) {
+ log.error(err);
+ let errors = [];
+ for (let errName in err.errors) {
+ errors.push(err.errors[errName].message);
+ }
+ log.error(errors);
+ res.statusCode = 400;
+ return res.json({ err, errors });
+ // handle error;
+ });
+ req.result = pb.toJSON();
+ next();
+}, response('publication'));
+
+pubApp.post('/edit', passport.authenticate('bearer', { session: false }), authorized('editar publicacao'), upload.single('file'), async (req, res, next) => {
+ let _file_id = null
+ if(req.file){
+ _file_id = await fileWorker.uploadFile(req.file);
+ if(!_file_id)
+ console.log("NAO ARQUIVO");}
+ let data = JSON.parse(req.body.data);
+ req.result = data.toJSON();
+ next();
+}, response('publication'));
+
+pubApp.put('/edit/:id', passport.authenticate('bearer', { session: false }), authorized('editar publicacao'), async (req, res, next) => {
+ console.log(req);
+ let pb = await Publication.findByPk(req.params.id).catch(function (err) {
+ if (err) {
+ log.error(err);
+ return next({ err });
+ }
+ })
+ if (!pb) {
+ res.statusCode = 404;
+ return next({
+ err: {
+ message: 'Publicação não encontrada'
+ }
+ });
+ }
+ pb.filter = req.body.categoria || pb.filter;
+ pb.title = req.body.title || pb.title;
+ pb.authors = req.body.autores || pb.authors;
+ pb.organization= req.body.organizacao || pb.organization;
+ pb.year= req.body.ano || pb.year;
+ pb.text= req.body.texto || pb.text;
+ pb.link= req.body.link || pb.link;
+ pb.upload= req.body.upload || pb.upload;
+ pb.is_homepage= req.body.homepage || pb.is_homepage;
+ console.log(pb);
+ pb.save().catch(err => {
+ if (err) {
+ log.error(err);
+ return next({ message: 'Erro ao atualizar publicacao' });
+ }
+ })
+ let p = pb.toJSON();
+ res.json({ publication: p });
+
+});
+
+pubApp.delete('/:id', passport.authenticate('bearer', { session: false }), authorized('apagar publicacao'), async (req, res, next) => {
+ await Publication.destroy({where:{id:req.params.id}}).catch(function (err) {
+ if (err) {
+ log.error(err);
+ return next({ err });
+ }
+});
+ return next({ msg: 'Publication Deleted', status: 200 });
+});
+
+module.exports = pubApp;
diff --git a/src/libs/routes_v1/resetToken.js b/src/libs/routes_v1/resetToken.js
index 34ece8455adf7b77208dc200a95641ed04638609..579bec0bde0c4bdff26e2f1dc588ff801697a82f 100644
--- a/src/libs/routes_v1/resetToken.js
+++ b/src/libs/routes_v1/resetToken.js
@@ -10,72 +10,72 @@ const ResetToken = require(`${libs}/models/resetToken`);
const User = require(`${libs}/models/user`);
-resetTokenApp.get('/:token', (req, res, next) => {
+resetTokenApp.get('/:token', async (req, res, next) => {
let token = req.params.token;
- ResetToken.findOne({token: token}, (err, rToken) => {
- if(err) {
+ let rToken = await ResetToken.findOne({where:{ token: token} }).catch(function (err) {
+ if (err) {
log.error(err);
- return next(err);
+ return next({ err });
}
- if(!rToken) {
- // TODO: generate new reset token
- res.statusCode = 404;
- return next({msg: 'Token not found', status:404});
- }
- if (rToken.hasExpired()) {
- res.statusCode = 410;
- ResetToken.remove({token: token}, (err) => {
- if(err) {
- log.error(err);
- next(err);
- }
- })
- return next({msg: 'Token expired', status: 410});
- }
- User.findById(rToken.userId, (err, user) => {
- if(err) {
+ })
+ if (!rToken) {
+ res.statusCode = 404;
+ return next({ msg: 'Token not found', status: 404 });
+ }
+ if (rToken.hasExpired()) {
+ res.statusCode = 410;
+ await ResetToken.destroy({where:{ token: token}}).catch(function (err) {
+ if (err) {
log.error(err);
- next(err);
+ return next({ err });
}
- let u = user.toObject();
- delete u.salt;
- delete u.hashedPassword;
- res.json({user: u});
- });
- });
+ })
+ return next({ msg: 'Token expired', status: 410 });
+ }
+ let _user = await User.findByPk(rToken.user_id).catch(function (err) {
+ if (err) {
+ log.error(err);
+ return next({ err });
+ }
+ })
+ let u = _user.toJSON();
+ delete u.salt;
+ delete u.hashed_password;
+ res.json({ user: u });
});
-resetTokenApp.post('/:token', (req, res, next) => {
+
+resetTokenApp.post('/:token', async (req, res, next) => {
let token = req.params.token;
- ResetToken.findOne({token: token}, (err, rToken) => {
- if(err) {
+ let rToken = await ResetToken.findOne({where:{ token: token}}).catch(function (err) {
+ if (err) {
log.error(err);
- return next(err);
+ return next({ err });
}
- if(!rToken) {
- res.statusCode = 404;
- return next({msg: 'Token not found', status:404});
+ })
+ if (!rToken) {
+ res.statusCode = 404;
+ return next({ msg: 'Token not found', status: 404 });
+ }
+ let _user = await User.findByPk(rToken.user_id).catch(function (err) {
+ if (err) {
+ log.error(err);
+ return next({ err });
}
- User.findById(rToken.userId, (err, user) => {
- if(err) {
- log.error(err);
- next(err);
- }
- user.password = req.body.password;
- user.save((err) => {
- if(err) {
- log.error(err);
- next(err);
- }
- ResetToken.remove({token: token}, (err) => {
- if(err) {
- log.error(err);
- next(err);
- }
- })
- res.json({msg: "Senha alterada com sucesso"});
- })
- });
- });
-})
+ })
+ await _user.update({password:req.body.password});
+ _user.save().catch(function (err) {
+ if (err) {
+ log.error(err);
+ return next({ err });
+ }
+ })
+ await ResetToken.destroy({where:{token: token} }).catch(function (err) {
+ if (err) {
+ log.error(err);
+ return next({ err });
+ }
+ })
+ res.json({ msg: "Senha alterada com sucesso" });
+});
module.exports = resetTokenApp;
diff --git a/src/libs/routes_v1/simulation.js b/src/libs/routes_v1/simulation.js
index 4b2e40c33dd1855116353f618a7c87c13078eb84..cc0ab38025dc0a9b2c39c4ebaa3f8a962d178525 100644
--- a/src/libs/routes_v1/simulation.js
+++ b/src/libs/routes_v1/simulation.js
@@ -6,12 +6,6 @@ const libs = `${process.cwd()}/libs`;
const log = require(`${libs}/log`)(module);
-const squel = require('squel');
-
-const query = require(`${libs}/middlewares/query`).query;
-
-const response = require(`${libs}/middlewares/response`);
-
const Simulation = require(`${libs}/models/simulation`);
const PQR = require(`${libs}/models/pqr`);
@@ -20,7 +14,7 @@ const passport = require('passport');
simulationApp.get('/time', (req, res, next) => {
const maxTime = parseInt(req.query.max_time, 10);
- if(isNaN(maxTime)) {
+ if (isNaN(maxTime)) {
res.status(400);
next({
status: 400,
@@ -28,57 +22,61 @@ simulationApp.get('/time', (req, res, next) => {
});
}
res.json({
- result: Array.apply(null, {length: maxTime}).map(Number.call, Number).map((i)=>i+1)
+ result: Array.apply(null, { length: maxTime }).map(Number.call, Number).map((i) => i + 1)
});
});
-simulationApp.get('/pqr', (req, res) => {
- PQR.findOne((err, pqr) => {
- if(err) {
+simulationApp.get('/pqr', async (req, res) => {
+ let pqr = await PQR.findOne({ attributes: ['content'] }).catch(function (err) {
+ if (err) {
log.error(err);
- return next({err});
+ return next({ err });
}
-
- res.json(pqr);
});
+ if (pqr)
+ res.json(pqr);
});
-simulationApp.put('/pqr', passport.authenticate('bearer', { session: false }), (req, res, next) => {
- let user = req.user.toObject();
-
- PQR.findOne((err, pqr) => {
- if(err) {
- log.error(err)
- return next({err});
+simulationApp.put('/pqr', passport.authenticate('bearer', { session: false }), async (req, res, next) => {
+ let user = req.user;
+ let pqr = await PQR.findOne().catch(function (err) {
+ if (err) {
+ log.error(err);
+ return next({ err });
}
+ });
+ if (!user.admin) {
+ log.info(`Usuário ${user.email} tentou alterar o PQR, mas não tem privilégio`);
+ res.statusCode = 401;
+ return next({ err: { msg: 'Unauthorized' } });
+ }
- if(!user.admin) {
- log.info(`Usuário ${user.email} tentou alterar o PQR, mas não tem privilégio`);
- res.statusCode = 401;
- return next({err: { msg: 'Unauthorized'}});
- }
- pqr.content = req.body.content || pqr.content;
- pqr.save((err) => {
- if(err) {
+ if(pqr){
+ let _content = req.body.content || pqr.content;
+ pqr.content = _content;
+ await pqr.save({fields:['content']}).catch(function (err) {
+ if (err) {
log.error(err);
- return next({err});
+ return next({ err });
}
- res.json({msg: 'PQR updated'})
- });
- });
+ });}
+
+ res.json({ msg: 'PQR updated' })
+
});
-simulationApp.get('/', passport.authenticate('bearer', { session: false }), (req, res) => {
- let user = req.user.toObject();
- let query = Simulation.find({userId: user._id}).select('userId name createdAt updatedAt');
- query.exec((err, simulations) => {
- if(err) {
+simulationApp.get('/', passport.authenticate('bearer', { session: false }), async (req, res) => {
+ let user = req.user;
+ let simulations = await Simulation.findAll({ where: { user_id: user.id } }, { attributes: ['user_id', 'name', 'created_at', 'updated_at'] }).catch(function (err) {
+ if (err) {
log.error(err);
- return next({err});
+ return next({ err });
}
-
- res.json(simulations);
- });
+ })
+ if (!simulations){
+ res.json("Simulations not found");
+ }
+ res.json(simulations);
// Simulation.find({userId: user._id}, (err, simulations) => {
// if(err) {
@@ -90,78 +88,74 @@ simulationApp.get('/', passport.authenticate('bearer', { session: false }), (req
// });
});
-simulationApp.post('/', passport.authenticate('bearer', { session: false }), (req, res, next) => {
- let user = req.user.toObject();
+simulationApp.post('/', passport.authenticate('bearer', { session: false }), async (req, res, next) => {
+ let user = req.user;
- let simulation = new Simulation({
- userId: user._id,
+ let simulation = await Simulation.create({
+ user_id: user.id,
content: req.body.content,
name: req.body.name
});
- simulation.save((err) => {
- if(err) {
+ await simulation.save().catch(function (err) {
+ if (err) {
log.error(err);
- return next({err});
+ return next({ err });
}
+ });
- res.json({msg: 'Simulation created', simulation});
- })
-});
+ res.json({ msg: 'Simulation created', simulation });
+})
-simulationApp.get('/:id', passport.authenticate('bearer', { session: false }), (req, res) => {
- let user = req.user.toObject();
+simulationApp.get('/:id', passport.authenticate('bearer', { session: false }), async (req, res) => {
+ let user = req.user;
- Simulation.findOne({_id: req.params.id, userId: user._id}, (err, simulation) => {
- if(err) {
+ let simulation = await Simulation.findOne({where:{id: req.params.id, user_id: user.id }}).catch(function (err) {
+ if (err) {
log.error(err);
- return next({err});
+ return next({ err });
}
-
- res.json(simulation);
});
+ res.json(simulation);
+
});
-simulationApp.put('/:id', passport.authenticate('bearer', { session: false }), (req, res, next) => {
- let user = req.user.toObject();
+simulationApp.put('/:id', passport.authenticate('bearer', { session: false }), async (req, res, next) => {
+ let user = req.user;
- Simulation.findOne({_id: req.params.id, userId: user._id}, (err, simulation) => {
- if(err) {
+ let simulation = await Simulation.findOne({ where: { id: req.params.id, user_id: user.id } }).catch(function (err) {
+ if (err) {
log.error(err);
- return next({err});
+ return next({ err });
}
+ });
- if(!simulation) {
- res.statusCode = 404;
- return next({err: { msg: 'Simulation not found'}});
- }
-
- simulation.content = req.body.content || simulation.content;
- simulation.name = req.body.name || simulation.name;
- simulation.updatedAt = Date.now();
-
- simulation.save((err) => {
- if(err) {
- log.error(err);
- return next(err);
- }
+ if (!simulation) {
+ res.statusCode = 404;
+ return next({ err: { msg: 'Simulation not found' } });
+ }
- res.json(simulation);
- });
+ simulation.content = req.body.content || simulation.content;
+ simulation.name = req.body.name || simulation.name;
+ simulation.updated_at = new Date();
+ await simulation.save({fields:['content','name','updated_at']}).catch(function (err) {
+ if (err) {
+ log.error(err);
+ return next({ err });
+ }
});
+ res.json({ msg: 'Simulation created', simulation });
});
-simulationApp.delete('/:id', passport.authenticate('bearer', { session: false }), (req, res, next) => {
- let user = req.user.toObject();
-
- Simulation.remove({_id: req.params.id, userId: user._id}, (err, simulation) => {
- if(err) {
+simulationApp.delete('/:id', passport.authenticate('bearer', { session: false }), async (req, res, next) => {
+ let user = req.user;
+ await Simulation.destroy({where: { "id": req.params.id, "user_id": user.id } }).catch(function (err) {
+ if (err) {
log.error(err);
- return next({err});
+ return next({ err });
}
-
- res.json({msg: 'Simulation removed'});
});
+ res.json({ msg: 'Simulation removed' });
});
module.exports = simulationApp;
diff --git a/src/libs/routes_v1/test.js b/src/libs/routes_v1/test.js
new file mode 100644
index 0000000000000000000000000000000000000000..9e8482dcf3bbdcb52faf269d9a7e7f57d37069cf
--- /dev/null
+++ b/src/libs/routes_v1/test.js
@@ -0,0 +1,100 @@
+const express = require('express');
+const oauth2orize = require('oauth2orize');
+const passport = require('passport');
+const ClientPasswordStrategy = require('passport-oauth2-client-password');
+const testApp = express();
+const libs = `${process.cwd()}/libs`;
+
+const Client = require(`${libs}/models/client`);
+const User = require(`${libs}/models/user`)
+var server = oauth2orize.createServer();
+
+passport.use(new ClientPasswordStrategy(
+ function(client_id, client_secret, done) {
+ Client.findOne({where: {client_id: client_id}
+ }).then(function(err, client) {
+ if(err){
+ console.log("Erro de requisicao");
+ return done(err);
+ }
+ if(!client){
+ console.log("Erro de cliente");
+ return done(null, false);
+ }
+ if (client.client_secret !== client_secret){
+ console.log("Erro de geracao Chave Secreta");
+ return done(null, false);
+ }
+ console.log("Tudo certo nesse use");
+ return done(null, client);
+ })
+ }
+ ));
+
+let generateTokens = (userId, clientId, done) => {
+ // curries in `done` callback so we don't need to pass it
+ let refreshTokenValue;
+ let token;
+ let tokenValue;
+
+ RefreshToken.destroy({where:{"user_id": userId, "client_id": clientId}});
+ AccessToken.destroy({where:{"user_id": userId, "client_id": clientId}});
+
+ tokenValue = crypto.randomBytes(32).toString('hex');
+ refreshTokenValue = crypto.randomBytes(32).toString('hex');
+
+ AccessToken.create({
+ user_id:userId,
+ client_id:clientId,
+ token:tokenValue
+ })
+
+ let refreshed_token = refreshTokenValue;
+
+ RefreshToken.create({
+ user_id:userId,
+ client_id:clientId,
+ token:refreshed_token
+ })
+
+ token.save((err) => {
+ if (err) {
+ log.error(err);
+ return done(err);
+ }
+ done(null, tokenValue, refreshTokenValue, {
+ 'expires_in': config.security.tokenLife
+ });
+ })
+};
+
+
+let entrar = function(client, username, done) {
+ User.findOne({
+ where: {email:username}
+ }).then(function(user) {
+ console.log(user)
+ if(user == null){
+ return done(null, false);
+ }
+ if(user.dataValues.origin != client.client_secret){
+ console.log("Erro de client_secret");
+ return done(null, false);
+ }
+ log.info(`Gerando token para usuário ${user.name}`);
+ generateTokens(user._id, client._id, done);
+ }).catch(function(error) {
+ return done(error);
+ });
+ };
+
+
+
+
+
+testApp.post('/', (req, res, next) =>{
+ entrar(req.body, req.body.username);
+});
+
+
+module.exports = testApp;
\ No newline at end of file
diff --git a/src/libs/routes_v1/user.js b/src/libs/routes_v1/user.js
index 7ff088eea62f34ffd3b66de4a28ae42807a97e8d..1a6044cc1f7775116c9ab1895ba2671f17d135eb 100644
--- a/src/libs/routes_v1/user.js
+++ b/src/libs/routes_v1/user.js
@@ -20,6 +20,8 @@ const email = require(`${libs}/middlewares/email`);
const passport = require('passport');
+const uuid = require('node-uuid');
+
function emailSyntax(email) {
const regex = /^(([^<>()\[\]\.,;:\s@\"]+(\.[^<>()\[\]\.,;:\s@\"]+)*)|(\".+\"))@(([^<>()[\]\.,;:\s@\"]+\.)+[^<>()[\]\.,;:\s@\"]{2,})$/i;
return regex.test(email);
@@ -56,16 +58,16 @@ userApp.get('/segment', (req, res, next) => {
userApp.get('/role', (req, res, next) => {
req.result = [
- {"Gestores e equipe gestora das secretarias e ministério da Educação" : ["Dirigente municipal, estadual e federal", "Secretário do MEC", "Servidor da área de planejamento educacional", "Membro de associação de gestores (Ex. Undime, Consed, etc)", "Outro [citar função]"]},
- {"Gestores dos órgãos de planejamento e finanças (das três esferas de governo)" : ["Equipe gestora dos órgãos de planejamento", "Equipe gestora dos órgãos de finanças", "Outro [citar função]"]},
- {"Agentes do poder legislativo" : ["Parlamentar", "Assessor/a parlamentar", "Auditor/a dos tribunais de conta", "Conselheiro/a de tribunais de conta.", "Outro [citar função]"]},
- {"Agentes dos conselhos de educação" : ["Conselheiro/a municipais, estaduais e federais", "Conselheiro/a do Fundeb", "Outro [citar função]"]},
- {"Profissionais da educação" : ["Professor/a da Educação Básica", "Profissional da educação não-docente", "Outro [citar função]"]},
- {"Sindicato" : ["Agente de sindicatos"]},
- {"Sociedade civil interessada no financiamento da Educação Básica de qualidade" : ["Membro de fóruns educacionais", "Membro de ONGs e demais entidades sem fins lucrativos", "Estudante da educação básica e membro de entidades estudantis", "Pais e membros de entidades de pais", "Outro [citar função]"]},
- {"Comunidade acadêmica" : ["Pesquisador/a", "Estudantes de graduação e pós-graduação", "Representantes de entidades de pesquisa (Ex.: ANPED, ANPAE e FINEDUCA)", "Outro [citar função]"]},
- {"Imprensa" : ["Jornalista", "Outro [citar função]"]},
- {"Outro [citar segmento]" : []}
+ { "Gestores e equipe gestora das secretarias e ministério da Educação": ["Dirigente municipal, estadual e federal", "Secretário do MEC", "Servidor da área de planejamento educacional", "Membro de associação de gestores (Ex. Undime, Consed, etc)", "Outro [citar função]"] },
+ { "Gestores dos órgãos de planejamento e finanças (das três esferas de governo)": ["Equipe gestora dos órgãos de planejamento", "Equipe gestora dos órgãos de finanças", "Outro [citar função]"] },
+ { "Agentes do poder legislativo": ["Parlamentar", "Assessor/a parlamentar", "Auditor/a dos tribunais de conta", "Conselheiro/a de tribunais de conta.", "Outro [citar função]"] },
+ { "Agentes dos conselhos de educação": ["Conselheiro/a municipais, estaduais e federais", "Conselheiro/a do Fundeb", "Outro [citar função]"] },
+ { "Profissionais da educação": ["Professor/a da Educação Básica", "Profissional da educação não-docente", "Outro [citar função]"] },
+ { "Sindicato": ["Agente de sindicatos"] },
+ { "Sociedade civil interessada no financiamento da Educação Básica de qualidade": ["Membro de fóruns educacionais", "Membro de ONGs e demais entidades sem fins lucrativos", "Estudante da educação básica e membro de entidades estudantis", "Pais e membros de entidades de pais", "Outro [citar função]"] },
+ { "Comunidade acadêmica": ["Pesquisador/a", "Estudantes de graduação e pós-graduação", "Representantes de entidades de pesquisa (Ex.: ANPED, ANPAE e FINEDUCA)", "Outro [citar função]"] },
+ { "Imprensa": ["Jornalista", "Outro [citar função]"] },
+ { "Outro [citar segmento]": [] }
]
next();
}, response('role'));
@@ -92,214 +94,249 @@ userApp.get('/', passport.authenticate('bearer', {session: false}), (req, res, n
*/
userApp.get('/me', passport.authenticate('bearer', { session: false }), (req, res, next) => {
- let user = req.user.toObject();
- delete user.hashedPassword;
- delete user.salt;
- req.result = user;
+ let u = req.user.toJSON();
+ u._id = u.id;
+ u.institutionName = u.institution_name;
+ u.receiveEmails = u.receive_email;
+ u.receive_emails = u.receive_email;
+ delete u.id;
+ delete u.institution_name;
+ delete u.receive_email;
+ delete u.hashed_password;
+ delete u.salt;
+
+ req.result = u;
next();
}, response('user'));
+function isEmpty(str) {
+ return (!str || str.length === 0 );
+}
+
userApp.get('/:id', (req, res, next) => {
- User.findById(req.params.id, (err, user) => {
- if(err) {
- log.error(err);
- return next(err);
- }
- if(!user) {
- req.statusCode = 404;
- next({msg: 'User not found'});
+ User.findByPk(req.params.id).then((user) => {
+ if (!user) {
+ res.statusCode = 404;
+ res.json({ msg: "O usuário não está cadastrado" });
} else {
- let u = user.toObject;
- delete u.hashedPassword;
+ let u = user.toJSON();
+ u._id = u.id;
+ u.institutionName = u.institution_name;
+ u.receiveEmails = u.receive_email;
+ u.receive_emails = u.receive_email;
+ delete u.id;
+ delete u.institution_name;
+ delete u.receive_email;
+ delete u.hashed_password;
delete u.salt;
req.result = u;
next();
}
+ }).catch(function (err) {
+ log.error(err);
+ return next(err);
});
}, response('user'));
-userApp.post('/', (req, res, next) => {
- let user = new User({
- email: req.body.email,
- password: req.body.password,
- name: req.body.name,
- nickname: req.body.nickname,
- cpf: req.body.cpf,
- cep: req.body.cep,
- complement: req.body.complement,
- address: req.body.address,
- phone: req.body.phone,
- schooling: req.body.schooling,
- course: req.body.course,
- segment: req.body.segment,
- role: req.body.role,
- institutionName: req.body.institutionName,
- state: req.body.state,
- city: req.body.city,
- receiveEmails: false || req.body.receiveEmails,
- origin: req.body.origin,
- citesegment: req.body.citesegment,
- citerole: req.body.citerole,
- admin: false
- });
-
+userApp.post('/', async (req, res, next) => {
if (typeof req.body.password === 'undefined' || !req.body.password) {
res.statusCode = 400;
- return res.json({errors: ["O campo senha é obrigatório"]});
- } else {
- user.save((err) => {
- if(err) {
+ return res.json({ errors: ["O campo senha é obrigatório"] });
+ }
+ else {
+ let user = await User.create({
+ id: 0,
+ email: req.body.email,
+ password: req.body.password,
+ hashed_password: 0,
+ salt: 0,
+ name: req.body.name,
+ nickname: req.body.nickname,
+ cpf: req.body.cpf,
+ cep: req.body.cep,
+ complement: req.body.complement,
+ address: req.body.address,
+ phone: req.body.phone,
+ schooling: req.body.schooling,
+ course: req.body.course,
+ segment: req.body.segment,
+ role: req.body.role,
+ institution_name: req.body.institutionName,
+ state: req.body.state,
+ city: req.body.city,
+ receive_email: false || req.body.receiveEmails || req.body.receive_emails,
+ origin: req.body.origin,
+ citesegment: req.body.citesegment,
+ citerole: req.body.citerole,
+ admin: false,
+ role_id: 0
+ }).catch(function (err) {
+ log.error(err);
+ let errors = [];
+ for (let errName in err.errors) {
+ errors.push(err.errors[errName].message);
+ }
+ log.error(errors);
+ res.statusCode = 400;
+ return res.json({ err, errors });
+ // handle error;
+ });
+ let tokenValue = uuid.v4();
+ const verificationToken = VerificationToken.create({
+ user_id: user.id,
+ token: tokenValue,
+ verified: false
+ });
+ if (!verificationToken) {
+ res.statusCode = 404;
+ return res.json({ msg: "Couldn't create Verification Token" });
+ }
+ let url = config.default.lde.url + '/verify';
+ let text = `Olá, ${user.name}, seja bem vindo/a ao Laboratório de Dados Educacionais.\n\nClique neste link para confirmar sua conta: ${url}/${tokenValue}`;
+ // Send confirmation email
+ let mailOptions = {
+ to: `"${user.name} <${user.email}>"`,
+ subject: "Confirme seu cadastro - Laboratório de Dados Educacionais",
+ text
+ }
+ email(mailOptions, (err, info) => {
+ if (err) {
log.error(err);
- let errors = [];
- for(let errName in err.errors) {
- errors.push(err.errors[errName].message);
- }
- log.error(errors);
- res.statusCode = 400;
- return res.json({err, errors});
+ res.json({ msg: 'Message not delivered, user created but not confirmed' });
}
-
- // Create verification token
- let verificationToken = new VerificationToken({
- userId: user._id
- });
-
- verificationToken.createVerificationToken((err, token) => {
- if(err) {
- log.error(err);
- return next(err);
- }
- let url = config.default.lde.url + '/verify';
- let text = `Olá, ${user.name}, seja bem vindo/a ao Laboratório de Dados Educacionais.\n\nClique neste link para confirmar sua conta: ${url}/${token}`;
- // Send confirmation email
- let mailOptions = {
- to: `"${user.name} <${user.email}>"`,
- subject: "Confirme seu cadastro - Laboratório de Dados Educacionais",
- text
- }
- email(mailOptions, (err, info) => {
- if(err) {
- log.error(err);
- res.json({msg: 'User created'});
- }
- if(info) {
- log.info(`Message ${info.messageId} sent: ${info.response}`);
- log.info(`Usuário ${user.email} foi criado`);
- }
- res.json({msg: 'User created'});
- });
- });
+ if (info) {
+ log.info(`Message ${info.messageId} sent: ${info.response}`);
+ log.info(`Usuário ${user.email} foi criado`);
+ }
+ res.json({ msg: 'User created' });
});
}
-
});
-userApp.put('/:id', passport.authenticate('bearer', { session: false }), (req, res, next) => {
- User.findById(req.params.id, (err, user) => {
+userApp.put('/:id', passport.authenticate('bearer', { session: false }), async (req, res, next) => {
+ let user = await User.findByPk(req.params.id).catch(function (err) {
if (err) {
log.error(err);
- return next({err});
+ return next({ err });
}
-
- if(!user) {
- res.statusCode = 404;
- return next({err: {
+ })
+ if (!user) {
+ res.statusCode = 404;
+ return next({
+ err: {
message: 'Usuário não encontrado'
- }});
- }
+ }
+ });
+ }
- user.email = req.body.email || user.email;
- user.name = req.body.name || user.name;
- user.nickname = req.body.nickname || user.nickname || user.name;
- user.cep = req.body.cep || user.cep;
- user.complement = req.body.complement || user.complement;
- user.address = req.body.address || user.address;
- user.phone = req.body.phone || user.phone;
- user.schooling = req.body.schooling || user.schooling;
- user.course = req.body.course || user.course;
- user.segment = req.body.segment || user.segment;
- user.role = req.body.role || user.role;
- user.institutionName = req.body.institutionName || user.institutionName;
- user.state = req.body.state || user.state;
- user.city = req.body.city || user.city;
- user.receiveEmails = req.body.receiveEmails || user.receiveEmails;
- user.citesegment = req.body.citesegment || user.citesegment;
- user.citerole = req.body.citerole || user.citerole;
+ user.email = req.body.email || user.email;
+ user.name = req.body.name || user.name;
+ user.nickname = req.body.nickname || user.nickname || user.name;
+ user.cep = req.body.cep || user.cep;
+ user.complement = req.body.complement || user.complement;
+ user.address = req.body.address || user.address;
+ user.phone = req.body.phone || user.phone;
+ user.schooling = req.body.schooling || user.schooling;
+ user.course = req.body.course || user.course;
+ user.segment = req.body.segment || user.segment;
+ user.role = req.body.role || user.role;
+ user.institutionName = req.body.institutionName || user.institutionName;
+ user.state = req.body.state || user.state;
+ user.city = req.body.city || user.city;
+ user.receive_email = req.body.receiveEmails || req.body.receive_emails || user.receive_email;
+ user.citesegment = req.body.citesegment || user.citesegment;
+ user.citerole = req.body.citerole || user.citerole;
- if ((req.body.password) && (req.body.newpassword)) {
- if (req.body.password != req.body.newpassword) {
- if (user.checkPassword(req.body.password)) {
- user.password = req.body.newpassword;
- } else {
- res.statusCode = 500;
- return res.json({error: {
- message: 'A senha atual está incorreta'
- }});
- }
- } else {
- res.statusCode = 500;
- return res.json({error: {
- message: 'A nova senha é a mesma da senha atual'
- }});
+ if((!isEmpty(req.body.password)) && (!isEmpty(req.body.newpassword))){
+ if (req.body.password != req.body.newpassword) {
+ if (user.checkPassword(user, req.body.password)) {
+ await user.update({password:req.body.newpassword});
+ }
+ else {
+ res.statusCode = 500;
+ return res.json({
+ error: {
+ message: 'A senha atual está incorreta'
+ }
+ });
+ }
+ } else {
+ res.statusCode = 500;
+ return res.json({
+ error: {
+ message: 'A nova senha é a mesma da senha atual'
}
+ });
}
+ }
+
+ user.save().catch(err => {
+ if (err) {
+ log.error(err);
+ return next({ message: 'Erro ao atualizar usuário' });
+ }})
+ let u = user.toJSON();
+ u._id = u.id;
+ u.institutionName = u.institution_name;
+ u.receiveEmails = u.receive_email;
+ u.receive_emails = u.receive_email;
+ delete u.id;
+ delete u.institution_name;
+ delete u.receive_email;
+ delete u.hashed_password;
+ delete u.salt;
+ delete u.password;
+ res.json({ user: u });
- user.save(err => {
- if(err) {
- log.error(err);
- return next({message: 'Erro ao atualizar usuário'});
- }
- let u = user.toObject();
- delete u.hashedPassword;
- delete u.salt;
- res.json({user: u});
- })
- })
});
-userApp.get('/reset/password', (req, res, next) => {
+
+userApp.get('/reset/password', async (req, res, next) => {
let emailAddress = req.query.email;
- User.findOne({email: emailAddress}, (err, user)=> {
- if(err) {
- log.error(err);
- let errors = [];
- for(let errName in err.errors) {
- errors.push(err.errors[errName].message);
- }
- res.statusCode = 400;
- return res.json({err, errors});
+ let user = await User.findOne({ where: { email: emailAddress } }).catch(function (err) {
+ log.error(err);
+ let errors = [];
+ for (let errName in err.errors) {
+ errors.push(err.errors[errName].message);
}
- if (!user) {
+ log.error(errors);
+ res.statusCode = 400;
+ return res.json({ err, errors });
+ // handle error;
+ });
+ if (!user) {
+ res.statusCode = 404;
+ res.json({ msg: "O usuário não está cadastrado" });
+ }
+ else {
+ let tokenValue = uuid.v4();
+ const rt = await ResetToken.create({
+ user_id: user.id,
+ token: tokenValue,
+ reset: false
+ });
+ if (!rt) {
res.statusCode = 404;
- res.json({msg: "O usuário não está cadastrado"});
+ return res.json({ msg: "Couldn't create Reset Password Token" });
}
- else {
- let resetToken = new ResetToken({
- userId: user._id
- });
- resetToken.createResetToken((err, token) => {
- if (err) {
- log.error(err);
- return next(err);
- }
- let url = config.default.lde.url + '/reset-password';
- let text = `Olá, ${user.name}.\n\nRecebemos uma solicitação para redefinir sua senha do Laboratório de Dados Educacionais. Clique neste link para redefinir a sua senha: ${url}/${token}`;
- let mailOptions = {
- to: `"${user.name} <${user.email}>"`,
- subject: "Redefinição de Senha - Laboratório de Dados Educacionais",
- text
- }
- email(mailOptions, (err, info) => {
- if(err) {
- log.error(err);
- res.json({msg: 'Undelivered Reset Password Mail'});
- }
- log.info(`Message ${info.messageId} sent: ${info.response}`);
- res.json({msg: 'Reset Password Mail Successfully Delivered'});
- });
- })
+ let url = config.default.lde.url + '/reset-password';
+ let text = `Olá, ${user.name}.\n\nRecebemos uma solicitação para redefinir sua senha do Laboratório de Dados Educacionais. Clique neste link para redefinir a sua senha: ${url}/${tokenValue}`;
+ let mailOptions = {
+ to: `"${user.name} <${user.email}>"`,
+ subject: "Redefinição de Senha - Laboratório de Dados Educacionais",
+ text
}
- })
-})
+ console.log(mailOptions);
+ email(mailOptions, (err, info) => {
+ if (err) {
+ console.log(err);
+ log.error(err);
+ res.json({ msg: 'Undelivered Reset Password Mail' });
+ }
+ log.info(`Message ${info.messageId} sent: ${info.response}`);
+ res.json({ msg: 'Reset Password Mail Successfully Delivered' });
+ });
+ }
+});
module.exports = userApp;
diff --git a/src/libs/routes_v1/verifyToken.js b/src/libs/routes_v1/verifyToken.js
index d54f64aa162c767c765784398dbcab455a9d666e..81731fe3809df11cd7cb69d04c430642c58cc54c 100644
--- a/src/libs/routes_v1/verifyToken.js
+++ b/src/libs/routes_v1/verifyToken.js
@@ -10,43 +10,45 @@ const VerificationToken = require(`${libs}/models/verificationToken`);
const User = require(`${libs}/models/user`);
-verifyTokenApp.get('/:token', (req, res, next) => {
+verifyTokenApp.get('/:token', async (req, res, next) => {
let token = req.params.token;
- VerificationToken.findOne({token: token}, (err, vToken) => {
- if(err) {
+ let vToken = await VerificationToken.findOne({ where: { token: token } }).catch(function (err) {
+ if (err) {
log.error(err);
- return next(err);
+ return next({ err });
}
- if(!vToken) {
- // TODO: generate new verification token
- res.statusCode = 404;
- return next({msg: 'Token not found', status:404});
+ })
+ if (!vToken) {
+ // TODO: generate new verification token
+ res.statusCode = 404;
+ return next({ msg: 'Token not found', status: 404 });
+ }
+ let _user = await User.findByPk(vToken.user_id).catch(function (err) {
+ if (err) {
+ log.error(err);
+ return next({ err });
+ }
+ })
+ if(!_user){
+ return done(null, false);
+ }
+ await _user.update({verified:true});
+ await _user.save().catch(err => {
+ if (err) {
+ log.error(err);
+ return next({ message: 'Erro ao atualizar usuário' });
+ }})
+ vToken.verified = true;
+ await vToken.save().catch(err => {
+ if (err) {
+ log.error(err);
+ next(err);
}
- User.findById(vToken.userId, (err, user) => {
- if(err) {
- log.error(err);
- next(err);
- }
- user.verified = true;
- user.save((err) => {
- if(err) {
- log.error(err);
- next(err);
- }
- });
- let u = user.toObject();
- delete u.salt;
- delete u.hashedPassword;
- vToken.verified = true;
- vToken.save((err) => {
- if(err) {
- log.error(err);
- next(err);
- }
- });
- res.json({msg: 'User verified', user: u});
- });
});
+ let u = _user.toJSON();
+ delete u['salt'];
+ delete u['hashed_password'];
+ res.json({ msg: 'User verified', u });
});
module.exports = verifyTokenApp;
diff --git a/src/libs/routes_v2/resetToken.js b/src/libs/routes_v2/resetToken.js
index 34ece8455adf7b77208dc200a95641ed04638609..3d67a1e2390dcd206f248fa3af59bda16e2fcbb6 100644
--- a/src/libs/routes_v2/resetToken.js
+++ b/src/libs/routes_v2/resetToken.js
@@ -32,7 +32,7 @@ resetTokenApp.get('/:token', (req, res, next) => {
})
return next({msg: 'Token expired', status: 410});
}
- User.findById(rToken.userId, (err, user) => {
+ User.findByPk(rToken.userId, (err, user) => {
if(err) {
log.error(err);
next(err);
@@ -55,7 +55,7 @@ resetTokenApp.post('/:token', (req, res, next) => {
res.statusCode = 404;
return next({msg: 'Token not found', status:404});
}
- User.findById(rToken.userId, (err, user) => {
+ User.findByPk(rToken.userId, (err, user) => {
if(err) {
log.error(err);
next(err);
diff --git a/src/libs/routes_v2/user.js b/src/libs/routes_v2/user.js
index 7ff088eea62f34ffd3b66de4a28ae42807a97e8d..a2ab63a5dd0c8c24bf3d18dbc39a9e0b3e739b72 100644
--- a/src/libs/routes_v2/user.js
+++ b/src/libs/routes_v2/user.js
@@ -100,7 +100,7 @@ userApp.get('/me', passport.authenticate('bearer', { session: false }), (req, re
}, response('user'));
userApp.get('/:id', (req, res, next) => {
- User.findById(req.params.id, (err, user) => {
+ User.findOne({id:req.params.id}, (err, user) => {
if(err) {
log.error(err);
return next(err);
@@ -195,7 +195,7 @@ userApp.post('/', (req, res, next) => {
});
userApp.put('/:id', passport.authenticate('bearer', { session: false }), (req, res, next) => {
- User.findById(req.params.id, (err, user) => {
+ User.findOne({id:req.params.id}, (err, user) => {
if (err) {
log.error(err);
return next({err});
diff --git a/src/libs/routes_v2/verifyToken.js b/src/libs/routes_v2/verifyToken.js
index d54f64aa162c767c765784398dbcab455a9d666e..8978cd4bb84d75b48a060799a1ab846aa627180a 100644
--- a/src/libs/routes_v2/verifyToken.js
+++ b/src/libs/routes_v2/verifyToken.js
@@ -22,7 +22,7 @@ verifyTokenApp.get('/:token', (req, res, next) => {
res.statusCode = 404;
return next({msg: 'Token not found', status:404});
}
- User.findById(vToken.userId, (err, user) => {
+ User.findOne({id:vToken.userId}, (err, user) => {
if(err) {
log.error(err);
next(err);