node -v

const chalk = require('chalk');
const name = process.argv[2];
console.log('Hello, ' + chalk.red.bold(name) + '!');

const express = require('express');
const app = express();
 
// __dirname holds the file path to the current directory.
app.use(express.static(__dirname + '/public'));
 
app.get('/year', (request, response) => {
  // request is an object that contains details
  // about the request that was received.
  // response is an object that contains methods
  // for populating the response to be sent.
  // These are often abbreviated as "req" and "res"
  // as you'll see in later code.
  // This explicitly passes a string to "send" because if a
  // number is passed it treats it as a response status code.
  response.send(new Date().getFullYear().toString());
});
 
const listener = app.listen(1919, () => {
  console.log('browse http://localhost:' + listener.address().port);
});

create extension pgcrypto; -- needed to encrypt passwords
 
create table ice_creams (
  id serial primary key,
  flavor text
);
 
create table users (
  username text primary key,
  password text -- encrypted
);
 
create table user_ice_creams (
  username text references users(username),
  ice_cream_id integer references ice_creams(id)
);

db=ice_cream
dropdb $db
createdb $db
psql -d $db -f tables.ddl

const PgConnection = require('postgresql-easy');
 
// Configure a connection to the database.
const pg = new PgConnection({database: 'ice_cream'});
 
const tableName = 'ice_creams';
 
async function demo() {
  try {
    // Delete all rows from these tables:
    // user_ice_creams, users, and ice_cream.
    await pg.deleteAll('user_ice_creams');
    await pg.deleteAll('users');
    await pg.deleteAll(tableName);
 
    // Insert three new rows corresponding to three flavors.
    // For each flavor it calls pg-insert which returns a promise.
    // flavors.map returns an array of these three promises.
    // Promise.all returns a promise that resolves when
    // all the promises in the array passed to it resolve.
    const flavors = ['vanilla', 'chocolate', 'strawberry'];
    const results = await Promise.all(
      flavors.map(f => pg.insert(tableName, {flavor: f})));
 
    // Get an array of the ids of the new rows.
    const ids = results.map(result => result.rows[0].id);
    console.log('inserted records with ids', ids);
 
    // Delete the first row (vanilla).
    await pg.deleteById(tableName, ids[0]);
 
    // Change the flavor of the second row (chocolate) to "chocolate chip".
    await pg.updateById(tableName, ids[1], {flavor: 'chocolate chip'});
 
    // Get all the rows in the table.
    const result = await pg.getAll(tableName);
 
    // Output their ids and flavors.
    for (const row of result.rows) {
      console.log(row.id, row.flavor);
    }
 
  // Catch and report any errors that occur in the previous steps.
  } catch (e) {
    throw e;
 
  } finally {
    // Disconnect from the database.
    await pg.disconnect();
  }
}
 
demo();

const auth = require('node-token-auth');
const express = require('express');
const PgConnection = require('postgresql-easy');
const server = require('./server'); // described later
 
// Configure the algorithm and password used to encrypt auth tokens
// and set the session timeout in minutes.
const algorithm = 'aes-256-ctr';
const key = 'V01kmann';
const timeoutMinutes = 1;
auth.configure(algorithm, key, timeoutMinutes);
 
const app = express();
server.setup(app);
 
function handleError(res, err) {
  res.statusMessage = `${err.toString()}; ${err.detail}`;
  res.status(500).send();
}
 
const pg = new PgConnection({
  database: 'ice_cream' // defaults to username
  //host: 'localhost', // default
  //idleTimeoutMillis: 30000, // before a client is closed (default is 30000)
  //max: 10, // max clients in pool (default is 10)
  //password: '', // not needed in this example
  //port: 5432, // the default
  //user: 'Mark' // not needed in this example
});
 
/**
 * Deletes an ice cream flavor from a given user.
 * The URL will look like /ice-cream/some-user/some-flavor-id
 * The "Authorization" request header must be set.
 */
app.delete('/ice-cream/:username/:id', async (req, res) => {
  if (!auth.authorize(req, res)) return;
 
  // id is the id of the ice cream flavor to be deleted.
  const {id, username} = req.params;
 
  const sql = `
    delete from user_ice_creams
    where username=$1 and ice_cream_id=$2`;
  try {
    await pg.query(sql, username, id);
    res.send();
  } catch (e) {
    handleError(res, e);
  }
});
 
/**
 * Retrieves all ice cream ids and flavors
 * associated with a given user.
 * The URL will look like /ice-cream/some-user
 * The "Authorization" request header must be set.
 */
app.get('/ice-cream/:username', async (req, res) => {
  if (!auth.authorize(req, res)) return;
 
  const {username} = req.params;
  const sql = `
    select ic.id, ic.flavor
    from ice_creams ic, user_ice_creams uic
    where uic.username='${username}'
    and uic.ice_cream_id=ic.id`;
  try {
    const result = await pg.query(sql);
    res.json(result.rows);
  } catch (e) {
    handleError(res, e);
  }
});
 
/**
 * Adds an ice cream flavor to a given user.
 * The URL will look like /ice-cream/some-user?flavor=some-flavor
 * The "Authorization" request header must be set.
 * The response will contain the id of newly created user_ice_creams row.
 */
app.post('/ice-cream/:username', async (req, res) => {
  if (!auth.authorize(req, res)) return;
 
  const {username} = req.params;
  const {flavor} = req.query;
 
  // Creates a row in the user_ice_creams table
  // that associates an ice cream flavor with a user.
  async function associate(username, iceCreamId) {
    const sql = `
      insert into user_ice_creams (username, ice_cream_id)
      values ($1, $2)`;
    try {
      await pg.query(sql, username, iceCreamId);
      res.send(String(iceCreamId));
    } catch (e) {
      handleError(res, e);
    }
  }
 
  // Get the id of the flavor if it already exists.
  let sql = 'select id from ice_creams where flavor=$1';
  try {
    const result = await pg.query(sql, flavor);
    const [row] = result.rows;
    if (row) { // The flavor exists.
      associate(username, row.id);
    } else { // The flavor doesn't exist, so create it.
      sql = 'insert into ice_creams (flavor) values ($1) returning id';
      const result = await pg.query(sql, flavor);
      const [row] = result.rows;
      if (row) {
        associate(username, row.id);
      } else {
        handleError(res, 'failed to create new flavor');
      }
    }
  } catch (e) {
    handleError(res, e);
  }
});
 
/**
 * Updates a record in the ice-cream table by id.
 * The URL will look like /ice-cream/some-ice-cream-id?flavor=some-new-flavor
 * The "Authorization" request header must be set.
 */
app.put('/ice-cream/:id', async (req, res) => {
  if (!auth.authorize(req, res)) return;
 
  const {id} = req.params;
  const {flavor} = req.query;
  try {
    await pg.updateById('ice_creams', id, {flavor});
    res.send();
  } catch (e) {
    handleError(res, e);
  }
});
 
/**
 * Logs in a user.
 * The username and password must be in the body
 * and the content type must be "application/json".
 */
app.post('/login', async (req, res) => {
  const {username, password} = req.body;
  if (!username) {
    res.statusMessage = 'Missing Username';
    return res.status(400).send();
  }
  if (!password) {
    res.statusMessage = 'Missing Password';
    return res.status(400).send();
  }
 
  const sql = `
    select password = crypt('${password}', password) as authenticated
    from users where username='${username}'`;
  try {
    const result = await pg.query(sql);
    const [row] = result.rows;
    if (row) {
      auth.generateToken(username, req, res);
      res.send(row.authenticated);
    } else {
      res.statusMessage = 'Username Not Found';
      res.status(404).send();
    }
  } catch (e) {
    handleError(res, e);
  }
});
 
/**
 * Logs out the current user.
 * The "Authorization" request header must be set.
 */
app.post('/logout', (req, res) => {
  if (!auth.authorize(req, res)) return;
 
  auth.deleteToken(req);
  res.send();
});
 
/**
 * Signs up a new user.
 * The username and password must be in the body
 * and the content type must be "application/json".
 */
app.post('/signup', async (req, res) => {
  const {username, password} = req.body;
  if (!username) {
    res.statusMessage = 'Missing Username';
    return res.status(400).send();
  }
  if (!password) {
    res.statusMessage = 'Missing Password';
    return res.status(400).send();
  }
 
  // Encrypt password using a Blowfish-based ciper (bf)
  // performing 8 iterations.
  const sql = `
    insert into users (username, password)
    values('${username}', crypt('${password}', gen_salt('bf', 8)))`;
 
  try {
    await pg.query(sql);
    auth.generateToken(username, req, res);
    res.send();
  } catch (e) {
    handleError(res, e);
  }
});
 
server.start();

const bodyParser = require('body-parser');
const fs = require('fs');
const https = require('https');
const sio = require('socket.io');
 
let server;
 
function setup(app) {
  // Suppress the x-powered-by response header
  // so hackers don't get a clue that might help them.
  app.set('x-powered-by', false);
 
  // Enable use of CORS.
  app.use((req, res, next) => {
    // This could be more selective!
    res.header('Access-Control-Allow-Origin', '*');
    res.header('Access-Control-Allow-Headers',
      'Accept, Authorization, Content-Type, Origin, X-Requested-With');
    res.header('Access-Control-Expose-Headers',
      'Authorization, Content-Type');
    res.header('Access-Control-Allow-Methods', 'GET,DELETE,POST,PUT');
    next();
  });
 
  // The "extended" option of bodyParser enables parsing of objects and arrays.
  app.use(bodyParser.json({extended: true}));
 
  // Enable use of HTTPS.
  // The two ".pem" files references are described later.
  const options = {
    key: fs.readFileSync('key.pem'),
    cert: fs.readFileSync('cert.pem'),
    passphrase: 'icecream'
  };
  server = https.createServer(options, app);
 
  server.on('error', err => {
    console.error(err.code === 'EACCES' ? 'must use sudo' : err);
  });
}
 
function start() {
  const PORT = 443;
  server.listen(PORT, () => console.log('listening on port', PORT));
 
  // Configure Socket.IO to allow the server to communicate with the browser.
  // Our usage supports session timeouts.
  const io = sio.listen(server);
  io.on('connection', socket => global.socket = socket);
}
 
module.exports = {setup, start};

<!doctype html>
<html lang="en">
  <head>
    <meta name="viewport" content="width=device-width, initial-scale=1">
 
    <!--
      Notice the use of %PUBLIC_URL% in the tag below.
      It will be replaced with the URL of the `public` folder during the build.
      Only files inside the `public` folder can be referenced from the HTML.
    -->
    <link rel="shortcut icon" href="%PUBLIC_URL%/favicon.ico">
 
    <title>Ice Cream App</title>
  </head>
  <body>
    <!--
      This element is populated by React.
      See the reference to 'root' in src/index.js.
    -->
    <div id="root"></div>
  </body>
</html>

import React from 'react';
import ReactDOM from 'react-dom';
import App from './App';
import './index.css';
 
// This creates an instance of the App component and renders it
// inside the div with an id of "root" in public/index.html.
ReactDOM.render(
  <App />,
  document.getElementById('root')
);

import React, {Component} from 'react';
import Login from './login';
import Main from './main';
import 'whatwg-fetch'; // for REST calls
import './App.css';
 
// This allows the client to listen to socket.io events
// emitted from the server.  It is used to proactively
// terminate sessions when the session timeout expires.
import io from 'socket.io-client';
 
class App extends Component {
  constructor() {
    super();
 
    // Redux is a popular library for managing state in a React application.
    // This application, being somewhat small, opts for a simpler approach
    // where the top-most component manages all of the state.
    // Placing a bound version of the setState method on the React object
    // allows other components to call it in order to modify state.
    // Each call causes the UI to re-render,
    // using the "Virtual DOM" to make this efficient.
    React.setState = this.setState.bind(this);
 
    // This gets a socket.io connection from the server
    // and registers for "session-timeout" events.
    // If one is received, the user is logged out.
    const socket = io('https://localhost', {secure: true});
    socket.on('session-timeout', () => {
      alert('Your session timed out.');
      this.logout();
    });
  }
 
  // This is the initial state of the application.
  state = {
    authenticated: false,
    error: '',
    flavor: '',
    iceCreamMap: {},
    password: '',
    restUrl: 'https://localhost',
    route: 'login', // controls the current page
    token: '',
    username: ''
  };
 
  /**
   * Sends a logout POST request to the server
   * and goes to the login page.
   */
  logout = async () => {
    const url = `${this.state.restUrl}/logout`;
    const headers = {Authorization: this.state.token};
    try {
      await fetch(url, {method: 'POST', headers});
      React.setState({
        authenticated: false,
        route: 'login',
        password: '',
        username: ''
      });
    } catch (e) {
      React.setState({error: e.toString()});
    }
  };
 
  render() {
    // Use destructuring to extract data from the state object.
    const {
      authenticated, error, flavor, iceCreamMap,
      password, restUrl, route, token, username
    } = this.state;
 
    return (
      <div className="App">
        <header>
          <img className="header-img" src="ice-cream.png" alt="ice cream"/>
          Ice cream, we all scream for it!
          {
            authenticated ?
              <button onClick={this.logout}>Log out</button> :
              null
          }
        </header>
        <div className="App-body">
          {
            // This is an alternative to controlling routing to pages
            // that is far simpler than more full-blown solutions
            // like react-router.
            route === 'login' ?
              <Login
                username={username}
                password={password}
                restUrl={restUrl}
              /> :
            route === 'main' ?
              <Main
                flavor={flavor}
                iceCreamMap={iceCreamMap}
                restUrl={restUrl}
                token={token}
                username={username}
              /> :
              <div>Unknown route {route}</div>
          }
          {
            // If an error has occurred, render it at the bottom of any page.
            error ? <div className="error">{error}</div> : null
          }
        </div>
      </div>
    );
  }
}
 
export default App;

import React, {Component, PropTypes as t} from 'react';
import 'whatwg-fetch';
 
function onChangePassword(event) {
  React.setState({password: event.target.value});
}
 
function onChangeUsername(event) {
  React.setState({username: event.target.value});
}
 
class Login extends Component {
 
  static propTypes = {
    password: t.string.isRequired,
    restUrl: t.string.isRequired,
    username: t.string.isRequired
  };
 
  // This is called when the "Log In" button is pressed.
  onLogin = async () => {
    const {password, restUrl, username} = this.props;
    const url = `${restUrl}/login`;
 
    try {
      // Send username and password to login REST service.
      const res = await fetch(url, {
        method: 'POST',
        headers: {'Content-Type': 'application/json'},
        body: JSON.stringify({username, password})
      });
 
      if (res.ok) { // successful login
        const token = res.headers.get('Authorization');
        const text = await res.text(); // returns a promise
        const authenticated = text === 'true';
        React.setState(
          authenticated ?
          {
            authenticated: true,
            error: null, // clear previous error
            route: 'main',
            token
          } :
          {
            error: 'Invalid username or password'
          });
      } else { // unsuccessful login
        const msg = /ECONNREFUSED/.test(res.statusText) ?
          'Failed to connect to database' :
          res.statusText;
        React.setState({error: msg});
      }
    } catch (e) {
      React.setState({error: `${url}; ${e.message}`});
    }
  }
 
  // This is called when the "Signup" button is pressed.
  onSignup = async () => {
    const {password, restUrl, username} = this.props;
    const url = `${restUrl}/signup`;
 
    try {
      const res = await fetch(url, {
        method: 'POST',
        headers: {'Content-Type': 'application/json'},
        body: JSON.stringify({username, password})
      });
 
      if (res.ok) { // successful signup
        const token = res.headers.get('Authorization');
        React.setState({
          authenticated: true,
          error: null, // clear previous error
          route: 'main',
          token,
          username
        });
      } else { // unsuccessful signup
        let text = res.statusText;
        if (/duplicate key/.test(text)) {
          text = `User ${username} already exists`;
        }
        React.setState({error: text});
      }
    } catch (e) {
      React.setState({error: `${url}; ${e.message}`});
    }
  }
 
  render() {
    const {password, username} = this.props;
    const canSubmit = username && password;
 
    // We are handling sending the username and password
    // to a REST service above, so we don't want
    // the HTML form to submit anything for us.
    // That is the reason for the call to preventDefault.
    return (
      <form className="login-form"
        onSubmit={event => event.preventDefault()}>
        <div className="row">
          <label>Username:</label>
          <input type="text"
            autoFocus
            onChange={onChangeUsername}
            value={username}
          />
        </div>
        <div className="row">
          <label>Password:</label>
          <input type="password"
            onChange={onChangePassword}
            value={password}
          />
        </div>
        <div className="row submit">
          {/* Pressing enter in either input invokes the first button. */}
          <button disabled={!canSubmit} onClick={this.onLogin}>
            Log In
          </button>
          <button disabled={!canSubmit} onClick={this.onSignup}>
            Signup
          </button>
        </div>
      </form>
    );
  }
}
 
export default Login;

import IceCreamEntry from './ice-cream-entry';
import IceCreamList from './ice-cream-list';
import React, {Component, PropTypes as t} from 'react';
import 'whatwg-fetch';
 
function changeFlavor(event) {
  React.setState({flavor: event.target.value});
}
 
function handleError(url, res) {
  React.setState(res.status === 440 ?
    {error: 'Session Timeout', route: 'login'} :
    {error: res.message});
}
 
async function loadIceCreams(url, headers) {
  let res;
  try {
    res = await fetch(url, {headers});
    if (!res.ok) return handleError(url, res);
 
    const iceCreams = await res.json();
    const iceCreamMap = {};
    for (const iceCream of iceCreams) {
      iceCreamMap[iceCream.id] = iceCream.flavor;
    }
    React.setState({iceCreamMap});
  } catch (e) {
    handleError(url, res);
  }
}
 
class Main extends Component {
 
  static propTypes = {
    flavor: t.string.isRequired,
    iceCreamMap: t.object.isRequired,
    restUrl: t.string.isRequired,
    token: t.string.isRequired,
    username: t.string.isRequired
  };
 
  /**
   * Gets the current list of ice cream flavors
   * liked by the current user.
   */
  componentDidMount() {
    const {restUrl, token, username} = this.props;
 
    // This header is used in all REST calls.
    this.headers = {Authorization: token};
 
    const url = `${restUrl}/ice-cream/${username}`;
    loadIceCreams(url, this.headers);
  }
 
  /**
   * Adds an ice cream flavor to the list
   * of those liked by the current user.
   */
  addIceCream = async flavor => {
    const {restUrl, username} = this.props;
    const url = `${restUrl}/ice-cream/${username}?flavor=${flavor}`;
    let res;
    try {
      res = await fetch(url, {method: 'POST', headers: this.headers});
      if (!res.ok) return handleError(url, res);
      let id = await res.text();
      if (!id) return;
 
      // Now that it has been successfully added to the database,
      // add it in the UI.
      id = Number(id);
      const {iceCreamMap} = this.props;
      iceCreamMap[id] = flavor;
      React.setState({flavor: '', iceCreamMap});
    } catch (e) {
      handleError(url, res);
    }
  };
 
  /**
   * Deletes an ice cream flavor from the list
   * of those liked by the current user.
   */
  deleteIceCream = async id => {
    const {restUrl, username} = this.props;
    const url = `${restUrl}/ice-cream/${username}/${id}`;
    let res;
    try {
      res = await fetch(url, {method: 'DELETE', headers: this.headers});
      if (!res.ok) return handleError(url, res);
 
      // Now that it has been successfully deleted from the database,
      // delete it from the UI.
      const {iceCreamMap} = this.props;
      delete iceCreamMap[id];
      React.setState({iceCreamMap});
    } catch (e) {
      handleError(url, res);
    }
  };
 
  render() {
    const {flavor, iceCreamMap, username} = this.props;
    return (
      <div className="main">
        <IceCreamEntry
          addCb={this.addIceCream}
          changeCb={changeFlavor}
          flavor={flavor}
        />
        <label>{username}'s favorite flavors are:</label>
        <IceCreamList
          deleteCb={this.deleteIceCream}
          iceCreamMap={iceCreamMap}
        />
      </div>
    );
  }
}
 
export default Main;

import React, {PropTypes as t} from 'react';
 
const IceCreamEntry = ({addCb, changeCb, flavor}) =>
  <form
    className="ice-cream-entry"
    onSubmit={event => event.preventDefault()}
  >
    <label>Flavor</label>
    <input type="text" autoFocus onChange={changeCb} value={flavor}/>
    {/* using unicode heavy plus for button */}
    <button onClick={() => addCb(flavor)}>➕</button>
  </form>;
 
IceCreamEntry.propTypes = {
  addCb: t.func.isRequired,
  changeCb: t.func.isRequired,
  flavor: t.string.isRequired,
};
 
export default IceCreamEntry;

import React, {PropTypes as t} from 'react';
import IceCreamRow from './ice-cream-row';
 
const IceCreamList = ({deleteCb, iceCreamMap}) => {
  const list = Object.keys(iceCreamMap)
    .map(id => ({id, flavor: iceCreamMap[id]}));
  list.sort((a, b) => a.flavor.localeCompare(b.flavor));
 
  return (
    <ul className="ice-cream-list">
      {
        list.map(iceCream =>
          <IceCreamRow
            deleteCb={deleteCb}
            id={iceCream.id}
            key={iceCream.id}
            flavor={iceCream.flavor}
          />)
      }
    </ul>
  );
};
 
IceCreamList.propTypes = {
  deleteCb: t.func.isRequired,
  iceCreamMap: t.object.isRequired
};
 
export default IceCreamList;

import React, {PropTypes as t} from 'react';
 
const IceCreamRow = ({deleteCb, flavor, id}) =>
  <li className="ice-cream-row">
    {/* using unicode heavy x for button */}
    <button onClick={() => deleteCb(id)}>✖</button>
    {flavor}
  </li>;
 
IceCreamRow.propTypes = {
  deleteCb: t.func.isRequired,
  flavor: t.string,
  id: t.string
};
 
export default IceCreamRow;