550 lines
15 KiB
JavaScript
550 lines
15 KiB
JavaScript
var router = require('express').Router();
|
|
var mongoose = require('mongoose');
|
|
var TrackData = mongoose.model('TrackData');
|
|
var Track = mongoose.model('Track');
|
|
var Comment = mongoose.model('Comment');
|
|
var User = mongoose.model('User');
|
|
var auth = require('../auth');
|
|
var currentTracks = new Map();
|
|
class trackInfo {
|
|
constructor (track,trackData)
|
|
{
|
|
this.track = track;
|
|
this.trackData = trackData;
|
|
}
|
|
}
|
|
|
|
|
|
function addPointsToTrack(track,body)
|
|
{
|
|
var num = 0;
|
|
var start = 0;
|
|
var end = 0;
|
|
//console.log("len"+body.length);
|
|
while (end < body.length) {
|
|
start = end;
|
|
while (body[end] != ";" && body[end] != "$" && end < body.length) {
|
|
end++;
|
|
}
|
|
if(body[end] == "$") // $ is replacing \n as newlines are not allowed in json strings
|
|
{
|
|
num=0;
|
|
}
|
|
if(end < body.length)
|
|
{
|
|
var token = body.substr(start, end - start);
|
|
end++;
|
|
if(token.length>0)
|
|
{
|
|
//console.log(token);
|
|
//console.log("num:"+num);
|
|
//console.log("end:"+end);
|
|
|
|
if((num == 0) && (token == "Date"))
|
|
{
|
|
// we have a header line, ignore it for now, TODO parse it
|
|
if (end < body.length) {
|
|
while (body[end] != ";" && body[end] != "$" && end < body.length) {
|
|
end++;
|
|
}
|
|
start = end;
|
|
num=100;
|
|
}
|
|
}
|
|
if (num == 0) {
|
|
track.trackData.points.push({ date: "dummy", time: "", latitude: "", longitude: "", course: "", speed: "", d1: "", d2: "", flag: "", private: ""});
|
|
track.trackData.points[track.trackData.points.length - 1].date = token;
|
|
num++;
|
|
}
|
|
else if (num == 1) {
|
|
track.trackData.points[track.trackData.points.length - 1].time = token;
|
|
num++;
|
|
}
|
|
else if (num == 2) {
|
|
var f = parseFloat(token);
|
|
if(isNaN(f))
|
|
{
|
|
f = parseFloat(token.substring(0,10));
|
|
}
|
|
track.trackData.points[track.trackData.points.length - 1].latitude = f;
|
|
num++;
|
|
}
|
|
else if (num == 3) {
|
|
var f = parseFloat(token);
|
|
if(isNaN(f))
|
|
{
|
|
f = parseFloat(token.substring(0,10));
|
|
}
|
|
track.trackData.points[track.trackData.points.length - 1].longitude = f;
|
|
num++;
|
|
}
|
|
else if (num == 4) {
|
|
var f = parseFloat(token);
|
|
if(isNaN(f))
|
|
{
|
|
f = parseFloat(token.substring(0,10));
|
|
}
|
|
track.trackData.points[track.trackData.points.length - 1].course = f;
|
|
num++;
|
|
}
|
|
else if (num == 5) {
|
|
var f = parseFloat(token);
|
|
if(isNaN(f))
|
|
{
|
|
f = parseFloat(token.substring(0,10));
|
|
}
|
|
track.trackData.points[track.trackData.points.length - 1].speed = f;
|
|
num++;
|
|
}
|
|
else if (num == 6) {
|
|
track.trackData.points[track.trackData.points.length - 1].d1 = token;
|
|
num++;
|
|
}
|
|
else if (num == 7) {
|
|
track.trackData.points[track.trackData.points.length - 1].d2 = token;
|
|
num++;
|
|
}
|
|
else if (num == 8) {
|
|
track.trackData.points[track.trackData.points.length - 1].flag = token;
|
|
num++;
|
|
}
|
|
else if (num == 9) {
|
|
track.trackData.points[track.trackData.points.length - 1].private = token;
|
|
num++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Preload track objects on routes with ':track'
|
|
router.param('track', function(req, res, next, slug) {
|
|
Track.findOne({ slug: slug})
|
|
.populate('author')
|
|
.then(function (track) {
|
|
if (!track) { return res.sendStatus(404); }
|
|
|
|
req.track = track;
|
|
|
|
return next();
|
|
}).catch(next);
|
|
});
|
|
|
|
router.param('comment', function(req, res, next, id) {
|
|
Comment.findById(id).then(function(comment){
|
|
if(!comment) { return res.sendStatus(404); }
|
|
|
|
req.comment = comment;
|
|
|
|
return next();
|
|
}).catch(next);
|
|
});
|
|
|
|
router.get('/', auth.optional, function(req, res, next) {
|
|
var query = {};
|
|
var limit = 20;
|
|
var offset = 0;
|
|
|
|
if(typeof req.query.limit !== 'undefined'){
|
|
limit = req.query.limit;
|
|
}
|
|
|
|
if(typeof req.query.offset !== 'undefined'){
|
|
offset = req.query.offset;
|
|
}
|
|
|
|
if( typeof req.query.tag !== 'undefined' ){
|
|
query.tagList = {"$in" : [req.query.tag]};
|
|
}
|
|
|
|
Promise.all([
|
|
req.query.author ? User.findOne({username: req.query.author}) : null,
|
|
req.query.favorited ? User.findOne({username: req.query.favorited}) : null
|
|
]).then(function(results){
|
|
var author = results[0];
|
|
var favoriter = results[1];
|
|
|
|
if(author){
|
|
query.author = author._id;
|
|
}
|
|
|
|
if(favoriter){
|
|
query._id = {$in: favoriter.favorites};
|
|
} else if(req.query.favorited){
|
|
query._id = {$in: []};
|
|
}
|
|
|
|
return Promise.all([
|
|
Track.find(query)
|
|
.limit(Number(limit))
|
|
.skip(Number(offset))
|
|
.sort({createdAt: 'desc'})
|
|
.populate('author')
|
|
.where('visible').equals(true)
|
|
.exec(),
|
|
Track.countDocuments(query).exec(),
|
|
req.payload ? User.findById(req.payload.id) : null,
|
|
]).then(function(results){
|
|
var tracks = results[0];
|
|
var tracksCount = results[1];
|
|
var user = results[2];
|
|
//console.log(tracks);
|
|
var retTracks = [];
|
|
for (t of tracks) {
|
|
//console.log(t);
|
|
//if (t.author.areTracksVisibleForAll || t.author == user) {
|
|
retTracks.push(t);
|
|
//}
|
|
}
|
|
return res.json({
|
|
tracks: retTracks.map(function(track){
|
|
return track.toJSONFor(user);
|
|
}),
|
|
tracksCount: retTracks.length
|
|
});
|
|
});
|
|
}).catch(next);
|
|
});
|
|
|
|
router.get('/feed', auth.required, function(req, res, next) {
|
|
var limit = 20;
|
|
var offset = 0;
|
|
|
|
if(typeof req.query.limit !== 'undefined'){
|
|
limit = req.query.limit;
|
|
}
|
|
|
|
if(typeof req.query.offset !== 'undefined'){
|
|
offset = req.query.offset;
|
|
}
|
|
|
|
User.findById(req.payload.id).then(function(user){
|
|
if (!user) { return res.sendStatus(401); }
|
|
if(user.following != '')
|
|
{
|
|
Promise.all([
|
|
Track.find({ author: {$in: user.following}})
|
|
.limit(Number(limit))
|
|
.skip(Number(offset))
|
|
.populate('author')
|
|
.exec(),
|
|
Track.countDocuments({ author: {$in: user.following}})
|
|
]).then(function(results){
|
|
var tracks = results[0];
|
|
var tracksCount = results[1];
|
|
|
|
return res.json({
|
|
tracks: tracks.map(function(track){
|
|
return track.toJSONFor(user);
|
|
}),
|
|
tracksCount: tracksCount
|
|
});
|
|
}).catch(next);
|
|
}
|
|
else
|
|
{
|
|
Promise.all([
|
|
Track.find({ author: {$in: req.payload.id}})
|
|
.limit(Number(limit))
|
|
.skip(Number(offset))
|
|
.populate('author')
|
|
.exec(),
|
|
Track.countDocuments({ author: {$in: req.payload.id}})
|
|
]).then(function(results){
|
|
var tracks = results[0];
|
|
var tracksCount = results[1];
|
|
|
|
return res.json({
|
|
tracks: tracks.map(function(track){
|
|
return track.toJSONFor(user);
|
|
}),
|
|
tracksCount: tracksCount
|
|
});
|
|
}).catch(next);
|
|
}
|
|
|
|
|
|
|
|
});
|
|
});
|
|
|
|
router.post('/', auth.required, function(req, res, next) {
|
|
User.findById(req.payload.id).then(function(user){
|
|
if (!user) { return res.sendStatus(401); }
|
|
|
|
var track = new Track(req.body.track);
|
|
var trackData = new TrackData();
|
|
track.trackData = trackData._id;
|
|
|
|
track.author = user;
|
|
track.visible = track.author.areTracksVisibleForAll;
|
|
trackData.save(function (err){
|
|
if(err){
|
|
console.log("failed to save trackData");
|
|
}
|
|
});
|
|
|
|
return track.save().then(function(){
|
|
//console.log(track.author);
|
|
return res.json({track: track.toJSONFor(user)});
|
|
});
|
|
return res.json({track: track.toJSONFor(user)});
|
|
}).catch(next);
|
|
});
|
|
|
|
router.post('/add', auth.optional, function(req, res, next) {
|
|
//console.log("Add");
|
|
|
|
//console.log(req.payload);
|
|
User.findById(req.body.id).then(function (user) {
|
|
if (!user) { return res.sendStatus(401); }
|
|
|
|
var ti = null;
|
|
if (currentTracks.has(req.body.id))
|
|
ti = currentTracks.get(req.body.id);
|
|
|
|
//console.log("TI" + ti);
|
|
//console.log("TILen" + ti.trackData.points.length);
|
|
//console.log("TITrack" + ti.track);
|
|
//console.log("Body" + req.body.track.body);
|
|
if (ti.track) {
|
|
addPointsToTrack(ti, req.body.track.body);
|
|
//console.log("TLen" + ti.trackData.points.length);
|
|
ti.track.author = user;
|
|
}
|
|
|
|
//return track.save().then(function(){
|
|
// console.log(track.author);
|
|
//return res.json({ track: track.toJSONFor(user) });
|
|
return res.sendStatus(200);
|
|
//});
|
|
}).catch(next);
|
|
});
|
|
|
|
router.post('/begin', auth.optional, function (req, res, next) {
|
|
//console.log("Begin");
|
|
//console.log(req.payload);
|
|
User.findById(req.body.id).then(function (user) {
|
|
if (!user) { return res.sendStatus(401); }
|
|
|
|
if(currentTracks.has(req.body.id))
|
|
currentTracks.delete(req.body.id); // delete old parts if there are leftovers
|
|
var ti = new trackInfo(new Track(req.body.track),new TrackData());
|
|
ti.track.trackData = ti.trackData._id;
|
|
currentTracks.set(req.body.id, ti);
|
|
|
|
//console.log("addToTrack"+req.body);
|
|
|
|
addPointsToTrack(ti, ti.track.body);
|
|
|
|
//console.log("TLen" + ti.track);
|
|
//console.log("TLen" + ti.trackData);
|
|
//console.log("TLen" + ti.trackData.points.length);
|
|
|
|
//console.log(track.trackData.points[0].date);
|
|
ti.track.author = user;
|
|
|
|
//return track.save().then(function () {
|
|
// console.log(track.author);
|
|
return res.sendStatus(200);
|
|
//});
|
|
}).catch(next);
|
|
});
|
|
|
|
router.post('/end', auth.optional, function (req, res, next) {
|
|
//console.log("End");
|
|
//console.log(req.payload);
|
|
User.findById(req.body.id).then(function (user) {
|
|
if (!user) { return res.sendStatus(401); }
|
|
|
|
var track = null;
|
|
if (currentTracks.has(req.body.id))
|
|
{
|
|
ti = currentTracks.get(req.body.id);
|
|
addPointsToTrack(ti, req.body.track.body);
|
|
}
|
|
else
|
|
{
|
|
var ti = new trackInfo(new Track(req.body.track),new TrackData());
|
|
ti.track.trackData = ti.trackData._id;
|
|
addPointsToTrack(ti, ti.track.body);
|
|
}
|
|
if (ti.track) {
|
|
ti.track.author = user;
|
|
}
|
|
|
|
currentTracks.delete(req.body.id); // we are done with this track, it is complete
|
|
ti.track.author = user;
|
|
|
|
//console.log(track);
|
|
//console.log("user:"+user);
|
|
return ti.track.save().then(function () {
|
|
//console.log("TLen" + ti.track);
|
|
//console.log("TLen" + ti.trackData);
|
|
//console.log("TLen" + ti.trackData.points.length);
|
|
ti.trackData.save(function (err){
|
|
if(err){
|
|
console.log("failed to save trackData"+err.toString());
|
|
}
|
|
});
|
|
|
|
console.log("successfulSave:");
|
|
return res.sendStatus(200);
|
|
});
|
|
}).catch(next);
|
|
});
|
|
|
|
// return a track
|
|
router.get('/:track', auth.optional, function(req, res, next) {
|
|
Promise.all([
|
|
req.payload ? User.findById(req.payload.id) : null,
|
|
req.track.populate('author').execPopulate()
|
|
]).then(function(results){
|
|
var user = results[0];
|
|
|
|
return res.json({track: req.track.toJSONFor(user)});
|
|
}).catch(next);
|
|
});
|
|
|
|
// update track
|
|
router.put('/:track', auth.required, function(req, res, next) {
|
|
User.findById(req.payload.id).then(function(user){
|
|
if(req.track.author._id.toString() === req.payload.id.toString()){
|
|
if(typeof req.body.track.title !== 'undefined'){
|
|
req.track.title = req.body.track.title;
|
|
}
|
|
|
|
if(typeof req.body.track.description !== 'undefined'){
|
|
req.track.description = req.body.track.description;
|
|
}
|
|
|
|
if(typeof req.body.track.body !== 'undefined'){
|
|
req.track.body = req.body.track.body;
|
|
}
|
|
|
|
if(typeof req.body.track.tagList !== 'undefined'){
|
|
req.track.tagList = req.body.track.tagList;
|
|
}
|
|
req.track.visible = req.body.track.visible;
|
|
console.log("saving track");
|
|
|
|
req.track.save().then(function(track){
|
|
return res.json({track: track.toJSONFor(user)});
|
|
}).catch(next);
|
|
} else {
|
|
return res.sendStatus(403);
|
|
}
|
|
});
|
|
});
|
|
|
|
// delete track
|
|
router.delete('/:track', auth.required, function(req, res, next) {
|
|
User.findById(req.payload.id).then(function(user){
|
|
if (!user) { return res.sendStatus(401); }
|
|
if(req.track.author._id.toString() === req.payload.id.toString()){
|
|
TrackData.findByIdAndDelete(req.track.trackData, function (err, td) {console.log("doneDelete");}); // delet our track data
|
|
return req.track.remove().then(function(){
|
|
return res.sendStatus(204);
|
|
});
|
|
} else {
|
|
return res.sendStatus(403);
|
|
}
|
|
}).catch(next);
|
|
});
|
|
|
|
// Favorite an track
|
|
router.post('/:track/favorite', auth.required, function(req, res, next) {
|
|
var trackId = req.track._id;
|
|
|
|
User.findById(req.payload.id).then(function(user){
|
|
if (!user) { return res.sendStatus(401); }
|
|
|
|
return user.favorite(trackId).then(function(){
|
|
return req.track.updateFavoriteCount().then(function(track){
|
|
return res.json({track: track.toJSONFor(user)});
|
|
});
|
|
});
|
|
}).catch(next);
|
|
});
|
|
|
|
// Unfavorite an track
|
|
router.delete('/:track/favorite', auth.required, function(req, res, next) {
|
|
var trackId = req.track._id;
|
|
|
|
User.findById(req.payload.id).then(function (user){
|
|
if (!user) { return res.sendStatus(401); }
|
|
|
|
return user.unfavorite(trackId).then(function(){
|
|
return req.track.updateFavoriteCount().then(function(track){
|
|
return res.json({track: track.toJSONFor(user)});
|
|
});
|
|
});
|
|
}).catch(next);
|
|
});
|
|
|
|
// return an track's comments
|
|
router.get('/:track/comments', auth.optional, function(req, res, next){
|
|
Promise.resolve(req.payload ? User.findById(req.payload.id) : null).then(function(user){
|
|
return req.track.populate({
|
|
path: 'comments',
|
|
populate: {
|
|
path: 'author'
|
|
},
|
|
options: {
|
|
sort: {
|
|
createdAt: 'desc'
|
|
}
|
|
}
|
|
}).execPopulate().then(function(track) {
|
|
return res.json({comments: req.track.comments.map(function(comment){
|
|
return comment.toJSONFor(user);
|
|
})});
|
|
});
|
|
}).catch(next);
|
|
});
|
|
|
|
// create a new comment
|
|
router.post('/:track/comments', auth.required, function(req, res, next) {
|
|
User.findById(req.payload.id).then(function(user){
|
|
if(!user){ return res.sendStatus(401); }
|
|
|
|
var comment = new Comment(req.body.comment);
|
|
comment.track = req.track;
|
|
comment.author = user;
|
|
|
|
return comment.save().then(function(){
|
|
req.track.comments.push(comment);
|
|
|
|
return req.track.save().then(function(track) {
|
|
res.json({comment: comment.toJSONFor(user)});
|
|
});
|
|
});
|
|
}).catch(next);
|
|
});
|
|
|
|
router.delete('/:track/comments/:comment', auth.required, function(req, res, next) {
|
|
if(req.comment.author.toString() === req.payload.id.toString()){
|
|
req.track.comments.remove(req.comment._id);
|
|
req.track.save()
|
|
.then(Comment.find({_id: req.comment._id}).remove().exec())
|
|
.then(function(){
|
|
res.sendStatus(204);
|
|
});
|
|
} else {
|
|
res.sendStatus(403);
|
|
}
|
|
});
|
|
|
|
// return an track's trackData
|
|
router.get('/:track/TrackData', auth.optional, function(req, res, next){
|
|
Promise.resolve(req.payload ? User.findById(req.payload.id) : null).then(function(user){
|
|
//console.log("requestTrackData"+req.track);
|
|
TrackData.findById(req.track.trackData,function(err,trackData){
|
|
//console.log({trackData: trackData});
|
|
return res.json({trackData: trackData});
|
|
});
|
|
}).catch(next);
|
|
});
|
|
|
|
module.exports = router;
|