Merge branch 'master' of https://github.com/ernest-phillips/nodejs_captstone

Author: ernest-phillips

.travis.yml

@@ -1,4 +1,4 @@
 language: node_js
-node_js:
-  - "iojs"
-  - "7"
+node_js: node
+services:
+- mongodb

README.md

@@ -1,5 +1,7 @@
 # Fit-Journal with NodeJS
 
+View project at www.fit-journal.herokuapp.com (currently still in development)
+
 Track your workout history whether it be resistance or cardiovascular training, all in one place!
 This project is built on Node and Express using CRUD standard practices.
 Create an account.

app/auth/auth.router.js

@@ -14,8 +14,6 @@ const {
 
 const authRouter = express.Router();
 
-//Receives user we can turn into JSON web token to be issued out 
-//to users to access protected endpoints
 function createJwtToken(user) {
     return jwt.sign({
         user
@@ -26,12 +24,15 @@ function createJwtToken(user) {
     });
 }
 //Login endpoint
-authRouter.get('/login.html', (req, res) => {});
+authRouter.get('/login', (req, res) => {
+    const user = request.user.serialize();
+    const jwtToken = createJwtToken(user);
+    response.json({ jwtToken, user });
+});
 
 authRouter.post('/login', localPassportMiddleware, (request, response) => {
     const user = request.user.serialize();
     const jwtToken = createJwtToken(user);
-    // response.redirect('/api/workout');
     response.json({
         jwtToken,
         user
@@ -42,7 +43,6 @@ authRouter.post('/login', localPassportMiddleware, (request, response) => {
 authRouter.post('/refresh', jwtPassportMiddleware, (request, response) => {
     const user = request.user;
     const jwtToken = createJwtToken(user);
-    // response.redirect('/api/workout');
     response.json({
         jwtToken,
         user
@@ -59,7 +59,7 @@ authRouter.post('/logout', localPassportMiddleware, (req, res) => {
 
 =======
 authRouter.post('/logout', (req, res) => {
-    console.log("logging out")
+
     res.header('Cache-Control', 'no-cache, private, no-store, must-revalidate, max-stale=0, post-check=0, pre-check=0');
     res.json({
 

app/auth/auth.strategy.js

@@ -14,46 +14,37 @@ const {
     JWT_SECRET
 } = require('../config');
 
-// Passport authentication strategies are used to define how authentication middleware works.
-// For more on how Passport authentication works using strategies, see:
-// http://www.passportjs.org/docs/configure/
+
 
 // The LocalStrategy gets used while trying to access an Endpoint using a User + Password combination
 const localStrategy = new LocalStrategy((username, password, passportVerify) => {
     let user;
-    // Step 1: Verify the username exists
+
     User.findOne({
         username: username
     }).then(_user => {
         user = _user;
         if (!user) {
 
-            // Step 2A: If user is not found on the database, reject promise with an error.
             return Promise.reject({
                 reason: 'LoginError',
                 message: 'Incorrect username or password'
             });
         }
-        // Step 2B: Compare the user's password against the stored password hash by running it against the same algorithm.
 
         return user.validatePassword(password);
     }).then(isValid => {
         if (!isValid) {
 
-            // Step 3A: If password doesn't match the stored password hash, reject promise with an error.
             return Promise.reject({
                 reason: 'LoginError',
                 message: 'Incorrect username or password'
             });
         }
-        // Step 3B: If authentication is succesfull, execute the passportVerify callback correctly.
-        // To learn more about how the passportVerify callback works, see:
-        // http://www.passportjs.org/docs/configure/#verify-callback
+
         return passportVerify(null, user);
     }).catch(err => {
-        // Step 4: If an error ocurred at any stage during the process, execute the passportVerify callback correctly.
-        // To learn more about how the passportVerify callback works, see:
-        // http://www.passportjs.org/docs/configure/#verify-callback
+
         if (err.reason === 'LoginError') {
 
             return passportVerify(null, false, err.message);

app/config.js

@@ -1,16 +1,17 @@
 module.exports = {
-    PORT: process.env.PORT || 8080,
-    HTTP_STATUS_CODES: {
-        OK: 200,
-        CREATED: 201,
-        NO_CONTENT: 204,
-        BAD_REQUEST: 400,
-        UNAUTHORIZED: 401,
-        NOT_FOUND: 404,
-        INTERNAL_SERVER_ERROR: 500
-    },
-    MONGO_URL: process.env.MONGO_URL || 'mongodb://localhost:27017/fit-journal',
-    TEST_MONGO_URL: process.env.TEST_MONGO_URL || 'mongodb://localhost:27017/test-fit-journal',
-    JWT_SECRET: process.env.JWT_SECRET || 'default',
-    JWT_EXPIRY: process.env.JWT_EXPIRY || '7d'
-};
+  PORT: process.env.PORT || 8080,
+  HTTP_STATUS_CODES: {
+    OK: 200,
+    CREATED: 201,
+    NO_CONTENT: 204,
+    BAD_REQUEST: 400,
+    UNAUTHORIZED: 401,
+    NOT_FOUND: 404,
+    INTERNAL_SERVER_ERROR: 500,
+  },
+  MONGO_URL: process.env.MONGO_URL || 'mongodb://localhost:27017/fit-journal',
+  // MONGO_URL: process.env.MONGO_URL || 'mongodb://ds237932.mlab.com:37932/fit-journal',
+  TEST_MONGO_URL: process.env.TEST_MONGO_URL || 'mongodb://localhost:27017/test-fit-journal',
+  JWT_SECRET: process.env.JWT_SECRET || 'default',
+  JWT_EXPIRY: process.env.JWT_EXPIRY || '7d',
+};

app/exercise/exercise.model.js

@@ -47,6 +47,5 @@ const ExerciseJoiSchema = Joi.object().keys({
 });
 
 module.exports = {
-    Exercise,
-    ExerciseJoiSchema
+    Exercise
 };

app/exercise/exercise.router.js

@@ -18,11 +18,9 @@ const {
 exerciseRouter.post('/', (request, response) => {
 
     const newExercise = {
-
         exercise: request.body.exercise,
         ex_type: request.body.ex_type,
         bodypart: request.body.bodypart
-
     };
 
     const validation = Joi.validate(newExercise, ExerciseJoiSchema);

app/server.js

@@ -44,6 +44,10 @@ app.use('/api/auth', authRouter);
 app.use('/api/user', userRouter); //Redirects all calls to /api/user to userRouter
 app.use('/api/home', workoutRouter);
 app.use('/api/exercises', exerciseRouter);
+app.use(express.static('./public', {
+    extensions: ['html', 'htm']
+        // Other options here
+}));
 
 
 app.use('*', function(req, res) {
@@ -67,28 +71,22 @@ function startServer(testEnv) {
         } else {
             mongoUrl = MONGO_URL;
         }
-        // Step 1: attempt to connect to MongoDB with mongoose
-        mongoose.connect(mongoUrl, {
-            useNewUrlParser: true
-        }, err => {
-            if (err) {
-                // Step 2a: if there si an error starting mongo, log error, reject promise and stop code execution
-                console.error(err);
-                return reject(err);
-            } else {
-                // Step 2B: start express server
-                server = app.listen(PORT, () => {
-                    //STep 3A: log success message to console and resolve promise
-                    console.log(`Express sever listining on http://localhost:${PORT}`);
-                    resolve();
-                }).on('error', err => {
-                    // Step 3B: if there was a problem starting the express sever, disconnect from MongoDB immediately
-                    mongoose.disconnect();
+        mongoose.connect(mongoUrl, { useNewUrlParser: true },
+            err => {
+                if (err) {
                     console.error(err);
-                    reject(err);
-                });
-            }
-        });
+                    return reject(err);
+                } else {
+                    server = app.listen(PORT, () => {
+                        console.log(`Express sever listining on http://localhost:${PORT}`);
+                        resolve();
+                    }).on('error', err => {
+                        mongoose.disconnect();
+                        console.error(err);
+                        reject(err);
+                    });
+                }
+            });
     });
 }
 

app/sets/sets.model.js

@@ -0,0 +1,53 @@
+const mongoose = require("mongoose");
+const Joi = require("joi");
+
+
+const setSchema = new mongoose.Schema({
+    user: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: "user"
+    },
+    exercise: {
+        type: String,
+        required: true
+    },
+    set: {
+        type: Number,
+        required: true
+    },
+    reps: {
+        type: Number,
+        required: true
+    },
+    weight: {
+        type: Number
+    },
+    date: {
+        type: Date,
+        default: Date.now
+    }
+});
+setSchema.methods.serialize = function() {
+    return {
+        user: this.user,
+        exercise: this.exercise,
+        reps: this.reps,
+        weight: this.weight,
+        set: this.set,
+        date: this.date
+    }
+}
+const Set = mongoose.model("set", setSchema);
+const SetJoiSchema = Joi.object({
+    user: Joi.string().required(),
+    exercise: Joi.string(),
+    reps: Joi.number(),
+    set: Joi.number(),
+    weight: Joi.number()
+})
+
+module.exports = {
+    Set,
+    setSchema,
+    SetJoiSchema
+}

app/sets/sets.router.js

@@ -0,0 +1,57 @@
+const express = require('express');
+const Joi = require('joi');
+const setsRouter = express.Router();
+const path = require('path');
+
+const {
+    HTTP_STATUS_CODES
+} = require('../config');
+const {
+    jwtPassportMiddleware
+} = require('../auth/auth.strategy');
+const {
+    Set,
+    SetJoiSchema
+} = require('./sets.model');
+
+//Create new set   
+setsRouter.post('/', (req, res) => {
+    const newSet = {
+        date: req.body.date,
+        exercise: req.body.exercise,
+        reps: req.body.reps,
+        weight: req.body.weight,
+        set: req.body.set
+
+    }
+    const validation = Joi.validate(newSet, SetJoiSchema);
+    if (validation.error) {
+        console.log("Set Validation Error")
+        return res.status(HTTP_STATUS_CODES.BAD_REQUEST).json({
+            error: validation.error
+        });
+    }
+    Set.create(newSet)
+        .then(createdSet => {
+            return res.status(HTTP_STATUS_CODES.CREATED).json(createdSet.serialize());
+        })
+        .catch(error => {
+            return res.status(HTTP_STATUS_CODES.INTERNAL_SERVER_ERROR).send(error);
+        })
+})
+
+setsRouter.get('/', (req, res) => {
+    Set.find()
+        .then(sets => {
+            return res.status(HTTP_STATUS_CODES.OK).json(
+                sets.map(set => set.serialize())
+            );
+        })
+        .catch(error => {
+            return res.status(HTTP_STATUS_CODES.INTERNAL_SERVER_ERROR).json(error);
+        });
+});
+module.exports = {
+
+    setsRouter
+}