Chuck Michael's Solution

.gitignore

@@ -0,0 +1 @@
+node_modules

README.md

@@ -1,2 +1,17 @@
 # assignment_mad_lib_api
 Serving up the madness with a Mad Lib API!
+
+Chuck Michael's (https://github.com/chuckinabox/) Solution
+
+Aquire Token from http:localhost:4000, after signuping up.
+
+Access api with http://localhost:4000/api/v1/madlib?access_token=123ABCExample&story=This story needs a {{ noun }} {{ adjective }}&words=[computer, dry] will return "This story needs a computer dry"
+
+Automatically get nouns, adjectives, adverbs, verbs entered with just the story parameter
+http://...&story={{ noun }} {{ adjective }} {{ adverb }} {{ verb }}
+
+Also get a list of words with the part of speech parameter pos
+http://...&pos=noun
+
+By default is 10 but with adding count, choice your own
+http://...&pos=verb&count=40

app.js

@@ -0,0 +1,249 @@
+const express = require("express");
+const app = express();
+
+// ----------------------------------------
+// Body Parser
+// ----------------------------------------
+const bodyParser = require("body-parser");
+app.use(bodyParser.urlencoded({ extended: true }));
+
+// ----------------------------------------
+// Sessions/Cookies
+// ----------------------------------------
+const cookieSession = require("cookie-session");
+
+app.use(
+  cookieSession({
+    name: "session",
+    keys: [process.env.SESSION_SECRET || "asdf1234567890qwer"]
+  })
+);
+
+app.use((req, res, next) => {
+  app.locals.session = req.session;
+  next();
+});
+
+// ----------------------------------------
+// Method Override
+// ----------------------------------------
+const methodOverride = require("method-override");
+const getPostSupport = require("express-method-override-get-post-support");
+
+app.use(
+  methodOverride(
+    getPostSupport.callback,
+    getPostSupport.options // GET POST
+  )
+);
+
+// ----------------------------------------
+// Referrer
+// ----------------------------------------
+app.use((req, res, next) => {
+  req.session.backUrl = req.header("Referer") || "/";
+  next();
+});
+
+// ----------------------------------------
+// Logging
+// ----------------------------------------
+const morgan = require("morgan");
+const morganToolkit = require("morgan-toolkit")(morgan);
+
+// Use morgan middleware with
+// custom format
+if (process.env.NODE_ENV !== "test") {
+  app.use(morganToolkit());
+}
+
+// ----------------------------------------
+// Mongoose
+// ----------------------------------------
+const mongoose = require("mongoose");
+app.use((req, res, next) => {
+  if (mongoose.connection.readyState) {
+    next();
+  } else {
+    require("./mongo")().then(() => next());
+  }
+});
+
+// ----------------------------------------
+// Services
+// ----------------------------------------
+
+// Require passport, strategies and User model
+const passport = require("passport");
+const LocalStrategy = require("passport-local").Strategy;
+const BearerStrategy = require("passport-http-bearer").Strategy;
+const User = require("./models").User;
+
+// Initialize passport
+app.use(passport.initialize());
+app.use(passport.session());
+
+// Create local strategy
+const localStrategy = new LocalStrategy(
+  {
+    // Set username field to email
+    // to match form
+    usernameField: "email"
+  },
+  (email, password, done) => {
+    // Find user by email
+    User.findOne({ email: email })
+      .then(user => {
+        // The user is valid if the password is valid
+        const isValid = user.validatePassword(password);
+
+        // If the user is valid pass the user
+        // to the done callback
+        // Else pass false
+        return done(null, isValid ? user : false);
+      })
+      .catch(e => done(null, false));
+  }
+);
+
+// Create the token bearer strategy
+const bearerStrategy = new BearerStrategy((token, done) => {
+  // Find the user by token
+  User.findOne({ token: token })
+    .then(user => {
+      // Pass the user if found else false
+      return done(null, user || false);
+    })
+    .catch(e => done(null, false));
+});
+
+// Use the strategy middlewares
+passport.use(localStrategy);
+passport.use(bearerStrategy);
+
+// Serialize and deserialize the user
+// with the user ID
+passport.serializeUser((user, done) => done(null, user.id));
+passport.deserializeUser((id, done) => {
+  // Find the user in the database
+  User.findById(id)
+    .then(user => done(null, user))
+    .catch(e => done(null, false));
+});
+
+// ----------------------------------------
+// Session Helper Middlewares
+// ----------------------------------------
+
+// Set up middleware to allow/disallow login/logout
+const loggedInOnly = (req, res, next) => {
+  return req.user ? next() : res.redirect("/login");
+};
+
+const loggedOutOnly = (req, res, next) => {
+  return !req.user ? next() : res.redirect("/");
+};
+
+// ----------------------------------------
+// Routes
+// ----------------------------------------
+
+// Show login only if logged out
+app.get("/login", loggedOutOnly, (req, res) => {
+  res.render("login/login");
+});
+
+// Allow logout via GET and DELETE
+const onLogout = (req, res) => {
+  // Passport convenience method to logout
+  req.logout();
+
+  // Ensure always redirecting as GET
+  req.method = "GET";
+  res.redirect("/login");
+};
+app.get("/logout", loggedInOnly, onLogout);
+app.delete("/logout", loggedInOnly, onLogout);
+
+// Create session with passport
+app.post(
+  "/login",
+  passport.authenticate("local", {
+    successRedirect: "/",
+    failureRedirect: "/login",
+    failureFlash: true
+  })
+);
+
+// Pass logged in/out middlewares to users router
+const loginRouter = require("./routers/login")({
+  loggedInOnly,
+  loggedOutOnly
+});
+app.use("/", loginRouter);
+
+const madLibRouter = require("./routers/madLib");
+app.use("/api/v1", madLibRouter);
+
+// Setup API router
+// const furiousSpinoffsRouter = require('./routers/furious_spinoffs');
+// app.use('/api/v1', furiousSpinoffsRouter);
+
+// ----------------------------------------
+// Template Engine
+// ----------------------------------------
+const expressHandlebars = require("express-handlebars");
+
+const hbs = expressHandlebars.create({
+  partialsDir: "views/",
+  defaultLayout: "application"
+});
+
+app.engine("handlebars", hbs.engine);
+app.set("view engine", "handlebars");
+
+// ----------------------------------------
+// Server
+// ----------------------------------------
+const port = process.env.PORT || process.argv[2] || 4000;
+const host = "localhost";
+
+let args;
+process.env.NODE_ENV === "production" ? (args = [port]) : (args = [port, host]);
+
+args.push(() => {
+  console.log(`Listening: http://${host}:${port}\n`);
+});
+
+// If we're running this file directly
+// start up the server
+if (require.main === module) {
+  app.listen.apply(app, args);
+}
+
+// ----------------------------------------
+// Error Handling
+// ----------------------------------------
+app.use("/api", (err, req, res, next) => {
+  if (res.headersSent) {
+    return next(err);
+  }
+
+  if (err.stack) {
+    err = err.stack;
+  }
+  res.status(500).json({ error: err });
+});
+
+app.use((err, req, res, next) => {
+  if (res.headersSent) {
+    return next(err);
+  }
+
+  if (err.stack) {
+    err = err.stack;
+  }
+  res.status(500).render("errors/500", { error: err });
+});
+
+module.exports = app;

config/mongoose.json

@@ -0,0 +1,28 @@
+{
+  "development": {
+    "database": "assignment_mad_lib_api_development",
+    "host": "localhost"
+  },
+  "test": {
+    "database": "assignment_mad_lib_api_test",
+    "host": "localhost"
+  },
+  "production": {
+    "use_env_variable": "MONGO_URL"
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

models/index.js

@@ -0,0 +1,24 @@
+const mongoose = require('mongoose');
+const bluebird = require('bluebird');
+
+mongoose.Promise = bluebird;
+
+// Enable logging if not testing
+(process.env.NODE_ENV === 'test') ||
+  mongoose.set('debug', true);
+
+
+const models = {};
+
+
+models.User = require('./user');
+
+
+
+
+module.exports = models;
+
+
+
+
+

models/user.js

@@ -0,0 +1,65 @@
+const mongoose = require("mongoose");
+const Schema = mongoose.Schema;
+const uniqueValidator = require("mongoose-unique-validator");
+const bcrypt = require("bcrypt");
+const md5 = require("md5");
+const uuid = require("uuid/v4");
+
+const UserSchema = new Schema(
+  {
+    fname: {
+      type: String,
+      required: true
+    },
+    lname: {
+      type: String,
+      required: true
+    },
+    email: {
+      type: String,
+      required: true,
+      unique: true
+    },
+    hashedPassword: {
+      type: String,
+      required: true
+    },
+    token: {
+      type: String,
+      unique: true
+    }
+  },
+  {
+    timestamps: true
+  }
+);
+
+UserSchema.plugin(uniqueValidator);
+
+UserSchema.virtual("password").set(function(value) {
+  this._password = value;
+  this.hashedPassword = bcrypt.hashSync(value, 8);
+});
+
+UserSchema.virtual("password").get(function() {
+  return this.hashedPassword;
+});
+
+UserSchema.path("hashedPassword").validate(function(val) {
+  if (this._password.length < 8) {
+    this.invalidate("password", "Password must be at least 8 characters");
+  }
+});
+
+UserSchema.methods.validatePassword = function(password) {
+  return bcrypt.compareSync(password, this.hashedPassword);
+};
+
+UserSchema.pre("save", function(next) {
+  this.token = md5(`${this.email}${uuid()}`);
+  next();
+});
+
+const User = mongoose.model("User", UserSchema);
+
+module.exports = User;