arnaucube/socketioMEANseed
1
0
Fork 0
mirror of https://github.com/arnaucube/socketioMEANseed.git synced 2026-02-07 19:56:46 +01:00
Code Issues Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
arnaucode
2017-02-03 08:56:51 +01:00
parent c4b7414770
commit 112745d6fa
1585 changed files with 450241 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

109
server/controllers/adminController.js Normal file
View File

@@ -0,0 +1,109 @@
var express = require('express');
var app = express();
var jwt = require('jsonwebtoken');
var config = require('../config/config');
var crypto = require('crypto');
app.set('superSecret', config.secret);
/*******MODELS*********/
//var trainerModel = require('../models/trainerModel');
var userModel = require('../models/userModel');
var dietModel = require('../models/dietModel');
var routineModel = require('../models/routineModel');
/** GET '/admin/users/' **/
exports.getUsers = function (req, res) {
userModel.find()
.limit(Number(req.query.pageSize))
.skip(Number(req.query.pageSize) * Number(req.query.page))
.exec(function (err, users) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(users);
});
};
/** GET '/admin/users/:userid' **/
exports.getUserById = function (req, res) {
userModel.findOne({_id: req.params.userid})
.lean()
.populate('followers', 'name avatar')
.populate('following', 'name avatar')
.exec(function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'User not found.'});
} else if (user) {
var nodes=[];
var edges=[];
var node={
title: user.name,
label: user.name,
image: user.avatar,
shape: "image",
id: user._id
};
nodes.push(node);
for(var i=0; i<user.followers.length; i++)
{
var node={
title: user.followers[i].name,
label: user.followers[i].name,
image: user.followers[i].avatar,
shape: "image",
id: user.followers[i]._id
};
nodes.push(node);
var edge={
from: user._id,
to: user.followers[i]._id,
arrows: {
from: user._id
},
color: {
color: "#36bc9b"
}
};
edges.push(edge);
}
for(var i=0; i<user.following.length; i++)
{
var indexJ=-1
for(var j=0; j<nodes.length; j++)
{
if(nodes[j].id.equals(user.following[i]._id))
{
indexJ=JSON.parse(JSON.stringify(j));
}
}
if(indexJ==-1)
{//el node no estava als followers, afegim el node
var node={
title: user.following[i].name,
label: user.following[i].name,
image: user.following[i].avatar,
shape: "image",
id: user.following[i]._id
};
nodes.push(node);
}
var edge={
from: user._id,
to: user.following[i]._id,
arrows: {
to: user.following[i]._id
},
color: {
color: "#4876b4"
}
};
edges.push(edge);
}
res.status(200).jsonp({
nodes: nodes,
edges: edges
});
}
});
};

125
server/controllers/chefController.js Normal file
View File

@@ -0,0 +1,125 @@
var express = require('express');
var app = express();
var jwt = require('jsonwebtoken');
var config = require('../config/config');
var crypto = require('crypto');
app.set('superSecret', config.secret);
/*******MODELS*********/
//var chefModel = require('../models/chefModel');
var userModel = require('../models/userModel');
var dietModel = require('../models/dietModel');
/**GET '/chefs' **/
exports.getChefs = function (req, res) {
userModel.find({role: 'chef'})
.limit(Number(req.query.pageSize))
.skip(Number(req.query.pageSize)*Number(req.query.page))
.exec(function (err, chefs) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(chefs);
});
};
/** GET '/chefs/:chefid' **/
exports.getChefById = function (req, res) {
userModel.findOne({_id: req.params.chefid})
.lean()
.populate('diets', 'title description')
.exec(function (err, chef) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(chef);
});
};
/** PUT '/chefs/:chefid' **/
exports.updateChefById = function (req, res) {
var id = req.params.chefid;
var chef = req.body;
userModel.update({"_id": id}, chef,
function (err) {
if (err) return console.log(err);
console.log(chef);
res.status(200).jsonp(chef);
});
};
/** DELETE '/chefs/:chefid' **/
exports.deleteChefById = function (req, res) {
userModel.findByIdAndRemove({_id: req.params.chefid}, function (err) {
if (err) return res.send(500, err.message);
res.status(200).send("Chef deleted");
});
};
/** POST '/chefs/register' **/
exports.register = function (req, res) {
var chef = new userModel({
name: req.body.name,
password: crypto.createHash('sha256').update(req.body.password).digest('base64'),
email: req.body.email,
role: req.body.role
});
chef.save(function (err, chef) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(chef);
});
};
/** POST '/chefs/login' **/
exports.login = function (req, res) {
userModel.findOne({
email: req.body.email
})
.select('+password')
.exec(function (err, chef) {
if (err) throw err;
if (!chef) {
res.json({success: false, message: 'Authentication failed. chef not found.'});
} else if (chef) {
req.body.password = crypto.createHash('sha256').update(req.body.password).digest('base64');
if (chef.password != req.body.password) {
res.json({success: false, message: 'Authentication failed. Wrong password.'});
} else {
var indexToken = -1;
for (var i = 0; i < chef.tokens.length; i++) {
if (chef.tokens[i].userAgent == req.body.userAgent) {
indexToken = JSON.parse(JSON.stringify(i));
}
}
console.log(indexToken);
if (indexToken == -1) {//userAgent no exist
var tokenGenerated = jwt.sign({foo: 'bar'}, app.get('superSecret'), {
// expiresIn: 86400 // expires in 24 hours
});
var newToken = {
userAgent: req.body.userAgent,
token: tokenGenerated
};
chef.tokens.push(newToken);
} else {//userAgent already exist
chef.tokens[indexToken].token = "";
var tokenGenerated = jwt.sign({foo: 'bar'}, app.get('superSecret'), {
// expiresIn: 86400 // expires in 24 hours
});
chef.tokens[indexToken].token = tokenGenerated;
}
chef.save(function (err, chef) {
if (err) return res.send(500, err.message);
// return the information including token as JSON
chef.password = "";
res.json({
user: chef,
success: true,
message: 'Enjoy your token!',
token: tokenGenerated
});
});
}
}
});
};

42
server/controllers/contactController.js Normal file
View File

@@ -0,0 +1,42 @@
var express = require('express');
var app = express();
var config = require('../config/config');
/*******MODELS*********/
var contactModel = require('../models/contactModel');
/** GET '/contacts/' **/
exports.getContacts = function (req, res) {
contactModel.find()
.limit(Number(req.query.pageSize))
.skip(Number(req.query.pageSize) * Number(req.query.page))
.exec(function (err, contacts) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(contacts);
});
};
/** GET '/contacts/:contactsid' **/
exports.getContactById = function (req, res) {
contactModel.findOne({_id: req.params.contactid})
.exec(function (err, contact) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(contact);
});
};
/**POST '/contact' **/
exports.createContact = function (req, res) {
var contact = new contactModel({
name: req.body.name,
subject: req.body.subject,
email: req.body.email,
description: req.body.description
});
contact.save(function (err, contact) {
if (err) {
console.log(err.message);
return res.status(500).send(err.message);
}
res.status(200).jsonp(contact);
});
};

202
server/controllers/conversationController.js Normal file
View File

@@ -0,0 +1,202 @@
var express = require('express');
var app = express();
var conversationModel = require('../models/conversationModel');
var userModel = require('../models/userModel');
//var trainerModel = require('../models/trainerModel');
var crypto = require('crypto');
exports.getUserConversations = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']})
.lean()
.populate({//això és per fer deep population
path: 'conversations',
populate: {
path: 'userA userB',
model: 'userModel',
select: 'name avatar'
}
})
.populate({//això és per fer deep population
path: 'conversations',
populate: {
path: 'messages.user',
model: 'userModel',
select: 'name avatar'
}
})
.exec(function (err, user) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(user.conversations);
});
};
/**POST '/conversations' **/
exports.createConversation = function (req, res) {//req.body.userB
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, userA) {
if (err) return res.send(500, err.message);
if (!userA) {
res.json({success: false, message: 'userA not found.'});
} else if (userA) {
//aquí ja hem agafat el userA a partir del seu token
userModel.findOne({_id: req.body.userB}, function (err, userB) {//busquem l'userB
if (err) return res.send(500, err.message);
if (!userB) {
res.json({success: false, message: 'userB not found.'});
} else if (userB) {
conversationModel.findOne({$or:[{userA: userA._id, userB: userB._id},{userA: userB._id, userB: userA._id}]}, function (err, conversation) {
if (err) return res.send(500, err.message);
if (!conversation) {
console.log("conversation no exists, create new one");
var conversation = new conversationModel({
userA: userA._id,
userB: userB._id,
modifiedDate: Date()
});
conversation.save(function (err, conversation) {
if (err) return res.send(500, err.message);
userA.conversations.push(conversation._id);
userA.save(function (err) {
if (err) return res.send(500, err.message);
userB.conversations.push(conversation._id);
userB.save(function (err) {
if (err) return res.send(500, err.message);
userModel.findOne({'tokens.token': req.headers['x-access-token']})
.lean()
.populate({//això és per fer deep population
path: 'conversations',
populate: {
path: 'userA userB',
model: 'userModel',
select: 'name avatar'
}
})
.populate({//això és per fer deep population
path: 'conversations',
populate: {
path: 'messages.user',
model: 'userModel',
select: 'name avatar'
}
})
.exec(function (err, user) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(user.conversations);
});
});
});
});
} else if (conversation) {
console.log("conversation exists");
userModel.findOne({'tokens.token': req.headers['x-access-token']})
.lean()
.populate({//això és per fer deep population
path: 'conversations',
populate: {
path: 'userA userB',
model: 'userModel',
select: 'name avatar'
}
})
.populate({//això és per fer deep population
path: 'conversations',
populate: {
path: 'messages.user',
model: 'userModel',
select: 'name avatar'
}
})
.exec(function (err, user) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(user.conversations);
});
}
});//end of conversation find
}//end else if (userB)
});//end of userB find
}//end else if (userA)
});//end of userA find
};
/**POST '/conversations/:conversationid' **/
exports.addMessageToConversation = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, userSender) {
if (err) return res.send(500, err.message);
if (!userSender) {
res.json({success: false, message: 'userSender not found.'});
} else if (userSender) {
//aquí ja hem agafat el userSender a partir del seu token
conversationModel.findOne({_id: req.params.conversationid}, function (err, conversation) {
if (err) return res.send(500, err.message);
if (!conversation) {
res.json({success: false, message: 'conversation not found.'});
} else if (conversation) {
var newmessage = {
user: userSender._id,
content: req.body.message,
date: Date()
};
conversation.messages.push(newmessage);
conversation.modifiedDate=Date();
conversation.save(function (err, conversation) {
if (err) return res.send(500, err.message);
//ara cal saber qui és l'userReciever (el que no ha enviat el missatge)
var idUserReciever;
if(userSender._id.equals(conversation.userA)==false){
idUserReciever=conversation.userA;
}else if(userSender._id.equals(conversation.userB)==false){
idUserReciever=conversation.userB;
}
userModel.findOne({_id: idUserReciever}, function (err, userReciever) {//busquem l'userReciever
if (err) return res.send(500, err.message);
if (!userReciever) {
res.json({success: false, message: 'userReciever not found.'});
} else if (userReciever) {
console.log("reciever: " + userReciever.name);
/*notification*/
var notification = {
state: "pendent",
message: userSender.name + " sent a message to you",
link: "messages",
icon: "message.png",
date: Date()
};
userReciever.notifications.push(notification);
/* end of notification*/
userReciever.save(function (err) {
if (err) return res.send(500, err.message);
userModel.findOne({'tokens.token': req.headers['x-access-token']})
.lean()
.populate({//això és per fer deep population
path: 'conversations',
populate: {
path: 'userA userB',
model: 'userModel',
select: 'name avatar'
}
})
.populate({//això és per fer deep population
path: 'conversations',
populate: {
path: 'messages.user',
model: 'userModel',
select: 'name avatar'
}
})
.exec(function (err, user) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(user.conversations);
});
});
}//end else if (userReciever)
});//end userReciever find
});
}//end else if (conversation)
});//end of conversation find
}//end else if (userSender)
});//end of userSender find
};

251
server/controllers/dietController.js Normal file
View File

@@ -0,0 +1,251 @@
var express = require('express');
var app = express();
var config = require('../config/config');
var crypto = require('crypto');
app.set('superSecret', config.secret);
var userModel = require('../models/userModel');
var dietModel = require('../models/dietModel');
//var chefModel = require('../models/chefModel');
/** GET '/diets' ***/
exports.getDiets = function (req, res) {
dietModel.find()
.limit(Number(req.query.pageSize))
.skip(Number(req.query.pageSize)*Number(req.query.page))
.exec(function (err, diets) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(diets);
});
};
/** GET '/diets/:dietid' **/
exports.getDietById = function (req, res) {
dietModel.findOne({_id: req.params.dietid})
.lean()
.populate('chef', 'name avatar')
.exec(function (err, diet) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(diet);
});
};
/**DELETE '/diets/:dietid' **/
exports.deleteDietById = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token'], role:'chef'}, function (err, chef) {
if (err) return res.send(500, err.message);
if (!chef) {
res.json({success: false, message: 'Chef not found.'});
} else if (chef) {
for (var i = 0; i < chef.diets.length; i++) {
if (chef.diets[i].equals(req.params.dietid)) {
chef.diets.splice(i, 1);
chef.save(function (err, chef) {//guardem el chef amb la dieta treta
if (err) return res.send(500, err.message);
dietModel.findByIdAndRemove({_id: req.params.dietid}, function (err) {
if (err !== null) return res.send(500, err.message);
res.status(200).jsonp('Deleted diet');
});
});
}
}
}
});
};
/** PUT '/diets/:dietid' **/
exports.updateDietById = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token'], role:'chef'}, function (err, chef) {
if (err) return res.send(500, err.message);
if (!chef) {
res.json({success: false, message: 'Chef not found.'});
} else if (chef) {
for (var i = 0; i < chef.diets.length; i++) {
if (chef.diets[i].equals(req.params.dietid)) {
chef.diets.splice(i, 1); //<-- splice? quan s'està fent un update? no s'hauria d'eliminar
//tot i que no afecta, pq l'splice aquest després no es guarda a la base de dades pq no hi ha cap chef.save
/* Solo si esa dieta ha sido creada por el chef */
var id = req.params.dietid;
var diet = req.body;
dietModel.update({"_id": id}, diet,
function (err) {
if (err) return console.log(err);
console.log(diet);
res.status(200).jsonp(diet);
});
}
}
}
});
};
/**POST '/diets' **/
exports.createDiet = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token'], role:'chef'}, function (err, chef) {
if (err) return res.send(500, err.message);
if (!chef) {
res.json({success: false, message: 'Diet creation failed. Chef not found.'});
} else if (chef) {
var diet = new dietModel({
title: req.body.title,
description: req.body.description,
chef: chef._id,//a partir del token, pillem la id
client: req.params.clientid//es guarda de quin user és la diet
});
//guardem la diet
diet.save(function (err, diet) {
if (err) {
console.log(err.message);
return res.status(500).send(err.message);
}
//ara guardem la dietid al chef
chef.diets.push(diet._id);
chef.save(function (err, chef) {
if (err) return res.send(500, err.message);
});
res.status(200).jsonp(diet);
});
}//else
});
};
/** POST '/diets/:dietid/days' **/
exports.addDayToDiet = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token'], role:'chef'}, function (err, chef) {
if (err) return res.send(500, err.message);
if (!chef) {
res.json({success: false, message: 'Diet day addition failed. Trainer not found.'});
} else if (chef) {
dietModel.findOne({_id: req.params.dietid}, function (err, diet) {
if (err) return res.send(500, err.message);
if (chef._id.equals(diet.chef)) {// si el chef que fa el post realment és el chef creator de la diet
diet.days.push(req.body.day);
diet.save(function (err, diet) {
if (err) {
return res.status(500).send(err.message);
}
res.status(200).jsonp(diet);
});
}
});
}// end else if
});
};
/** POST '/diets/choose' **/
exports.chooseDiet = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'choosing diet failed. user not found.'});
} else if (user) {
user.diets.push(req.params.dietid);
/* gamification */
var reward = {
concept: "choosing diet",
date: Date(),
value: +5
};
user.points.history.push(reward);
user.points.total = user.points.total + 5;
/* end of gamification */
user.save(function (err) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(user);
})
}//end else if
});
};
/** DELETE '/diets/choose' **/
exports.unchooseDiet = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'user not found.'});
} else if (user) {
for (var i = 0; i < user.diets.length; i++) {
if (user.diets[i].equals(req.params.dietid)) {//deletes the diets of the user with the dietid
user.diets.splice(i, 1);
}
}
/* gamification */
var reward = {
concept: "unchoosing diet",
date: Date(),
value: -7
};
user.points.history.push(reward);
user.points.total = user.points.total - 7;
/* end of gamification */
user.save(function (err) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(user);
});
}//end else if
});
};
/** POST '/diets/completeDay/:dietid' **/
exports.completeDayGamificatedDiet = function (req, res) {
//1r intentamos darle los puntos al usuario por haber completado el día
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, user) {
if (err)
return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'choosing diet failed. user not found.'});
}
else if (user) {
/* gamification */
var reward =
{
concept: "diet day complete",
date: Date(),
value: +1
};
user.points.history.push(reward);
user.points.total = user.points.total + 1;
/* end of gamification */
user.save(function (err) {
if (err)
return res.send(500, err.message);
});
//Ahora intentamos añadir done = true dentro del modelo dieta
dietModel.findOne({'_id': req.params.dietid}, function (err, diet) {
if (err)
return res.send(500, err.message);
if (!diet) {
res.json({success: false, message: 'Diet not found'});
}
else if (diet) {
var indexDay = -1;
for (var i = 0; i < diet.days.length; i++) //diet.days
{
if (diet.days[i]._id.equals(req.body.dayid)) {
//aquí hem trobat el dia que busquem
indexDay = JSON.parse(JSON.stringify(i));
}
}//End for looking for days
if (indexDay > -1) {
/* True to day done*/
diet.days[indexDay].done = true;
/* end of done*/
diet.save(function (err) {
if (err)
return res.send(500, err.message);
res.status(200).jsonp(diet);
});//diet.save
}//End if when day foung
else {
res.json({success: false, message: 'Day not found'});
}
}//End else if found diet
});//En dietModel for done = true
}//End else if (user)
});//En UserModel findOne()
};//End function

269
server/controllers/publicationController.js Normal file
View File

@@ -0,0 +1,269 @@
var express = require('express');
var app = express();
var publicationModel = require('../models/publicationModel');
var userModel = require('../models/userModel');
//var trainerModel = require('../models/trainerModel');
var crypto = require('crypto');
/**GET '/publications' **/
exports.getAllPublications = function (req, res) {
publicationModel.find()
.limit(Number(req.query.pageSize))
.skip(Number(req.query.pageSize)*Number(req.query.page))
.lean()
.populate('user', 'name avatar')
.exec(function (err, publications) {
if (err) return res.send(500, err.message);
if (!publications) {
//
} else if (publications) {
res.status(200).jsonp(publications);
}
});
};
/** GET '/publications/getById/:publicationid' **/
exports.getPublicationById = function (req, res) {
publicationModel.findOne({_id: req.params.publicationid})
.lean()
.populate('likes', 'name avatar')
.exec(function (err, publication) {
if (err) return res.send(500, err.message);
if (!publication) {
res.json({success: false, message: 'publication not found.'});
} else if (publication) {
res.status(200).jsonp(publication);
}
});
};
/**POST '/publications' **/
exports.postPublication = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'user not found.'});
} else if (user) {
//aquí ja hem agafat el user a partir del seu token
var publication = new publicationModel({
title: req.body.title,
content: req.body.content,
date: new Date(),
user: user._id,
photo: req.body.photo
});
//fins aquí tenim la variable publication amb els continguts
//ara cal 1r guardar el model publication a la base de dades
publication.save(function (err, publication) {
if (err) return res.send(500, err.message);
//i 2n, afegir la id de la publicació generada al user.publications
user.publications.push(publication._id);
/* gamification */
var reward = {
concept: "added new publication to Timeline",
date: Date(),
value: +1
};
user.points.history.push(reward);
user.points.total = user.points.total + 1;
/* end of gamification */
user.save(function (err, user) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(user);
});
});
}//end else if
});
};
/**GET '/users/:userid/publications' **/
exports.getUserPublicationsByUserId = function (req, res) {
userModel.findOne({_id: req.params.userid}, function (err, user) {
if (err) return res.send(500, err.message);
}).populate('publications')
.exec(function (error, user) {
if (error !== null) res.send(500, error.message);
console.log(JSON.stringify(user, null, "\t"));
res.status(200).jsonp(user.publications);
});
};
/**DELETE '/publications/:publicationid' **/
exports.deletePublicationById = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'user not found.'});
} else if (user) {
for (var i = 0; i < user.publications.length; i++) {
if (user.publications[i].equals(req.params.publicationid)) {//només si el user és qui ha fet la publication la pot esborrar
user.publications.splice(i, 1);
user.save(function (err, user) {//guardem l'user
if (err) return res.send(500, err.message);
publicationModel.findByIdAndRemove({_id: req.params.publicationid}, function (err) {
if (err !== null) return res.send(500, err.message);
res.status(200).jsonp('Deleted');
});
});
}
}
}
});
};
/** POST '/publications/:publicationid/like' **/
exports.likePublication = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'user not found.'});
} else if (user) {
console.log(user.name);
//ara busquem el userB
publicationModel.findOne({_id: req.params.publicationid}, function (err, publication) {
if (err) return res.send(500, err.message);
if (!publication) {
res.json({success: false, message: 'publication not found.'});
} else if (publication) {
// for(var i=0; i<userB.timeline)
publication.likes.push(user._id);
publication.save(function (err, publication) {
if (err) return res.send(500, err.message);
/* gamification */
var reward = {
concept: "liked publication " + publication.title,
date: Date(),
value: +1
};
user.points.history.push(reward);
user.points.total = user.points.total + 1;
/* end of gamification */
user.save(function (err, user) {
if (err) return res.send(500, err.message);
//ara busquem el user que ha fet la publication que ha rebut el like
userModel.findOne({_id: publication.user})
.exec(function (err, userB) {
/*notification*/
var notification = {
state: "pendent",
message: "user clicked like",
link: "user/"+userB._id,
icon: "newlike.png",
date: Date()
};
userB.notifications.push(notification);
/* end of notification*/
userB.save(function (err, user) {
if (err) return res.send(500, err.message);
publicationModel.findOne({_id: req.params.publicationid})
.lean()
.populate('user', 'name avatar')
.exec(function (err, publication) {
if (err) return res.send(500, err.message);
if (!publication) {
//
} else if (publication) {
res.status(200).jsonp(publication);
}
});
});
});
});
});
}//end else if
});
}//end else if
});
};
/** POST '/publications/:publicationid/dislike' **/
exports.dislikePublication = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'user not found.'});
} else if (user) {
console.log(user.name);
//ara busquem el userB
publicationModel.findOne({_id: req.params.publicationid}, function (err, publication) {
if (err) return res.send(500, err.message);
if (!publication) {
res.json({success: false, message: 'publication not found.'});
} else if (publication) {
for (var i = 0; i < publication.likes.length; i++) {
if (publication.likes[i].equals(user._id)) {
publication.likes.splice(i, 1);
}
}
publication.save(function (err, publication) {
if (err) return res.send(500, err.message);
/* gamification */
var reward = {
concept: "disliked publication " + publication.title,
date: Date(),
value: -1
};
user.points.history.push(reward);
user.points.total = user.points.total - 1;
/* end of gamification */
user.save(function (err, user) {
if (err) return res.send(500, err.message);
publicationModel.findOne({_id: req.params.publicationid})
.lean()
.populate('user', 'name avatar')
.exec(function (err, publication) {
if (err) return res.send(500, err.message);
if (!publication) {
//
} else if (publication) {
res.status(200).jsonp(publication);
}
});
});
});
}//end else if
});
}//end else if
});
};
/** GET '/publications/newsfeed' **/
var ObjectId = require('mongodb').ObjectID;
exports.getNewsFeed = function (req, res) {//getPublicationsFromFollowingUsers
//primer agafem l'user que fa la petició, per saber quins users està seguint
var newsfeed = [];
userModel.findOne({'tokens.token': req.headers['x-access-token']})
.exec(function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'getting newsfeed failed. user not found.'});
} else if (user) {
console.log("getting newsfeed for user: " + user.name);
var following = [];
for (var i = 0; i < user.following.length; i++) {//això ho fem perquè necessitem la array amb el contingut en format objectid
following.push(new ObjectId(user.following[i]));
}
following.push(new ObjectId(user._id));//així també reb les seves pròpies publicacions
publicationModel.find({user: {$in: following}})
.lean()
.populate('user', 'name avatar')
.exec(function (err, publications) {
if (err) return res.send(500, err.message);
if (!publications) {
//
} else if (publications) {
res.status(200).jsonp(publications);
}
});
}
});
};

303
server/controllers/routineController.js Normal file
View File

@@ -0,0 +1,303 @@
var express = require('express');
var app = express();
var config = require('../config/config');
var crypto = require('crypto');
app.set('superSecret', config.secret);
var userModel = require('../models/userModel');
var routineModel = require('../models/routineModel');
//var trainerModel = require('../models/trainerModel');
/** GET '/routines/' **/
exports.getRoutines = function (req, res) {
routineModel.find()
.limit(Number(req.query.pageSize))
.skip(Number(req.query.pageSize)*Number(req.query.page))
.exec(function (err, routines) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(routines);
});
};
/** GET '/routines/:routineid' **/
exports.getRoutineById = function (req, res) {
routineModel.findOne({_id: req.params.routineid})
.lean()
.populate('trainer', 'name avatar')
.populate('client', 'name avatar points.total')
.exec(function (err, routine) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(routine);
});
};
/** DELETE '/routines/:routineid' **/
exports.deleteRoutineById = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token'], role:'trainer'}, function (err, trainer) {
if (err) return res.send(500, err.message);
if (!trainer) {
res.json({success: false, message: 'Trainer not found.'});
} else if (trainer) {
for (var i = 0; i < trainer.routines.length; i++) {
if (trainer.routines[i].equals(req.params.routineid)) {//Solo si esa routine ha sido creada por el trainer
trainer.routines.splice(i, 1);
//també s'hauria de treure la referència al user que és client d'aquesta routine
trainer.save(function (err, trainer) {//guardem el trainer amb la rutina treta
if (err) return res.send(500, err.message);
routineModel.findByIdAndRemove({_id: req.params.routineid}, function (err) {//elminem la routine
if (err !== null) return res.send(500, err.message);
res.status(200).jsonp('Deleted routine');
});
});
}
}
}
});
};
/** PUT '/routines/:routineid' **/
exports.updateRoutineById = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token'], role:'trainer'}, function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'Trainer not found.'});
} else if (user) {
for (var i = 0; i < user.routines.length; i++) {
if (user.routines[i].equals(req.params.routineid)) {
user.routines.splice(i, 1);// <-- perquè es fa l'splice de user.routines si després no es guarda el user??
/* Solo si esa routine ha sido creada por el trainer */
var id = req.params.routineid;
var routine = req.body;
routineModel.update({"_id": id}, routine,
function (err) {
if (err) return console.log(err);
console.log(routine);
res.status(200).jsonp(routine);
});
}
}
}
});
};
/** POST '/routines/addToClient/:clientid' **/
exports.addRoutineToClient = function (req, res) {
userModel.findOne({
'tokens.token': req.headers['x-access-token'],
'clients.client': req.params.clientid,
'role': 'trainer'
}, function (err, trainer) {
if (err) return res.send(500, err.message);
if (!trainer) {
res.json({success: false, message: 'Routine creation failed. Trainer not found.'});
} else if (trainer) {
var routine = new routineModel({
title: req.body.title,
description: req.body.description,
trainer: trainer._id,//a partir del token, pillem la id
client: req.params.clientid//es guarda de quin user és la routine
});
//guardem la routine
routine.save(function (err, routine) {
if (err) {
console.log(err.message);
return res.status(500).send(err.message);
}
//ara guardem la routineid al trainer
trainer.routines.push(routine._id);
trainer.save(function (err, trainer) {
if (err) return res.send(500, err.message);
});
//res.status(200).jsonp(routine);
//ara afegim la routine al client
userModel.findOne({'_id': req.params.clientid}, function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'adding routine to client failed. user not found.'});
} else if (user) {
user.routines.push(routine._id);
/* gamification */
var reward = {
concept: "new routine",
date: Date(),
value: +5
};
user.points.history.push(reward);
user.points.total = user.points.total + 5;
/* end of gamification */
var notification = {
state: "pendent",
message: "trainer has added a routine to you",
link: "training",
icon: "newroutine.png",
date: Date()
};
user.notifications.push(notification);
user.save(function (err) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(routine);
});
}//end else if
});
});
}//else
});
};
/** POST '/routines/:routineid/days' **/
exports.addDayToRoutine = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, trainer) {
if (err) return res.send(500, err.message);
if (!trainer) {
res.json({success: false, message: 'Routine day addition failed. Trainer not found.'});
} else if (trainer) {
routineModel.findOne({_id: req.params.routineid}, function (err, routine) {
if (err) return res.send(500, err.message);
if (trainer._id.equals(routine.trainer)) {// si el trainer que fa el post realment és el trainer creator de la routine
routine.days.push(req.body.day);
routine.save(function (err, routine) {
if (err) {
return res.status(500).send(err.message);
}
routineModel.findOne({_id: routine._id})
.lean()
.populate('trainer', 'name avatar')
.populate('client', 'name avatar points.total')
.exec(function (err, routine) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(routine);
});
});
}
});
}// end else if
});
};
/** POST '/routines/choose' **/
exports.chooseRoutine = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'choosing routine failed. user not found.'});
} else if (user) {
console.log(user);//aquí potser caldria comprovar que la routine és la que han creat per l'user
user.routines.push(req.body.routineid);
/* gamification */
var reward = {
concept: "choosing routine",
date: Date(),
value: +5
};
user.points.history.push(reward);
user.points.total = user.points.total + 5;
/* end of gamification */
user.save(function (err) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(user);
});
}//end else if
});
};
/** DELETE '/routines/choose' **/
exports.unchooseRoutine = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'choosing routine failed. user not found.'});
} else if (user) {
for (var i = 0; i < user.routines.length; i++) {
if (user.routines[i] == req.body.routineid) {//deletes the diets of the user with the dietid
user.routines.splice(i, 1);
}
}
/* gamification */
var reward = {
concept: "unchoosing routine",
date: Date(),
value: -7
};
user.points.history.push(reward);
user.points.total = user.points.total - 7;
/* end of gamification */
user.save(function (err) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(user);
});
}//end else if
});
};
/** POST '/routines/completeDay/:routineid' **/
exports.completeDayGamificatedRoutine = function (req, res) {
//1r intentamos darle los puntos al usuario por haber completado el día
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, user) {
if (err)
return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'choosing routine failed. user not found.'});
}
else if (user) {
/* gamification */
var reward =
{
concept: "routine day complete",
date: Date(),
value: +1
};
user.points.history.push(reward);
user.points.total = user.points.total + 1;
/* end of gamification */
user.save(function (err) {
if (err)
return res.send(500, err.message);
});
//Ahora intentamos añadir done = true dentro del modelo rutina
routineModel.findOne({'_id': req.params.routineid}, function (err, routine) {
if (err)
return res.send(500, err.message);
if (!routine) {
res.json({success: false, message: 'Routine not found'});
}
else if (routine) {
var indexDay = -1;
for (var i = 0; i < routine.days.length; i++) //routine.days
{
if (routine.days[i]._id.equals(req.body.dayid)) {
//aquí hem trobat el dia que busquem
indexDay = JSON.parse(JSON.stringify(i));
}
}//End for looking for days
if (indexDay > -1) {
/* True to day done*/
routine.days[indexDay].done = true;
/* end of done*/
routine.save(function (err) {
if (err)
return res.send(500, err.message);
routineModel.findOne({_id: routine._id})
.lean()
.populate('trainer', 'name avatar')
.populate('client', 'name avatar points.total')
.exec(function (err, routine) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(routine);
});
});//Routine.save
}//End if when day foung
else {
res.json({success: false, message: 'Day not found'});
}
}//End else if found routine
});//En routineModel for done = true
}//End else if (user)
});//En UserModel findOne()
};//End function

107
server/controllers/runController.js Normal file
View File

@@ -0,0 +1,107 @@
var express = require('express');
var app = express();
var runModel = require('../models/runModel');
var publicationModel = require('../models/publicationModel');
var userModel = require('../models/userModel');
//var trainerModel = require('../models/trainerModel');
var crypto = require('crypto');
/**POST '/publications' **/
exports.postRun = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'user not found.'});
} else if (user) {
//aquí ja hem agafat el user a partir del seu token
var run = new runModel(req.body.newRun);
run.user=user._id;
//fins aquí tenim la variable publication amb els continguts
//ara cal 1r guardar el model publication a la base de dades
run.save(function (err, run) {
if (err) return res.send(500, err.message);
//i 2n, afegir la id de la publicació generada al user.publications
user.runs.push(run._id);
/* gamification */
var reward = {
concept: "added new run to user",
date: Date(),
value: +1
};
user.points.history.push(reward);
user.points.total = user.points.total + 1;
/* end of gamification */
user.save(function (err, user) {
if (err) return res.send(500, err.message);
//res.status(200).jsonp(user);
//ara farem una publicació ensenyant que ha fet aquest run
var publication = new publicationModel({
title: "new run '" + run.title + "'!",
content: "distance of: " + run.distance + ". View my runs at my profile",
date: new Date(),
user: user._id,
photo: run.photo
});
//fins aquí tenim la variable publication amb els continguts
//ara cal 1r guardar el model publication a la base de dades
publication.save(function (err, publication) {
if (err) return res.send(500, err.message);
//i 2n, afegir la id de la publicació generada al user.publications
user.publications.push(publication._id);
/* gamification */
var reward = {
concept: "added new publication to Timeline",
date: Date(),
value: +1
};
user.points.history.push(reward);
user.points.total = user.points.total + 1;
/* end of gamification */
if(!user.totalkm)
{
user.totalkm=0;
}
user.totalkm=user.totalkm + run.distance;
user.save(function (err, user) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(user);
});
});
});
});
}//end else if
});
};
/**GET '/users/:userid/publications' **/
exports.getRunsByUserId = function (req, res) {
userModel.findOne({
_id: req.params.userid
})
.populate('runs')
.exec(function (error, user) {
if (error !== null) res.send(500, error.message);
res.status(200).jsonp(user);
});
};
/** GET '/run/getById/:publicationid' **/
exports.getRunByRunId = function (req, res) {
runModel.findOne({_id: req.params.runid})
.lean()
.populate('user', 'name avatar')
.exec(function (err, run) {
if (err) return res.send(500, err.message);
if (!run) {
res.json({success: false, message: 'run not found.'});
} else if (run) {
res.status(200).jsonp(run);
}
});
};

433
server/controllers/trainerController.js Normal file
View File

@@ -0,0 +1,433 @@
var express = require('express');
var app = express();
var jwt = require('jsonwebtoken');
var config = require('../config/config');
var crypto = require('crypto');
app.set('superSecret', config.secret);
/*******MODELS*********/
//var trainerModel = require('../models/trainerModel');
var userModel = require('../models/userModel');
var dietModel = require('../models/dietModel');
var routineModel = require('../models/routineModel');
/** GET '/trainers' **/
exports.getTrainers = function (req, res) {
userModel.find({role: 'trainer'})
.limit(Number(req.query.pageSize))
.skip(Number(req.query.pageSize)*Number(req.query.page))
.exec(function (err, trainers) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(trainers);
});
};
exports.getTrainersByDisciplinesArray = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'sending petition failed. user not found.'});
} else if (user) {
if(user.disciplines[0])
{
userModel.find({
role: 'trainer',
$and: [
{_id: { $nin: user._id}},
{_id: { $nin: user.trainers}}
],
'disciplines.name': user.disciplines[0].name//per ara torna els trainers que tinguin la discipline[0] del user client
})
.limit(Number(req.query.pageSize))
.skip(Number(req.query.pageSize)*Number(req.query.page))
.exec(function (err, trainers) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(trainers);
});
}else{
userModel.find({
role: 'trainer',
$and: [
{_id: { $nin: user._id}},
{_id: { $nin: user.trainers}}
]
})
.limit(Number(req.query.pageSize))
.skip(Number(req.query.pageSize)*Number(req.query.page))
.exec(function (err, trainers) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(trainers);
});
}
}
});
};
/** GET '/trainers/:trainerid' **/
exports.getTrainerById = function (req, res) {
userModel.findOne({_id: req.params.trainerid, role: 'trainer'})
.lean()
.populate('routines', 'title description')
.populate('clients.client', 'name avatar points')
.populate('clientsPetitions.clientid', 'name avatar')
.exec(function (err, trainer) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(trainer);
});
};
/** GET '/trainers/searchByDiscipline' **/
exports.searchByDiscipline = function (req, res) {
userModel.find({'disciplines.name': req.params.discipline, role: 'trainer'})
.limit(Number(req.query.pageSize))
.skip(Number(req.query.pageSize)*Number(req.query.page))
.exec(function (err, trainers) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(trainers);
});
};
/** POST '/trainers/register' **/
exports.register = function (req, res) {
var trainer = new userModel({
name: req.body.name,
password: crypto.createHash('sha256').update(req.body.password).digest('base64'),
email: req.body.email,
avatar: 'img/user.png',
background: 'img/background.png',
role: req.body.role,
discipline: req.body.discipline,
points: {
total: 0
}
});
/* gamification */
var reward = {
concept: "account created",
date: Date(),
value: +1
};
trainer.points.history.push(reward);
trainer.points.total = trainer.points.total + 1;
/* end of gamification */
trainer.save(function (err, trainer) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(trainer);
});
};
/** POST '/trainers/login' **/
exports.login = function (req, res) {
userModel.findOne({
email: req.body.email, role: 'trainer'
})
.select('+password')
.exec(function (err, trainer) {
if (err) throw err;
if (!trainer) {
res.json({success: false, message: 'Authentication failed. trainer not found.'});
} else if (trainer) {
req.body.password = crypto.createHash('sha256').update(req.body.password).digest('base64');
if (trainer.password != req.body.password) {
res.json({success: false, message: 'Authentication failed. Wrong password.'});
} else {
var indexToken = -1;
for (var i = 0; i < trainer.tokens.length; i++) {
if (trainer.tokens[i].userAgent == req.body.userAgent) {
indexToken = JSON.parse(JSON.stringify(i));
}
}
console.log(indexToken);
if (indexToken == -1) {//userAgent no exist
var tokenGenerated = jwt.sign({foo: 'bar'}, app.get('superSecret'), {
// expiresIn: 86400 // expires in 24 hours
});
var newToken = {
userAgent: req.body.userAgent,
token: tokenGenerated,
os: req.body.os,
browser: req.body.browser,
device: req.body.device,
os_version: req.body.os_version,
browser_version: req.body.browser_version,
ip: req.body.ip,
lastLogin: Date()
};
trainer.tokens.push(newToken);
} else {//userAgent already exist
trainer.tokens[indexToken].token = "";
var tokenGenerated = jwt.sign({foo: 'bar'}, app.get('superSecret'), {
// expiresIn: 86400 // expires in 24 hours
});
trainer.tokens[indexToken].token = tokenGenerated;
trainer.tokens[indexToken].ip = req.body.ip;
trainer.tokens[indexToken].lastLogin = Date();
}
trainer.save(function (err, trainer) {
if (err) return res.send(500, err.message);
// return the information including token as JSON
trainer.password = "";
res.json({
user: trainer,
success: true,
message: 'Enjoy your token!',
token: tokenGenerated
});
});
}
}
});
};
/** POST '/trainers/acceptClientPetition' **/
exports.acceptClientPetition = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token'], role: 'trainer'}, function (err, trainer) {
if (err) return res.send(500, err.message);
if (!trainer) {
res.json({success: false, message: 'adding client to trainer failed. trainer not found.'});
} else if (trainer) {
console.log(trainer);//aquí potser caldria comprovar que la routine és la que han creat per l'trainer
//busquem la petition que estem processant
for (var i = 0; i < trainer.clientsPetitions.length; i++) //routine.days
{
if (trainer.clientsPetitions[i]._id.equals(req.body.petitionid)) {
var newClient = {
client: trainer.clientsPetitions[i].clientid,
petitionMessage: trainer.clientsPetitions[i].message,
date: Date()
};
trainer.clients.push(newClient);
//la petició la marco com a accepted
trainer.clientsPetitions[i].state = "accepted";
trainer.save(function (err) {
if (err) return res.send(500, err.message);
userModel.findOne({_id: trainer._id, role: 'trainer'})
.lean()
.populate('routines', 'title description')
.populate('clients.client', 'name avatar points')
.populate('clientsPetitions.clientid', 'name avatar')
.exec(function (err, trainer) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(trainer);
});
});
//ara afegim el trainer al user.trainer
userModel.findOne({'_id': trainer.clientsPetitions[i].clientid}, function (err, user) {
if (err) console.log(err.message);
if (!user) {
console.log('adding client to trainer failed. user not found.');
} else if (user) {
user.trainers.push(trainer._id);
/* gamification */
var reward = {
concept: "new trainer",
date: Date(),
value: +5
};
user.points.history.push(reward);
user.points.total = user.points.total + 5;
/* end of gamification */
var notification = {
state: "pendent",
message: "trainer has accepted to train you",
link: "training",
icon: "newtrainer.png",
date: Date()
};
user.notifications.push(notification);
user.save(function (err) {
if (err) console.log(err.message);
console.log("trainer added to user");
});
}
});
}
}
}//end else if
});
};
/** PUT '/trainers/:trainerid' **/
exports.updateTrainer = function (req, res) {
var trainer = req.body;
userModel.update({'tokens.token': req.headers['x-access-token']}, trainer,
function (err) {
if (err) return console.log(err);
console.log(trainer);
res.status(200).jsonp(trainer);
});
};
/** POST '/trainers/valorateTrainer/:trainerid' **/
exports.valorateTrainer = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'sending valoration failed. user not found.'});
} else if (user) {
//ara busquem el trainer
userModel.findOne({_id: req.params.trainerid, role: 'trainer'}, function (err, trainer) {
if (err) return res.send(500, err.message);
if (!trainer) {
res.json({success: false, message: 'sending valoration failed. trainer not found.'});
} else if (trainer) {
//comprovem que el client no hagi valorat ja el trainer
var javalorat = false;
var indexValoration=-1;
for (var i = 0; i < trainer.valorations.length; i++) {
if (trainer.valorations[i].clientid.equals(user._id)) {
javalorat = true;
indexValoration=JSON.parse(JSON.stringify(i));
}
}
if (javalorat == false) {
var valoration = {
clientid: user._id,
date: Date(),
message: req.body.message,
value: req.body.value
};
if(!trainer.valoration)
{
trainer.valoration=0;
}
var actual = (+trainer.valoration) * trainer.valorations.length;
var valor = ((+actual) + (+valoration.value)) / (trainer.valorations.length + 1);
trainer.valoration = valor;
trainer.valorations.push(valoration);
var notification = {
state: "pendent",
message: "client has valorated you",
link: "dashboard",
icon: "newvaloration.png",
date: Date()
};
trainer.notifications.push(notification);
trainer.save(function (err) {
if (err) return res.send(500, err.message);
//aquí la gamificació de l'user que fa la valoració per primer cop
/* gamification */
var reward = {
concept: "valorating trainer",
date: Date(),
value: +1
};
user.points.history.push(reward);
user.points.total = user.points.total + 1;
/* end of gamification */
user.save(function (err) {
/*if (err) return res.send(500, err.message);
res.status(200).jsonp(routine);*/
console.log("points of gamification on trainer valorating added to user");
});
userModel.findOne({_id: trainer._id})
.lean()
.populate('diets', 'title description')
.populate('routines', 'title description')
.populate('trainers', 'name avatar description')
.populate('clients.client', 'name avatar')
.populate('publications')
.exec(function (err, trainer) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(trainer);
});
});
} else {//end if javalorat==false
console.log("user already has valorated trainer, updating valoration and recalculating total");
var valoration = {
clientid: user._id,
date: Date(),
message: req.body.message,
value: req.body.value
};
var actual = ((+trainer.valoration) * (+trainer.valorations.length)) - (+trainer.valorations[indexValoration].value);//suma total valoracions sense la que estic canviant
var valor = ((+actual) + (+valoration.value)) / (trainer.valorations.length);
console.log(actual + ", " + valor);
trainer.valoration = valor;
trainer.valorations[indexValoration]=valoration;
var notification = {
state: "pendent",
message: "client has updated the valoration on you",
link: "dashboard",
icon: "newvaloration.png",
date: Date()
};
trainer.notifications.push(notification);
trainer.save(function (err) {
if (err) return res.send(500, err.message);
userModel.findOne({_id: trainer._id})
.lean()
.populate('diets', 'title description')
.populate('routines', 'title description')
.populate('trainers', 'name avatar description')
.populate('clients.client', 'name avatar')
.populate('publications')
.exec(function (err, trainer) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(trainer);
});
});
}
}//end else if
});
}//end else if
});
};
/** GET '/trainers/:trainerid/getNotifications' **/
exports.getNotifications = function (req, res) {
userModel.findOne({_id: req.params.trainerid, role: 'trainer'})
.exec(function (err, trainer) {
if (err) return res.send(500, err.message);
for (var i = 0; i < trainer.notifications.length; i++) {
if (trainer.notifications[i].state == "pendent") {
trainer.notifications[i].state = "viewed";
trainer.notifications[i].dateviewed = Date();
}
}
trainer.save(function (err) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(trainer.notifications);
});
});
};
/** GET '/trainers/searchByName/:trainername' **/
exports.searchByName = function (req, res) {
console.log("searchByName");
userModel.find({name: new RegExp(req.params.trainername, "i"), role: 'trainer'})
.limit(Number(req.query.pageSize))
.skip(Number(req.query.pageSize)*Number(req.query.page))
.exec(function (err, trainers) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(trainers);
});
};
/** DELETE '/trainers/:trainerid' **/
exports.removeTrainer = function (req, res) {/* AQUESTA FUNCIÖ CREC QUE ESTÂ MAL PLANTEJADA, DIRIA QUE NO FUNCIONA, si jo també ho diria no es pot trobar despres d'eliminar */
userModel.findByIdAndRemove({_id: req.params.trainerid}, function (err) {/**La he corregit, pero tenint en compte que tenim només un model ara potser es redundant no?**/
if (err) return res.send(500, err.message);
res.status(200).send("Trainer Deleted");
});
};

791
server/controllers/userController.js Normal file
View File

@@ -0,0 +1,791 @@
var express = require('express');
var app = express();
var router = express.Router();
var jwt = require('jsonwebtoken');
var config = require('../config/config');
var crypto = require('crypto');
var formidable = require('formidable');
var fs = require('fs');
var https = require('https');
app.set('superSecret', config.secret);
/*******MODELS*********/
var publicationModel = require('../models/publicationModel');
var userModel = require('../models/userModel');
var dietModel = require('../models/dietModel');
var routineModel = require('../models/routineModel');
/** POST '/users/register' **/
exports.register = function (req, res) {
console.log(req.body);
var user = new userModel({
name: req.body.name,
role: req.body.role,
password: crypto.createHash('sha256').update(req.body.password).digest('base64'),
email: req.body.email,
description: "Hi, i'm here to train.",
avatar: 'img/user.png',
background: 'img/background.png',
attributes: {
height: req.body.height,
weight: req.body.weight,
gender: req.body.gender,
age: req.body.age
},
points: {
total: 0
}
});
/* gamification */
var reward = {
concept: "account created",
date: Date(),
value: +1
};
user.points.history.push(reward);
user.points.total = user.points.total + 1;
/* end of gamification */
/*notification*/
var notification = {
state: "pendent",
message: "Wellcome! this is your profile, update the Profile picture to let other members recognize you",
link: "editUser/" + user._id,
icon: "newpetition.png",
date: Date()
};
user.notifications.push(notification);
/* end of notification*/
user.save(function (err, user) {
if (err) {
console.log(err.message);
return res.status(500).send(err.message);
}
//res.status(200).jsonp(user); en comptes de retoranr la data del signup, fem el login directament
console.log("signup fet correctament, redirigint al login internament automàtic");
exports.login(req, res);
});
};
var SECRET = "6LcyxhIUAAAAAPkCdz5HoBPN5--RhP7mpIE-V2CL";
function verifyRecaptcha(key, callback) {
https.get("https://www.google.com/recaptcha/api/siteverify?secret=" + SECRET + "&response=" + key, function(res) {
var data = "";
res.on('data', function (chunk) {
data += chunk.toString();
});
res.on('end', function() {
try {
var parsedData = JSON.parse(data);
callback(parsedData.success);
} catch (e) {
callback(false);
}
});
});
}
/** POST '/users/login' **/
exports.login = function (req, res) {
verifyRecaptcha(req.body["g-recaptcha-response"], function() {
userModel.findOne({
email: req.body.email
})
.select('+password')
.exec(function (err, user) {
if (err) throw err;
if (!user) {
res.json({success: false, message: 'Authentication failed. User not found.'});
} else if (user) {
req.body.password = crypto.createHash('sha256').update(req.body.password).digest('base64');
if (user.password != req.body.password) {
res.json({success: false, message: 'Authentication failed. Wrong password.'});
} else {
var indexToken = -1;
for (var i = 0; i < user.tokens.length; i++) {
if (user.tokens[i].userAgent == req.body.userAgent) {
indexToken = JSON.parse(JSON.stringify(i));//stringify i parse pq es faci una còpia de la variable i, enlloc de una referència
}
}
console.log(indexToken);
if (indexToken == -1) {//userAgent no exist
var tokenGenerated = jwt.sign({foo: 'bar'}, app.get('superSecret'), {
// expiresIn: 86400 // expires in 24 hours
});
var newToken = {
userAgent: req.body.userAgent,
token: tokenGenerated,
os: req.body.os,
browser: req.body.browser,
device: req.body.device,
os_version: req.body.os_version,
browser_version: req.body.browser_version,
ip: req.body.ip,
lastLogin: Date()
};
user.tokens.push(newToken);
} else {//userAgent already exist
user.tokens[indexToken].token = "";
var tokenGenerated = jwt.sign({foo: 'bar'}, app.get('superSecret'), {
// expiresIn: 86400 // expires in 24 hours
});
user.tokens[indexToken].token = tokenGenerated;
user.tokens[indexToken].ip = req.body.ip;
user.tokens[indexToken].lastLogin = Date();
}
user.save(function (err, user) {
if (err) return res.send(500, err.message);
// return the information including token as JSON
user.password = "";
res.json({
user: user,
success: true,
message: 'Enjoy your token!',
token: tokenGenerated
});
});
}
}
});
})};
/** POST '/logout' **/
exports.logout = function (req, res, callback) {
var token = req.headers.authorization;
var decoded = verify(token);
if (decoded) {
db.get(decoded.auth, function (err, record) {
if (err) throw err;
var updated = JSON.parse(record);
updated.valid = false;
db.put(decoded.auth, updated, function (err) {
if (err) throw err;
res.writeHead(200, {'content-type': 'text/plain'});
res.end('Logged Out!');
return callback(res);
});
});
} else {
authFail(res, done);
return callback(res);
}
};
/*** Building a File Uploader with NodeJs
* https://coligo.io/building-ajax-file-uploader-with-node/
*/
/** POST '/users/upload' **/
exports.avatarUpload = function (req, res) {/* no sé si s'ha provat si funciona, per ara almenys no està linkat ni es fa servir */
// create an incoming form object
var form = new formidable.IncomingForm();
// specify that we want to allow the user to upload multiple files in a single request
form.multiples = true;
// store all uploads in the /uploads directory
form.uploadDir = path.join(__dirname, '/uploads');
// every time a file has been uploaded successfully,
// rename it to it's orignal name
form.on('file', function (field, file) {
fs.rename(file.path, path.join(form.uploadDir, file.name));
});
// log any errors that occur
form.on('error', function (err) {
console.log('An error has occured: \n' + err);
});
// once all the files have been uploaded, send a response to the client
form.on('end', function () {
res.end('success');
});
// parse the incoming request containing the form data
form.parse(req);
};
/** PUT '/users/:userid' **/
exports.updateUser = function (req, res) {//funciona
var id = req.params.userid;
var user = req.body;
userModel.update({'tokens.token': req.headers['x-access-token']}, user,
function (err) {
if (err) return console.log(err);
console.log(user);
res.status(200).jsonp(user);
});
};
/** DELETE '/users/:userid' **/
exports.deleteUserById = function (req, res) {
userModel.findByIdAndRemove({_id: req.params.userid}, function (err) {
if (err) return res.send(500, err.message);
res.status(200).send("Deleted");
});
};
/** GET '/users/' **/
exports.getUsers = function (req, res) {
userModel.find({role: 'user'})
.limit(Number(req.query.pageSize))
.skip(Number(req.query.pageSize) * Number(req.query.page))
.exec(function (err, users) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(users);
});
};
/** GET '/users/:userid' **/
exports.getUserById = function (req, res) {
userModel.findOne({_id: req.params.userid})
.lean()
.populate('diets', 'title description')
.populate('routines', 'title description')
.populate('trainers', 'name avatar description disciplines')
.populate('clients.client', 'name avatar')
.populate('publications')
.exec(function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'User not found.'});
} else if (user) {
/* aquí va el carro de bucle per acabar retornant només les peticions pendents */
var pendentNumber=0;
for (var i = 0; i < user.notifications.length; i++) {
if (user.notifications[i].state == "pendent") {
pendentNumber++;
}
}
user.pendentNotificationsNumber=pendentNumber;
/* fi del carro de bucle de peticions pendents */
res.status(200).jsonp(user);
}
});
};
exports.getUserByToken = function (req, res) {
console.log(req.params.tok);
userModel.findOne({'tokens.token': req.params.tok})
.lean()
.populate('diets', 'title description')
.populate('routines', 'title description')
.populate('trainers', 'name avatar description disciplines')
.populate('clients.client', 'name avatar')
.populate('publications')
.exec(function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'User not found.'});
} else if (user) {
/* aquí va el carro de bucle per acabar retornant només les peticions pendents */
var pendentNumber=0;
for (var i = 0; i < user.notifications.length; i++) {
if (user.notifications[i].state == "pendent") {
pendentNumber++;
}
}
user.pendentNotificationsNumber=pendentNumber;
/* fi del carro de bucle de peticions pendents */
res.status(200).jsonp(user);
}
});
};
/** GET '/users/:userid/network' **/
exports.getUserNetworkById = function (req, res) {
userModel.findOne({_id: req.params.userid})
.lean()
.populate('followers', 'name avatar description')
.populate('following', 'name avatar description')
.exec(function (err, user) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(user);
});
};
/** GET '/users/:userid/suggestions' **/
exports.getUserSuggestionsById = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']})
.exec(function (err, user) {
if (err) return res.send(500, err.message);
userModel.find({
$and: [
{_id: { $nin: user._id}},
{_id: { $nin: user.following}}
],
city: user.city})
.limit(Number(req.query.pageSize))
.skip(Number(req.query.pageSize) * Number(req.query.page))
.select('name role email description avatar')
.exec(function (err, users) {
if (err) return res.send(500, err.message);
console.log(users);
if (users.length>0) {
res.status(200).jsonp(users);
} else {
//si no té users a la ciutat, li tornem users igualment (tot i no ser de la mateixa ciutat)
userModel.find({
$and: [
{_id: { $nin: user._id}},
{_id: { $nin: user.following}}
]})
.limit(Number(req.query.pageSize))
.skip(Number(req.query.pageSize) * Number(req.query.page))
.select('name role email description avatar')
.exec(function (err, users) {
res.status(200).jsonp(users);
});
}
});
});
};
/** GET '/users/:userid/diets' **/
exports.getDietsFromUserId = function (req, res) {
userModel.findOne({_id: req.params.userid})
.populate('diets')
.exec(function (err, user) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(user.diets);
});
};
/** GET '/users/:userid/routines' **/
exports.getRoutinesFromUserId = function (req, res) {
userModel.findOne({_id: req.params.userid})
.populate('routines')
.exec(function (err, user) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(user.routines);
});
};
/** POST '/users/sendPetitionToTrainer/:trainerid' **/
exports.sendPetitionToTrainer = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'sending petition failed. user not found.'});
} else if (user) {
console.log(user.name);//aquí potser caldria comprovar que la routine és la que han creat per l'user
//ara busquem el trainer
userModel.findOne({_id: req.params.trainerid}, function (err, trainer) {
if (err) return res.send(500, err.message);
if (!trainer) {
res.json({success: false, message: 'sending petition failed. trainer not found.'});
} else if (trainer) {
var newPetition = {
clientid: user._id,
message: req.body.message,
state: "pendent"
};
trainer.clientsPetitions.push(newPetition);
/*notification*/
var notification = {
state: "pendent",
message: "client has sent a petition to you",
link: "dashboard",
icon: "newpetition.png",
date: Date()
};
trainer.notifications.push(notification);
/* end of notification*/
trainer.save(function (err) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(trainer);
});
}//end else if
});
}//end else if
});
};
exports.getNumberOfNotifications = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']})
.exec(function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'User not found.'});
} else if (user) {
/* aquí va el carro de bucle per acabar retornant només les peticions pendents */
var pendentNumber=0;
for (var i = 0; i < user.notifications.length; i++) {
if (user.notifications[i].state == "pendent") {
pendentNumber++;
}
}
/* fi del carro de bucle de peticions pendents */
res.status(200).jsonp(pendentNumber);
}
});
};
/** GET '/users/:userid/getNotifications' **/
exports.getNotifications = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']})
.exec(function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'User not found.'});
} else if (user) {
var viewed=[];
var pendent=[];
for (var i = 0; i < user.notifications.length; i++) {
if (user.notifications[i].state == "pendent") {
pendent.push(user.notifications[i]);
user.notifications[i].state = "viewed";
user.notifications[i].dateviewed = Date();
}else{
viewed.push(user.notifications[i]);
}
}
user.save(function (err) {
if (err) return res.send(500, err.message);
res.status(200).jsonp({
pendent: pendent,
viewed: viewed
});
});
}
});
};
/** POST '/users/:userid/deleteSelectedTokens' **/
exports.deleteSelectedTokens = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'user not found.'});
} else if (user) {
console.log(user);
for (var i = 0; i < req.body.devicesToDelete.length; i++) {
for (var j = 0; j < user.tokens.length; j++) {
if (user.tokens[j].userAgent == req.body.devicesToDelete[i].userAgent) {
user.tokens.splice(j, 1);
}
}
}
user.save(function (err) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(user);
});
}//end else if
});
};
/**
userA: el que fa l'acció de seguir --> se li posa userB a following
userB: el que reb el seguiment --> se li posa el userA al followers
**/
/** POST '/users/follow' **/
exports.follow = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, userA) {
if (err) return res.send(500, err.message);
if (!userA) {
res.json({success: false, message: 'userA not found.'});
} else if (userA) {
//ara busquem el userB
userModel.findOne({_id: req.body.userid}, function (err, userB) {
if (err) return res.send(500, err.message);
if (!userB) {
res.json({success: false, message: 'userB not found.'});
} else if (userB) {
userB.followers.push(userA._id);
/*notification*/
var notification = {
state: "pendent",
message: userA.name + " followed you",
link: "dashboard",
icon: "follower.png",
date: Date()
};
userB.notifications.push(notification);
/* end of notification*/
/* gamification */
var reward = {
concept: userA.name + " followed you",
date: Date(),
value: +1
};
userB.points.history.push(reward);
userB.points.total = userB.points.total + 1;
/* end of gamification */
userB.save(function (err) {
if (err) return res.send(500, err.message);
userA.following.push(userB._id);
/* gamification */
var reward = {
concept: "followed " + userB.name,
date: Date(),
value: +1
};
userA.points.history.push(reward);
userA.points.total = userA.points.total + 1;
/* end of gamification */
userA.save(function (err) {
if (err) return res.send(500, err.message);
userModel.findOne({_id: userA._id}).lean().populate('following', 'name avatar')
.exec(function (err, userA) {
if (err) return res.send(500, err.message);
console.log("user followed" + userB.name);
res.status(200).jsonp(userB);
});
});
});
}//end else if
});
}//end else if
});
};
/**
userA: el que fa l'acció de deixar de seguir --> se li treu userB de following
userB: el que deixa de tenir el seguiment --> se li treu l'userA del followers
**/
/** POST '/users/unfollow' **/
exports.unfollow = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, userA) {
if (err) return res.send(500, err.message);
if (!userA) {
res.json({success: false, message: 'userA not found.'});
} else if (userA) {
//ara busquem el userB
userModel.findOne({_id: req.body.userid}, function (err, userB) {
if (err) return res.send(500, err.message);
if (!userB) {
res.json({success: false, message: 'userB not found.'});
} else if (userB) {
var indexFollower = -1;
for (var i = 0; i < userB.followers.length; i++) {
if (userB.followers[i].equals(userA._id)) {
indexFollower = JSON.parse(JSON.stringify(i));
}
}
if (indexFollower > -1) {
userB.followers.splice(indexFollower, 1);
/*notification*/
var notification = {
state: "pendent",
message: userA.name + " unfollowed you",
link: "dashboard",
icon: "unfollower.png",
date: Date()
};
userB.notifications.push(notification);
/* end of notification*/
/* gamification */
var reward = {
concept: userA.name + " unfollowed you",
date: Date(),
value: -1
};
userB.points.history.push(reward);
userB.points.total = userB.points.total - 1;
/* end of gamification */
userB.save(function (err) {
if (err) return res.send(500, err.message);
var indexFollower = -1;
for (var i = 0; i < userA.following.length; i++) {
if (userA.following[i].equals(userB._id)) {
indexFollower = JSON.parse(JSON.stringify(i));
}
}
if (indexFollower > -1) {
userA.following.splice(indexFollower, 1);
/* gamification */
var reward = {
concept: "unfollowed " + userB.name,
date: Date(),
value: -1
};
userA.points.history.push(reward);
userA.points.total = userA.points.total - 1;
/* end of gamification */
userA.save(function (err) {
if (err) return res.send(500, err.message);
userModel.findOne(userA).lean().populate('following', 'name avatar')
.exec(function (err, userA) {
if (err) return res.send(500, err.message);
console.log("user followed" + userB.name);
res.status(200).jsonp(userB);
});
});
} else {//else de indexFollower>-1
res.status(200).jsonp({message: 'not found'});
}
});
} else {//else de indexFollower>-1
res.status(200).jsonp({message: 'not found'});
}
}//end else if
});
}//end else if
});
};
/**GET '/search/:searchstring' **/
exports.search = function (req, res) {
userModel.find({
name: new RegExp(req.params.searchstring, "i"),
role: 'user'
})//perquè retorni tots els objectes que continguin l'string sense necessitat de que sigui exactament la mateixa string
.limit(Number(req.query.pageSize))
.skip(Number(req.query.pageSize) * Number(req.query.page))
.exec(function (err, users) {
if (err) return res.send(500, err.message);
userModel.find({
name: new RegExp(req.params.searchstring, "i"),
role: 'trainer'
})//perquè retorni tots els objectes que continguin l'string sense necessitat de que sigui exactament la mateixa string
.limit(Number(req.query.pageSize))
.skip(Number(req.query.pageSize) * Number(req.query.page))
.exec(function (err, trainers) {
if (err) return res.send(500, err.message);
routineModel.find({title: new RegExp(req.params.searchstring, "i")})//perquè retorni tots els objectes que continguin l'string sense necessitat de que sigui exactament la mateixa string
.limit(Number(req.query.pageSize))
.skip(Number(req.query.pageSize) * Number(req.query.page))
.exec(function (err, routines) {
if (err) return res.send(500, err.message);
dietModel.find({title: new RegExp(req.params.searchstring, "i")})//perquè retorni tots els objectes que continguin l'string sense necessitat de que sigui exactament la mateixa string
.limit(Number(req.query.pageSize))
.skip(Number(req.query.pageSize) * Number(req.query.page))
.exec(function (err, diets) {
if (err) return res.send(500, err.message);
res.json({
users: users,
trainers: trainers,
routines: routines,
diets: diets
});
});//diets
});//routines
});//trainers
});//users
};
/** POST '/users/newMark' **/
exports.newMark = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'user not found.'});
} else if (user) {
var newmark = {
title: req.body.title,
unit: req.body.unit
};
user.marks.push(newmark);
/* gamification */
var reward = {
concept: "new mark created: " + newmark.title,
date: Date(),
value: +3
};
user.points.history.push(reward);
user.points.total = user.points.total + 3;
/* end of gamification */
user.save(function (err) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(user.marks);
});
}//end else if user
});
};
/** DELETE /users/markid'**/
exports.deleteUserMark = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'user not found.'});
} else if (user) {
var indexMark=-1;
for (var i = 0; i < user.marks.length; i++) {
if (user.marks[i]._id == req.params.markid) {
indexMark = JSON.parse(JSON.stringify(i));
}
}
if(indexMark>-1)
{
user.marks.splice(indexMark, 1);
/* gamification */
var reward = {
concept: "mark deleted",
date: Date(),
value: -3
};
user.points.history.push(reward);
user.points.total = user.points.total - 3;
/* end of gamification */
user.save(function (err, user) {//guardem el trainer amb la rutina treta
if (err) return res.send(500, err.message);
userModel.findOne({_id: user._id})
.lean()
.populate('diets', 'title description')
.populate('routines', 'title description')
.populate('trainers', 'name avatar description disciplines')
.populate('clients.client', 'name avatar')
.populate('publications')
.exec(function (err, user) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(user);
});
});
}else{
res.status(200).jsonp({message: 'mark not found'});
}
}
});
}
/**
cal rebre:
_id
value: 10
**/
/** POST '/users/:markid/addDayToMark' **/
exports.addDayToMark = function (req, res) {
userModel.findOne({'tokens.token': req.headers['x-access-token']}, function (err, user) {
if (err) return res.send(500, err.message);
if (!user) {
res.json({success: false, message: 'user not found.'});
} else if (user) {
var indexMark = -1;
var indexDay = -1;
for (var i = 0; i < user.marks.length; i++) {
if (user.marks[i]._id == req.params.markid) {
indexMark = JSON.parse(JSON.stringify(i));
for (var j = 0; j < user.marks[i].days.length; j++) {
if (user.marks[i].days[j].date == Date()) {
indexDay = JSON.parse(JSON.stringify(j));
}
}
}
}
if (indexMark > -1)//si la mark existeix
{
if (indexDay == -1)//però el dia no existeix encara
{
var newday = {
date: Date(),
value: req.body.value
};
user.marks[indexMark].days.push(newday);
/* gamification */
var reward = {
concept: "day value added to mark: " + user.marks[indexMark].title,
date: Date(),
value: +1
};
user.points.history.push(reward);
user.points.total = user.points.total + 1;
/* end of gamification */
user.save(function (err) {
if (err) return res.send(500, err.message);
res.status(200).jsonp(user.marks);
});
} else {
res.status(200).jsonp({message: 'mark of day already registered'});
}
} else {
res.status(200).jsonp({message: 'mark not registered'});
}
}//end else if user
});
};