Token App

builder.js

var express = require('express');
var path = require('path');
var favicon = require('serve-favicon');
var logger = require('morgan');
var cookieParser = require('cookie-parser');
var bodyParser = require('body-parser');
var session = require('express-session');

var routes = require('./routes/index');

var passport = require('passport');
var request = require('request');
var OAuth2Strategy = require('passport-oauth2');
var redis = require('redis');
var redisClient = redis.createClient(11935, 'greeneye.redistogo.com');

const conf = {
  client_key: [APP_KEY],
  client_secret: [APP_SECRET]
};

redisClient.auth([REDIS_AUTH_KEY], function() {
  console.log('connected to redis');
});

passport.serializeUser(function(user, done) {
  done(null, user);
});

passport.deserializeUser(function(obj, done) {
  done(null, obj);
});

passport.use(
  new OAuth2Strategy({
    authorizationURL: 'https://api.login.yahoo.com/oauth2/request_auth',
    tokenURL: 'https://api.login.yahoo.com/oauth2/get_token',
    clientID: conf.client_key,
    clientSecret: conf.client_secret,
    callbackURL: 'http://www.fantasytool.dev/auth/yahoo/callback'
  }, function(accessToken, refreshToken, params, profile, done) {
    
    var options = {
      url: `https://social.yahooapis.com/v1/user/${params.xoauth_yahoo_guid}/profile?format=json`,
      method: 'get',
      json: true,
      auth: {
        'bearer': accessToken
      }
    };

    request(options, function (error, response, body) {
      if (!error && response.statusCode == 200) {
        var userObj = {
          id: body.profile.guiid,
          name: body.profile.nickname,
          avatar: body.profile.image.imageUrl,
          accessToken: accessToken,
          refreshToken: refreshToken
        };
        
        redisClient.set([TOKEN_KEY], JSON.stringify({
          accessToken: accessToken,
          refreshToken: refreshToken
          })
        );

        return done(null, userObj);
      }
    });
  }
));

var app = express();

// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');

// uncomment after placing your favicon in /public
//app.use(favicon(path.join(__dirname, 'public', 'favicon.ico')));
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(session({ 
  secret: [SECRET_VALUE],
  resave: false,
  saveUninitialized: true 
}));
app.use(express.static(path.join(__dirname, 'public')));

app.use('/', routes);

// authentication routes
app.get('/auth/yahoo',
  passport.authenticate('oauth2', { failureRedirect: '/login' }),
  function(req, res, user) {
    res.redirect('/');
  });

app.get('/auth/yahoo/callback',
  passport.authenticate('oauth2', { failureRedirect: '/login' }),
  function(req, res) {
    res.redirect(req.session.redirect || '/');
  }
);

app.get('/logout', function(req, res){
  req.logout();
  res.redirect(req.session.redirect || '/');
});

function checkAuth(req, res, next) {
  var userObj;

  if (req.isAuthenticated()) {
    userObj = {
      name: req.user.name,
      avatar: req.user.avatar
    };
  } else {
    userObj = null;
  }

  req.userObj = userObj;

  next();
}

// catch 404 and forward to error handler
app.use(function(req, res, next) {
  var err = new Error('Not Found');
  err.status = 404;
  next(err);
});

// error handlers

// development error handler
// will print stacktrace
if (app.get('env') === 'development') {
  app.use(function(err, req, res, next) {
    res.status(err.status || 500);
    res.render('error', {
      message: err.message,
      error: err
    });
  });
}

// production error handler
// no stacktraces leaked to user
app.use(function(err, req, res, next) {
  res.status(err.status || 500);
  res.render('error', {
    message: err.message,
    error: {}
  });
});

module.exports = app;

pushapp.js

const YahooFantasy = require('yahoo-fantasy');
const request = require('request');
const redis = require('redis');
const async = require('async');
const moment = require('moment');
const redisClient = redis.createClient(11935, 'greeneye.redistogo.com');

const TODAY = moment().format("dddd, MMMM Do YYYY");
const KEY = [TOKEN_KEY];
const PB_API_KEY = [PUSHBUTTON_API_KEY];
const conf = {
  client_key: [APP_KEY],
  client_secret: [APP_SECRET]
};

const yf = new YahooFantasy(
  conf.clientKey,
  conf.clientSecret
);

const refresh = function(err, refresh_token) {
  const reason = String(err.description).match( /"(.*?)"/ );

  return new Promise((resolve, reject) => {
    if (reason && 'token_expired' === reason[1]) {
      const options = {
        url: 'https://api.login.yahoo.com/oauth2/get_token',
        method: 'post',
        json: true,
        form: {
          client_id: conf.clientKey,
          client_secret: conf.clientSecret,
          redirect_uri: 'oob',
          refresh_token: refresh_token,
          grant_type: 'refresh_token'
        }
      };

      request(options, function (err, response, { access_token, refresh_token }) {
        console.log(access_token, refresh_token);
        if (err) {
          reject(err);
        }

        redisClient.set('tokenData', JSON.stringify({
          accessToken: access_token,
          refreshToken: refresh_token
          })
        );

        resolve({access_token, refresh_token});
      });
    } else {
      reject(err)
    }
  });
}

const callback = function(e, data) {
  console.log(data);
}

const getRosters = function(access_token, refresh_token) {
  yf.setUserToken(access_token);
  yf.team.roster([LEAGUE_KEY], (err, data) => {
    if (err) {
      return refresh(err, refresh_token).then(({access_token, refresh_token}) => {
        yf.setUserToken(access_token);
        getRosters();
      }, (reason) => {
        console.log(reason);
      });
    }

    const TEAM_URL = data.url;
    async.each(data.roster, (p, callback) => {
      if (typeof p.starting_status == 'undefined') return callback(null);

      redisClient.get(p.player_id, (e, data) => {
        // if there's an error with redis we skip the player
        if ( e ) return callback(e);
        
        // if the saved date is the same as today's date then
        // we won't send a push about them...
        if ( data == TODAY ) return callback(null);
        
        if ( 
          p.starting_status == 0 && !( p.selected_position == 'BN' || p.selected_position == 'DL')
          || p.starting_status == 1 && ( p.selected_position == 'BN' || p.selected_position == 'DL')
        ) {
          // player is not starting but is in the lineup...
          let data = {
            'type': 'link',
            'body': 'Tap to edit lineup',
            'url': TEAM_URL
          };
          
          if ( p.starting_status ) {
            data.title = `Player on your bench: ${p.name.full}`;

            if ('B' === p.position_type) {
              data.title += ` (hitting ${p.batting_order[0].order_num})`;
            }

            data.title += ' (FBBL)';
          } else {
            data.title = 'Not in lineup: ' + p.name.full + ' (FBBL)';
          }
          
          // push bullet options
          const options = {
            url: 'https://api.pushbullet.com/v2/pushes',
            method: 'POST',
            body: JSON.stringify(data), 
            headers: {
              'User-Agent': 'request',
              'Access-Token': PB_API_KEY,
              'Content-Type': 'application/json'
            }
          };
          
          // send push notification
          request(
            options,
            (err, resp, body) => {
              // save the fact that we've pushed the data to the db
              redisClient.set(p.player_id, TODAY, function() {
                return callback(null);
              });
          });
        } else {
          // the player is rightly starting or benched...
          // should i push to redis?
          return callback(null);
        }
      });
    }, (e, data) => {
      redisClient.end();
      process.exit(0);
    });
  });
}

redisClient.auth([REDIS_AUTH_KEY], () => {
  redisClient.get(KEY, (e, tokenData) => {
    if (e) {
      // whut?
    }
    
    let { accessToken, refreshToken } = JSON.parse(tokenData);
    getRosters(accessToken, refreshToken);
  });
});