module.exports = function (twitterKey, twitterSecret) {
const oauth = new OAuth(
`${root_url}/oauth/request_token`,
`${root_url}/oauth/access_token`,
twitterKey,
twitterSecret,
'1.0A',
null,
'HMAC-SHA1');
const getUser = function(userKey, userSecret, userId, done) {
oauth.get(
`${root_url}/1.1/statuses/user_timeline.json?user_id=${userId}`,
userKey,
userSecret,
function (error, results, res){
if(error){console.log(JSON.stringify(error))}
results = JSON.parse(results)
done(results);
});
}
return {user_data: getUser}
}
const getUser = function(userKey, userSecret, userId, done) {
oauth.get(
`${root_url}/1.1/statuses/user_timeline.json?user_id=${userId}`,
userKey,
userSecret,
function (error, results, res){
if(error){console.log(JSON.stringify(error))}
results = JSON.parse(results)
done(results);
});
}
var request = https.request(options, function(response){
response.on("data", function(d){
console.log("", d.toString("utf8"));
var tweet = JSON.parse(d);
console.log("tweet: " + tweet.text);
});
});
request.end();
*/
var oauth = new OAuth.OAuth(
'https://api.twitter.com/oauth/request_token',
'https://api.twitter.com/oauth/access_token',
'kWrLrMfLw4NVgyYbR0NTpAYsK',
'iY3fASx1kLAhwApVDUGkWOHZF3cp4dPidEoZ74UpGsX4qicOdm',
'1.0A',
null,
'HMAC-SHA1'
);
console.log("step2");
oauth.get(
'https://stream.twitter.com/1.1/statuses/filter.json?track=' + keyword,
'2719762452-CEg9qMDKpnR2d9tjx54xu11VFu6vJzvR5TnbNaM', //test user token
'oo6DDZlflz6kqXRQQRQGCKiwtZLnxF5Yhidd5GXvJ1Jsi', //test user secret
function (error, data, response){
console.log("", data.toString("utf8"));
response.on("data", function(d){
console.log("", d.toString("utf8"));
var tweet = JSON.parse(d);
console.log("tweet: " + tweet.text);
var StreamSearch = function(topic){
var filterUrl = "https://stream.twitter.com/1.1/statuses/filter.json" + "?track=" + topic;
var request = oa.get(filterUrl, access_token, access_token_secret );
return request;
}
// Setup key/secret for authentication and API endpoint URL
var configuration = {
api_url: "https://api.tradeking.com/v1/accounts/xxxxxxxx/orders.xml",
consumer_key: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
consumer_secret: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
access_token: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
access_secret: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
}
// Setup the OAuth Consumer
var tradeking_consumer = new oauth.OAuth(
"https://developers.tradeking.com/oauth/request_token",
"https://developers.tradeking.com/oauth/access_token",
configuration.consumer_key,
configuration.consumer_secret,
"1.0",
"http://mywebsite.com/tradeking/callback",
"HMAC-SHA1");
body = ['<FIXML xmlns="http://www.fixprotocol.org/FIXML-5-0-SP2">',
'<Order TmInForce="0" Typ="1" Side="1" Acct="60556275">',
'<Instrmt SecTyp="CS" Sym="GGP"/>','<OrdQty Qty="123"/>',
'</Order>',
'</FIXML>'].join();
// Make a request to the API endpoint
// Manually update the access token/secret as parameters. Typically this would be done through an OAuth callback when
// authenticating other users.
app.get('/expert1', function(req, res) {
console.log(JSON.stringify(req.user));
if(req.user.provider === 'twitter') {
console.log("THE TOKEN FOR MUKUND IS: " + req.user.oauth_token);
console.log("THE VERIFIER IS: " + req.user.oauth_verify);
userCred = {
userId : req.user.id,
firstName : req.user.displayName.split(' ')[0],
lastName : req.user.displayName.split(' ')[1],
profilePic : req.user.photos[0].value,
oauthToken : req.user.oauth_token,
oauthVerify : req.user.oauth_verify
};
console.log("The profile ID for me is: " + JSON.stringify(twitterUsers[req.user.id]));
var user = new User1();
user.userId = userCred.userId;
user.firstName = userCred.firstName;
user.lastName = userCred.lastName;
user.profilePic = userCred.profilePic;
user.save(function(err) {
if (err){
console.log('error WE CANNOT SAVE THIS USER TO THE DB!!');
}
});
}
else if(req.user.provider === 'linkedin') {
userCred = {
userId : req.user.id,
firstName : req.user.name.givenName,
lastName : req.user.name.familyName,
profilePic : req.user._json.pictureUrl,
};
var user = new User1();
user.userId = userCred.userId;
user.firstName = userCred.firstName;
user.lastName = userCred.lastName;
user.profilePic = userCred.profilePic;
user.save(function(err) {
if (err){
console.log('error');
}
});
}
tweeter = new OAuth(
"https://api.twitter.com/oauth/request_token",
"https://api.twitter.com/oauth/access_token",
TWITTER_CONSUMER_KEY,
TWITTER_CONSUMER_SECRET,
"1.0",
"http://*****:*****@Aalndy'}, "application/json",
function (error, data, response2) {
if(error){
console.log('Error: Something is wrong.\n'+JSON.stringify(error)+'\n');
for (i in response2) {
out = i + ' : ';
try {
out+=response2[i];
} catch(err) {}
out += '/n';
console.log(out);
}
}else{
console.log('Twitter status updated.\n');
console.log(response2+'\n');
}
});
/* request.post({
url: 'https://api.twitter.com/1.1/statuses/update.json',
headers: {
'Content-Type' : 'application/x-www-form-urlencoded',
'Authorization' : 'OAuth'
}},function(error, response, body){
console.log(body);
});
*/
res.render('expert1', {
user: userCred
});
});
function get(path, params, token, callback) {
oAuth.get(baseURI + path + '?' + querystring.stringify(params),
token.oauth_token, token.oauth_token_secret, requestCallback(callback));
}
oa.getOAuthRequestToken(function(error, oauth_token, oauth_token_secret, results){
if(error) sys.puts('error :' + error)
else {
sys.puts('oauth_token: ' + oauth_token)
sys.puts('oauth_token_secret: ' + oauth_token_secret)
sys.puts('requestoken results: ' + sys.inspect(results))
sys.puts("Requesting access token")
oa.getOauthAccessToken(oauth_token, oauth_token_secret, 'verifier', function(error, oauth_access_token, oauth_access_token_secret, results2) {
sys.puts('oauth_access_token: ' + oauth_access_token)
sys.puts('oauth_token_secret: ' + oauth_access_token_secret)
sys.puts('accesstoken results: ' + sys.inspect(results2))
sys.puts("Requesting access token")
var data= "";
oa.getProtectedResource("http://localhost:3000/fetch/unicorns?foo=bar&too=roo", "GET", oauth_access_token, oauth_access_token_secret, function (error, data, response) {
sys.puts(sys.inspect(error));
sys.puts(data);
});
});
}
})
function twit(data) {
//disconnect before attempting to reconnect to the streaming api
if (request) {
try{
request.removeAllEventListeners();
}catch(e){
console.log(e);
}
try {
request.abort();
} catch (e) {
console.log(e);
}
request = null;
}
//clear out the parser - TODO: don't recreate on reconnection attempts
if (parser) {
disconnect();
}
/**Asking for delimited data by attaching delimited = length to the post body.
* https://dev.twitter.com/docs/streaming-apis/parameters#delimited
* 'The 1953 indicates how many bytes to read off of the stream to get the
* rest of the Tweet (including \r\n). The next length delimiter will occur exactly after 1953 bytes.'
**/
data.params.delimited = 'length';
parser = new Parser();
parser.setTracking(data.params.track, data.params.hashOn);
delete data.params.hashOn;
request = oa.post(twitterURL, config.ACCESS_TOKEN, config.ACCESS_TOKEN_SECRET, data.params, null);
parser.setTimer(1000);//defaults to 1000 anyhow
parser.on('tracking', function(data) {
genericEmitter.emit('toSocket', 'tracking', data);
});
request.on('response', function(response) {
response.setEncoding('utf8');
response.pipe(parser, {
end : false
});
response.on('error', function(){
process.stdout.write('streaming error\n');
});
response.on('end', function () {
process.stdout.write('stream ended - goodbye' + response.statusCode + '\n');
var delay;
//status ok - likely due to logging back in with the same credentials - wait 30 seconds and try connecting again
if (response.statusCode == 200) {
delay = 1000 * 30;
} else if (response.statusCode == 420) {
//too many attempts to connect in a short period of time - need to wait at least 5 minutes before trying - rate limited
delay = 1000 * 60 * 5;
}
if (delay) setTimeout(function () {
twit(data);
}, delay);
});
});
request.end();
}
function postPictureToTwitter(tweet, photoName, callback){
var responseData = "";
var data = require("fs").readFileSync(__dirname + "/public/mustacheimages/" + photoName);
var oauth = new OAuth(
'https://api.twitter.com/oauth/request_token',
'https://api.twitter.com/oauth/access_token',
keys.consumerKey, keys.consumerSecret,
'1.0', null, 'HMAC-SHA1');
var crlf = "\r\n";
var boundary = '---------------------------10102754414578508781458777923';
var separator = '--' + boundary;
var footer = crlf + separator + '--' + crlf;
var fileHeader = 'Content-Disposition: file; name="media"; filename="' + photoName + '"';
var contents = separator + crlf
+ 'Content-Disposition: form-data; name="status"' + crlf
+ crlf
+ tweet + crlf
+ separator + crlf
+ fileHeader + crlf
+ 'Content-Type: image/png' + crlf
+ crlf;
var multipartBody = Buffer.concat([
new Buffer(contents),
data,
new Buffer(footer)]);
var hostname = 'upload.twitter.com';
var authorization = oauth.authHeader(
'https://upload.twitter.com/1/statuses/update_with_media.json',
keys.token, keys.secret, 'POST');
var headers = {
'Authorization': authorization,
'Content-Type': 'multipart/form-data; boundary=' + boundary,
'Host': hostname,
'Content-Length': multipartBody.length,
'Connection': 'Keep-Alive'
};
var options = {
host: hostname,
port: 443,
path: '/1/statuses/update_with_media.json',
method: 'POST',
headers: headers
};
var request = https.request(options);
request.write(multipartBody);
request.end();
request.on('error', function (err) {
console.log('Error: Something is wrong.\n'+JSON.stringify(err)+'\n');
});
request.on('response', function (response) {
response.setEncoding('utf8');
response.on('data', function (chunk) {
responseData += chunk.toString();
//console.log(chunk.toString());
});
response.on('end', function () {
//console.log(response.statusCode +'\n');
//res.end();
if(callback && typeof(callback)==="function")
callback(responseData);
});
});
}
function (){
tweeter.getProtectedResource('https://api.twitter.com/1.1/users/show.json?screen_name='+twitterhandle, "GET", keys.token, keys.secret, this);
},
webserver.configure('development', function(){
webserver.use(express.errorHandler({ dumpExceptions: true, showStack: true }));
});
webserver.configure('production', function(){
webserver.use(express.errorHandler());
});
if (!module.parent) {
webserver.listen(3000);
}
// authentication for other twitter requests
var tweeter = new OAuth(
"https://api.twitter.com/oauth/request_token",
"https://api.twitter.com/oauth/access_token",
keys.consumerKey,
keys.consumerSecret,
"1.0",
null,
"HMAC-SHA1"
);
/**
* Socket.IO
*/
var io = socketio.listen(webserver);
io.set('log level', 0);
io.sockets.on('connection', function (socket) {
exports.init = function(callback) {
var alldata = {
users: {
'timsavery': undefined,
'csanz': undefined,
'rekatz': undefined,
},
cards: []
};
var oa = new OAuth(
"http://sandbox-api.geekli.st/v1/oauth/request_token",
"http://sandbox-api.geekli.st/v1/oauth/access_token",
process.env.GKLST_CONSUMER_KEY,
process.env.GKLST_CONSUMER_SECRET,
"1.0",
null,
"HMAC-SHA1"
);
async.series([
function(seriesCallback) {
async.map(Object.keys(alldata.users), function(user, callback) {
oa.getProtectedResource('http://sandbox-api.geekli.st/v1/users/' + user, 'GET', process.env.GKLST_ACCESS_TOKEN, process.env.GKLST_ACCESS_TOKEN_SECRET, function (error, data, response) {
if (error) callback(error, null);
alldata.users[user] = JSON.parse(data);
request.get(alldata.users[user].data.avatar.large, function(err, response, body) {
fs.readFile('public/img/geeks/' + user + '-large.jpg', 'binary', function(err, data) {
im.resize({
srcPath: 'public/img/geeks/' + user + '-large.jpg',
dstPath: 'public/img/geeks/' + user + '.jpg',
width: 300
}, function() {
callback();
});
});
}).pipe(fs.createWriteStream('public/img/geeks/' + user + '-large.jpg'));
});
}, seriesCallback);
},
function(seriesCallback) {
async.map(Object.keys(alldata.users), function(user, callback) {
oa.getProtectedResource('http://sandbox-api.geekli.st/v1/users/' + user + '/cards', 'GET', process.env.GKLST_ACCESS_TOKEN, process.env.GKLST_ACCESS_TOKEN_SECRET, function (error, data, response) {
var cardsResult = JSON.parse(data);
for (var cardIdx=0; cardIdx<cardsResult.data.cards.length; cardIdx++) {
alldata.cards.push({
headline: cardsResult.data.cards[cardIdx].headline,
user: {
name: user,
avatar: '/img/geeks/' + user + '.jpg'
}
});
}
callback();
});
}, seriesCallback);
}
], function() {
callback(alldata);
});
};
module.exports = function(RED) {
"use strict";
var ntwitter = require('twitter-ng');
var OAuth= require('oauth').OAuth;
function TwitterNode(n) {
RED.nodes.createNode(this,n);
this.screen_name = n.screen_name;
}
RED.nodes.registerType("twitter-credentials",TwitterNode,{
credentials: {
screen_name: {type:"text"},
access_token: {type: "password"},
access_token_secret: {type:"password"}
}
});
function TwitterInNode(n) {
RED.nodes.createNode(this,n);
this.active = true;
this.user = n.user;
//this.tags = n.tags.replace(/ /g,'');
this.tags = n.tags;
this.twitter = n.twitter;
this.topic = n.topic||"tweets";
this.twitterConfig = RED.nodes.getNode(this.twitter);
var credentials = RED.nodes.getCredentials(this.twitter);
if (credentials && credentials.screen_name == this.twitterConfig.screen_name) {
var twit = new ntwitter({
consumer_key: "OKjYEd1ef2bfFolV25G5nQ",
consumer_secret: "meRsltCktVMUI8gmggpXett7WBLd1k0qidYazoML6g",
access_token_key: credentials.access_token,
access_token_secret: credentials.access_token_secret
});
//setInterval(function() {
// twit.get("/application/rate_limit_status.json",null,function(err,cb) {
// console.log("direct_messages:",cb["resources"]["direct_messages"]);
// });
//
//},10000);
var node = this;
if (this.user === "user") {
node.poll_ids = [];
node.since_ids = {};
var users = node.tags.split(",");
for (var i=0;i<users.length;i++) {
var user = users[i].replace(" ","");
twit.getUserTimeline({
screen_name:user,
trim_user:0,
count:1
},function() {
var u = user+"";
return function(err,cb) {
if (err) {
node.error(err);
return;
}
if (cb[0]) {
node.since_ids[u] = cb[0].id_str;
} else {
node.since_ids[u] = '0';
}
node.poll_ids.push(setInterval(function() {
twit.getUserTimeline({
screen_name:u,
trim_user:0,
since_id:node.since_ids[u]
},function(err,cb) {
if (cb) {
for (var t=cb.length-1;t>=0;t-=1) {
var tweet = cb[t];
var where = tweet.user.location||"";
var la = tweet.lang || tweet.user.lang;
//console.log(tweet.user.location,"=>",tweet.user.screen_name,"=>",pay);
var msg = { topic:node.topic+"/"+tweet.user.screen_name, payload:tweet.text, location:where, lang:la, tweet:tweet };
node.send(msg);
if (t == 0) {
node.since_ids[u] = tweet.id_str;
}
}
}
if (err) {
node.error(err);
}
});
},60000));
}
}());
}
} else if (this.user === "dm") {
node.poll_ids = [];
twit.getDirectMessages({
screen_name:node.twitterConfig.screen_name,
trim_user:0,
count:1
},function(err,cb) {
if (err) {
node.error(err);
return;
}
if (cb[0]) {
node.since_id = cb[0].id_str;
} else {
node.since_id = '0';
}
node.poll_ids.push(setInterval(function() {
twit.getDirectMessages({
screen_name:node.twitterConfig.screen_name,
trim_user:0,
since_id:node.since_id
},function(err,cb) {
if (cb) {
for (var t=cb.length-1;t>=0;t-=1) {
var tweet = cb[t];
var msg = { topic:node.topic+"/"+tweet.sender.screen_name, payload:tweet.text, tweet:tweet };
node.send(msg);
if (t == 0) {
node.since_id = tweet.id_str;
}
}
}
if (err) {
node.error(err);
}
});
},120000));
});
} else if (this.tags !== "") {
try {
var thing = 'statuses/filter';
if (this.user === "true") { thing = 'user'; }
var st = { track: [node.tags] };
var bits = node.tags.split(",");
if ((bits.length > 0) && (bits.length % 4 == 0)) {
if ((Number(bits[0]) < Number(bits[2])) && (Number(bits[1]) < Number(bits[3]))) {
st = { locations: node.tags };
}
else {
node.log("possible bad geo area format. Should be lower-left lon, lat, upper-right lon, lat");
}
}
var setupStream = function() {
if (node.active) {
twit.stream(thing, st, function(stream) {
//console.log(st);
//twit.stream('user', { track: [node.tags] }, function(stream) {
//twit.stream('site', { track: [node.tags] }, function(stream) {
//twit.stream('statuses/filter', { track: [node.tags] }, function(stream) {
node.stream = stream;
stream.on('data', function(tweet) {
//console.log(tweet.user);
if (tweet.user !== undefined) {
var where = tweet.user.location||"";
var la = tweet.lang || tweet.user.lang;
//console.log(tweet.user.location,"=>",tweet.user.screen_name,"=>",pay);
var msg = { topic:node.topic+"/"+tweet.user.screen_name, payload:tweet.text, location:where, lang:la, tweet:tweet };
node.send(msg);
}
});
stream.on('limit', function(tweet) {
node.log("tweet rate limit hit");
});
stream.on('error', function(tweet,rc) {
if (rc == 420) {
node.warn("Twitter rate limit hit");
} else {
node.warn("Stream error:"+tweet.toString()+" ("+rc+")");
}
setTimeout(setupStream,10000);
});
stream.on('destroy', function (response) {
if (this.active) {
node.warn("twitter ended unexpectedly");
setTimeout(setupStream,10000);
}
});
});
}
}
setupStream();
}
catch (err) {
node.error(err);
}
} else {
this.error("Invalid tag property");
}
} else {
this.error("missing twitter credentials");
}
this.on('close', function() {
if (this.stream) {
this.active = false;
this.stream.destroy();
}
if (this.poll_ids) {
for (var i=0;i<this.poll_ids.length;i++) {
clearInterval(this.poll_ids[i]);
}
}
});
}
RED.nodes.registerType("twitter in",TwitterInNode);
function TwitterOutNode(n) {
RED.nodes.createNode(this,n);
this.topic = n.topic;
this.twitter = n.twitter;
this.twitterConfig = RED.nodes.getNode(this.twitter);
var credentials = RED.nodes.getCredentials(this.twitter);
var node = this;
if (credentials && credentials.screen_name == this.twitterConfig.screen_name) {
var twit = new ntwitter({
consumer_key: "OKjYEd1ef2bfFolV25G5nQ",
consumer_secret: "meRsltCktVMUI8gmggpXett7WBLd1k0qidYazoML6g",
access_token_key: credentials.access_token,
access_token_secret: credentials.access_token_secret
}).verifyCredentials(function (err, data) {
if (err) {
node.error("Error verifying credentials: " + err);
} else {
node.on("input", function(msg) {
if (msg != null) {
if (msg.payload.length > 140) {
msg.payload = msg.payload.slice(0,139);
node.warn("Tweet greater than 140 : truncated");
}
twit.updateStatus(msg.payload, function (err, data) {
if (err) node.error(err);
});
}
});
}
});
}
}
RED.nodes.registerType("twitter out",TwitterOutNode);
var oa = new OAuth(
"https://api.twitter.com/oauth/request_token",
"https://api.twitter.com/oauth/access_token",
"OKjYEd1ef2bfFolV25G5nQ",
"meRsltCktVMUI8gmggpXett7WBLd1k0qidYazoML6g",
"1.0",
null,
"HMAC-SHA1"
);
RED.httpAdmin.get('/twitter-credentials/:id/auth', function(req, res){
var credentials = {};
oa.getOAuthRequestToken({
oauth_callback: req.query.callback
},function(error, oauth_token, oauth_token_secret, results){
if (error) {
var resp = '<h2>Oh no!</h2>'+
'<p>Something went wrong with the authentication process. The following error was returned:<p>'+
'<p><b>'+error.statusCode+'</b>: '+error.data+'</p>'+
'<p>One known cause of this type of failure is if the clock is wrong on system running Node-RED.';
res.send(resp)
} else {
credentials.oauth_token = oauth_token;
credentials.oauth_token_secret = oauth_token_secret;
res.redirect('https://twitter.com/oauth/authorize?oauth_token='+oauth_token)
RED.nodes.addCredentials(req.params.id,credentials);
}
});
});
RED.httpAdmin.get('/twitter-credentials/:id/auth/callback', function(req, res, next){
var credentials = RED.nodes.getCredentials(req.params.id);
credentials.oauth_verifier = req.query.oauth_verifier;
oa.getOAuthAccessToken(
credentials.oauth_token,
credentials.token_secret,
credentials.oauth_verifier,
function(error, oauth_access_token, oauth_access_token_secret, results){
if (error){
console.log(error);
res.send("yeah something broke.");
} else {
credentials = {};
credentials.access_token = oauth_access_token;
credentials.access_token_secret = oauth_access_token_secret;
credentials.screen_name = "@"+results.screen_name;
RED.nodes.addCredentials(req.params.id,credentials);
res.send("<html><head></head><body>Authorised - you can close this window and return to Node-RED</body></html>");
}
}
);
});
}
function tweetQuery(doc) {
console.log(doc);
var tweetID = doc.tweet_id;
var retweets = [];
consumer.get("http://api.twitter.com/1/statuses/retweets/" + tweetID + ".json?include_entities=true&trim_user=0", token, secret, function (error, data, response) {
if (error) {
console.log("Error getting tweet : " + sys.inspect(error), 500);
return;
}
else {
var parsedData = JSON.parse(data);
for (var x = 0; x < parsedData.length; x++) {
var twt = parsedData[x];
console.log(twt);
var retweet = 1;
var name = twt.user.name;
var description = twt.user.description;
var followers_count = twt.user.followers_count;
var location = twt.user.location;
var content = twt.text;
var time = twt.created_at;
var id = tweetID;
var retweet = twt.retweet_count;
var hashtag = twt.entities.hashtags;
var user_mentions = twt.entities.user_mentions;
retweets.push({
name: name,
description: description,
location: location,
followers_count: followers_count,
content: content,
time: time,
tweet_id: id,
retweet_count: retweet,
hashtags: hashtag,
user_mentions: user_mentions
});
}
}
db.merge(
doc._id,
{
retweets: retweets
}
,
function (err, res) {
if (err) {
sys.puts(err);
} else {
console.log("ADDED " + doc._id);
}
}
);
});
}
//
// Middleware
//
function oauth(req, res, next) {
console.log('OAuth process started');
var apiName = req.body.apiName,
apiConfig = apisConfig[apiName];
if (apiConfig.oauth) {
var apiKey = req.body.apiKey || req.body.key,
apiSecret = req.body.apiSecret || req.body.secret,
refererURL = url.parse(req.headers.referer),
callbackURL = refererURL.protocol + '//' + refererURL.host + '/authSuccess/' + apiName,
oa = new OAuth(apiConfig.oauth.requestURL,
apiConfig.oauth.accessURL,
apiKey,
apiSecret,
apiConfig.oauth.version,
callbackURL,
apiConfig.oauth.crypt);
if (config.debug) {
console.log('OAuth type: ' + apiConfig.oauth.type);
console.log('Method security: ' + req.body.oauth);
console.log('Session authed: ' + req.session[apiName]);
console.log('apiKey: ' + apiKey);
console.log('apiSecret: ' + apiSecret);
}
// Check if the API even uses OAuth, then if the method requires oauth, then if the session is not authed
if (apiConfig.oauth.type == 'three-legged' && req.body.oauth == 'authrequired' && (!req.session[apiName] || !req.session[apiName].authed) ) {
if (config.debug) {
console.log('req.session: ' + util.inspect(req.session));
console.log('headers: ' + util.inspect(req.headers));
console.log(util.inspect(oa));
console.log('sessionID: ' + util.inspect(req.sessionID));
}
oa.getOAuthRequestToken(function(err, oauthToken, oauthTokenSecret, results) {
if (err) {
res.send("Error getting OAuth request token : " + util.inspect(err), 500);
} else {
// Unique key using the sessionID and API name to store tokens and secrets
var key = req.sessionID + ':' + apiName;
db.set(key + ':apiKey', apiKey, redis.print);
db.set(key + ':apiSecret', apiSecret, redis.print);
db.set(key + ':requestToken', oauthToken, redis.print);
db.set(key + ':requestTokenSecret', oauthTokenSecret, redis.print);
// Set expiration to same as session
db.expire(key + ':apiKey', 1209600000);
db.expire(key + ':apiSecret', 1209600000);
db.expire(key + ':requestToken', 1209600000);
db.expire(key + ':requestTokenSecret', 1209600000);
res.send({'signin': apiConfig.oauth.signinURL + oauthToken });
}
});
} else if (apiConfig.oauth.type == 'two-legged' && req.body.oauth == 'authrequired') {
// Two legged stuff... for now nothing.
next();
} else {
next();
}
} else {
next();
}
}
//
// processRequest - handles API call
//
function processRequest(req, res, next) {
if (config.debug) {
console.log(util.inspect(req.body, null, 3));
}
var reqQuery = req.body,
customHeaders = {},
params = reqQuery.params || {},
locations = reqQuery.locations || {},
methodURL = reqQuery.methodUri,
httpMethod = reqQuery.httpMethod,
apiKey = reqQuery.apiKey,
apiSecret = reqQuery.apiSecret,
apiName = reqQuery.apiName,
apiConfig = apisConfig[apiName],
key = req.sessionID + ':' + apiName,
implicitAccessToken = reqQuery.accessToken;
for (var param in params) {
if (params.hasOwnProperty(param)) {
if (params[param] !== '') {
if (locations[param] == 'header') {
// Extract custom headers from the params
customHeaders[param] = params[param];
delete params[param];
} else {
// Replace placeholders in the methodURL with matching params
// URL params are prepended with ":"
var regx = new RegExp(':' + param);
// If the param is actually a part of the URL, put it in the URL and remove the param
if (!!regx.test(methodURL)) {
methodURL = methodURL.replace(regx, encodeURIComponent(params[param]));
delete params[param]
}
}
} else {
delete params[param]; // Delete blank params
}
}
}
var baseHostInfo = apiConfig.baseURL.split(':');
var baseHostUrl = baseHostInfo[0],
baseHostPort = (baseHostInfo.length > 1) ? baseHostInfo[1] : "";
var headers = {};
for (var configHeader in apiConfig.headers) {
if (apiConfig.headers.hasOwnProperty(configHeader)) {
headers[configHeader] = apiConfig.headers[configHeader];
}
}
for (var customHeader in customHeaders) {
if (customHeaders.hasOwnProperty(customHeader)) {
headers[customHeader] = customHeaders[customHeader];
}
}
var paramString = query.stringify(params),
privateReqURL = apiConfig.protocol + '://' + apiConfig.baseURL + apiConfig.privatePath + methodURL + ((paramString.length > 0) ? '?' + paramString : ""),
options = {
headers: headers,
protocol: apiConfig.protocol + ':',
host: baseHostUrl,
port: baseHostPort,
method: httpMethod,
path: apiConfig.publicPath + methodURL// + ((paramString.length > 0) ? '?' + paramString : "")
};
if (['POST','DELETE','PUT'].indexOf(httpMethod) !== -1) {
var body = undefined;
/*if (params.body) {
try {
body = JSON.parse(params.body);
} catch (error) {
//just ignore and send normally
}
}*/
var requestBody = params.body || query.stringify(params);
}
if (apiConfig.oauth) {
console.log('Using OAuth');
// Three legged OAuth
if (apiConfig.oauth.type == 'three-legged' && (reqQuery.oauth == 'authrequired' || (req.session[apiName] && req.session[apiName].authed))) {
if (config.debug) {
console.log('Three Legged OAuth');
}
db.mget([key + ':apiKey',
key + ':apiSecret',
key + ':accessToken',
key + ':accessTokenSecret'
],
function(err, results) {
var apiKey = (typeof reqQuery.apiKey == "undefined" || reqQuery.apiKey == "undefined")?results[0]:reqQuery.apiKey,
apiSecret = (typeof reqQuery.apiSecret == "undefined" || reqQuery.apiSecret == "undefined")?results[1]:reqQuery.apiSecret,
accessToken = results[2],
accessTokenSecret = results[3];
var oa = new OAuth(apiConfig.oauth.requestURL || null,
apiConfig.oauth.accessURL || null,
apiKey || null,
apiSecret || null,
apiConfig.oauth.version || null,
null,
apiConfig.oauth.crypt);
if (config.debug) {
console.log('Access token: ' + accessToken);
console.log('Access token secret: ' + accessTokenSecret);
console.log('key: ' + key);
}
oa.getProtectedResource(privateReqURL, httpMethod, accessToken, accessTokenSecret, function (error, data, response) {
req.call = privateReqURL;
if (error) {
console.log('Got error: ' + util.inspect(error));
if (error.data == 'Server Error' || error.data == '') {
req.result = 'Server Error';
} else {
req.result = error.data;
}
res.statusCode = error.statusCode;
next();
} else {
req.resultHeaders = response.headers;
req.result = JSON.parse(data);
next();
}
});
}
);
} else if (apiConfig.oauth.type == 'two-legged' && reqQuery.oauth == 'authrequired') { // Two-legged
if (config.debug) {
console.log('Two Legged OAuth');
}
var body,
oa = new OAuth(null,
null,
apiKey || null,
apiSecret || null,
apiConfig.oauth.version || null,
null,
apiConfig.oauth.crypt);
var resource = options.protocol + '://' + options.host + options.path,
cb = function(error, data, response) {
if (error) {
if (error.data == 'Server Error' || error.data == '') {
req.result = 'Server Error';
} else {
console.log(util.inspect(error));
body = error.data;
}
res.statusCode = error.statusCode;
} else {
var responseContentType = response.headers['content-type'];
if (/application\/javascript/.test(responseContentType)
|| /text\/javascript/.test(responseContentType)
|| /application\/json/.test(responseContentType)) {
body = JSON.parse(data);
}
}
// Set Headers and Call
if (response) {
req.resultHeaders = response.headers || 'None';
} else {
req.resultHeaders = req.resultHeaders || 'None';
}
req.call = url.parse(options.host + options.path);
req.call = url.format(req.call);
// Response body
req.result = body;
next();
};
switch (httpMethod) {
case 'GET':
console.log(resource);
oa.get(resource, '', '',cb);
break;
case 'PUT':
case 'POST':
oa.post(resource, '', '', JSON.stringify(obj), null, cb);
break;
case 'DELETE':
oa.delete(resource,'','',cb);
break;
}
} else {
// API uses OAuth, but this call doesn't require auth and the user isn't already authed, so just call it.
unsecuredCall();
}
} else if (apiConfig.oauth2) {
console.log('Using OAuth2');
if (implicitAccessToken) {
db.mset([key + ':access_token', implicitAccessToken
], function(err, results2) {
req.session[apiName] = {};
req.session[apiName].authed = true;
if (config.debug) {
console.log('session[apiName].authed: ' + util.inspect(req.session));
}
});
}
if (reqQuery.oauth == 'authrequired' || (req.session[apiName] && req.session[apiName].authed)) {
if (config.debug) {
console.log('Session authed');
}
db.mget([key + ':apiKey',
key + ':apiSecret',
key + ':access_token',
key + ':refresh_token'
],
function(err, results) {
var apiKey = (typeof reqQuery.apiKey == "undefined" || reqQuery.apiKey == "undefined")?results[0]:reqQuery.apiKey,
apiSecret = (typeof reqQuery.apiSecret == "undefined" || reqQuery.apiSecret == "undefined")?results[1]:reqQuery.apiSecret,
access_token = (implicitAccessToken) ? implicitAccessToken : results[2],
refresh_token = results[3];
var oa = new OAuth2(apiKey,
apiSecret,
apiConfig.oauth2.baseSite,
apiConfig.oauth2.authorizeURL,
apiConfig.oauth2.accessTokenURL);
if (apiConfig.oauth2.tokenName) {
oa.setAccessTokenName(apiConfig.oauth2.tokenName);
}
if (true || config.debug) {
console.log('Api key: ' + apiKey);
console.log('Access token: ' + access_token);
console.log('Access token secret: ' + refresh_token);
console.log('key: ' + key);
}
headers['apikey'] = apiKey;
if (apiConfig.oauth2.authorizationHeader && (apiConfig.oauth2.authorizationHeader == 'Y')) {
headers['Authorization'] = "Bearer " + access_token;
}
oa._request(httpMethod, privateReqURL, headers, requestBody, access_token, function (error, data, response) {
req.call = privateReqURL;
if (error) {
console.log('Got error: ' + util.inspect(error));
if (error.data == 'Server Error' || error.data == '') {
req.result = 'Server Error';
} else {
req.result = error.data;
}
res.statusCode = error.statusCode;
next();
} else {
req.resultHeaders = response.headers;
req.result = JSON.parse(data);
next();
}
});
}
);
} else {
// API uses OAuth, but this call doesn't require auth and the user isn't already authed, so just call it.
unsecuredCall();
}
} else {
// API does not use authentication
unsecuredCall();
}
// Unsecured API Call helper
function unsecuredCall() {
db.mget([key + ':apiKey'], function(err, results) {
var apiKey = (typeof reqQuery.apiKey == "undefined" || reqQuery.apiKey == "undefined")?results[0]:reqQuery.apiKey;
console.log('Unsecured Call');
if (['POST','PUT','DELETE'].indexOf(httpMethod) === -1) {
options.path += ((paramString.length > 0) ? '?' + paramString : "");
}
// Add API Key to params, if any.
if (apiKey != '' && apiKey != 'undefined' && apiKey != undefined) {
if (options.path.indexOf('?') !== -1) {
options.path += '&';
}
else {
options.path += '?';
}
options.path += apiConfig.keyParam + '=' + apiKey;
}
// Perform signature routine, if any.
if (apiConfig.signature) {
var timeStamp, sig;
if (apiConfig.signature.type == 'signed_md5') {
// Add signature parameter
timeStamp = Math.round(new Date().getTime()/1000);
sig = crypto.createHash('md5').update('' + apiKey + apiSecret + timeStamp + '').digest(apiConfig.signature.digest);
options.path += '&' + apiConfig.signature.sigParam + '=' + sig;
}
else if (apiConfig.signature.type == 'signed_sha256') { // sha256(key+secret+epoch)
// Add signature parameter
timeStamp = Math.round(new Date().getTime()/1000);
sig = crypto.createHash('sha256').update('' + apiKey + apiSecret + timeStamp + '').digest(apiConfig.signature.digest);
options.path += '&' + apiConfig.signature.sigParam + '=' + sig;
}
}
// Setup headers, if any
if (reqQuery.headerNames && reqQuery.headerNames.length > 0) {
if (config.debug) {
console.log('Setting headers');
}
var headers = {};
for (var x = 0, len = reqQuery.headerNames.length; x < len; x++) {
if (config.debug) {
console.log('Setting header: ' + reqQuery.headerNames[x] + ':' + reqQuery.headerValues[x]);
}
if (reqQuery.headerNames[x] != '') {
headers[reqQuery.headerNames[x]] = reqQuery.headerValues[x];
}
}
options.headers = headers;
}
if(options.headers === void 0){
options.headers = {}
}
if (!options.headers['Content-Length']) {
if (requestBody) {
options.headers['Content-Length'] = requestBody.length;
}
else {
options.headers['Content-Length'] = 0;
}
}
if (!options.headers['Content-Type'] && requestBody) {
options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
}
if (config.debug) {
console.log(util.inspect(options));
}
var doRequest;
if (options.protocol === 'https' || options.protocol === 'https:') {
console.log('Protocol: HTTPS');
options.protocol = 'https:';
doRequest = https.request;
} else {
console.log('Protocol: HTTP');
doRequest = http.request;
}
// API Call. response is the response from the API, res is the response we will send back to the user.
var apiCall = doRequest(options, function(response) {
response.setEncoding('utf-8');
if (config.debug) {
console.log('HEADERS: ' + JSON.stringify(response.headers));
console.log('STATUS CODE: ' + response.statusCode);
}
res.statusCode = response.statusCode;
var body = '';
response.on('data', function(data) {
body += data;
});
response.on('end', function() {
delete options.agent;
var responseContentType = response.headers['content-type'];
if (/application\/javascript/.test(responseContentType)
|| /application\/json/.test(responseContentType)) {
console.log(util.inspect(body));
}
// Set Headers and Call
req.resultHeaders = response.headers;
req.call = url.parse(options.host + options.path);
req.call = url.format(req.call);
// Response body
req.result = body;
console.log(util.inspect(body));
next();
})
}).on('error', function(e) {
if (config.debug) {
console.log('HEADERS: ' + JSON.stringify(res.headers));
console.log("Got error: " + e.message);
console.log("Error: " + util.inspect(e));
}
});
if (requestBody) {
apiCall.end(requestBody, 'utf-8');
}
else {
apiCall.end();
}
});
}
}
module.exports = function(clientId, clientSecret) {
var oa = new OAuth(createUrl('/OAuthGetRequestToken'),
createUrl('/OAuthGetAccessToken'),
clientId,
clientSecret,
"1.0",
null,
"HMAC-SHA1");
return {
/**
* Request the request oAuth token
*/
requestToken: function(callback) {
return oa.getOAuthRequestToken(callback);
},
/**
* Create the URL for the oAuth dance
*/
redirect: function(token, params) {
params.oauth_token = token;
var qs = querystring.stringify(params);
return createUrl('/OAuthAuthorizeToken?'+ qs);
},
/**
* Get the oAuth access token
*/
accessToken: function(token, tokenSecret, verifier, callback) {
oa.getOAuthAccessToken(token,
tokenSecret,
verifier,
callback);
},
/**
* Trello middleware to attach trello models to the request
* Only if the session uuid is found
*/
middleware: function() {
var that = this;
return function(req, res, next) {
if (req.session.uuid) {
that.buildFor(req.session.uuid, req, next);
} else {
next();
}
};
},
/**
* Attach the trello models to the request if possible
*/
buildFor: function(uuid, req, next) {
req.getToken(uuid,
function(err, result) {
req.accessToken = result;
req.trello = Models.buildFor(clientId,
result);
next();
});
}
}
}
module.exports = function (api_key, api_secret, callbackURI, unit_system) {
var client = {version: '0.1.0'};
var serializer = Serializer.createSecureSerializer(api_key, api_secret);
var headers = {'Accept': '*/*', 'Connection': 'close', 'User-Agent': 'fitbit-js ' + client.version};
if (typeof unit_system !== 'undefined' && unit_system !== null) headers['Accept-Language'] = unit_system;
var oAuth = new OAuth('http://api.fitbit.com/oauth/request_token',
'http://api.fitbit.com/oauth/access_token',
api_key, api_secret, '1.0', callbackURI,
'HMAC-SHA1', null, headers);
function requestCallback(callback) {
return function (err, data, response) {
if (err) return callback(err, data);
var exception = null;
try {
data = JSON.parse(data);
} catch (e) { exception = e; }
callback(exception, response, data);
};
}
function get(path, params, token, callback) {
oAuth.get(baseURI + path + '?' + querystring.stringify(params),
token.oauth_token, token.oauth_token_secret, requestCallback(callback));
}
function post(path, params, token, callback) {
oAuth.post(baseURI + path, token.oauth_token, token.oauth_token_secret,
params, null, requestCallback(callback));
}
// PUBLIC
client.apiCall = function (method, path, params, callback) {
var token = params.token;
delete params.token;
if (method === 'GET') get(path, params, token, callback);
else if (method === 'POST') post(path, params, token, callback);
}
client.getAccessToken = function (req, res, callback) {
var sess;
if(req.cookies && req.cookies.fitbit_client) {
try { sess = serializer.parse(req.cookies.fitbit_client) }catch(E){ }
}
var qs = url.parse(req.url, true).query;
var has_token = qs && qs.oauth_token,
has_secret = sess && sess.token_secret;
if(has_token && has_secret) { // Access token
oAuth.getOAuthAccessToken(qs.oauth_token,
sess.tokenSecret,
qs.oauth_verifier,
function (error, oauth_token, oauth_token_secret, additionalParameters) {
if (error) return callback(error, null);
callback(null, {oauth_token: oauth_token, oauth_token_secret: oauth_token_secret});
});
} else { // Request token
oAuth.getOAuthRequestToken({oauth_callback: callbackURI},
function (error, oauth_token, oauth_token_secret, oauth_authorize_url, additionalParameters) {
if (error) return callback(error, null);
res.cookie('fitbit_client',
serializer.stringify({token_secret:oauth_token_secret}),
{ path: '/', httpOnly: false }); // stash the secret
res.redirect('http://www.fitbit.com/oauth/authorize?oauth_token=' + oauth_token);
});
}
};
return client;
};
requestToken: function(callback) {
return oa.getOAuthRequestToken(callback);
},
function post(path, params, token, callback) {
oAuth.post(baseURI + path, token.oauth_token, token.oauth_token_secret,
params, null, requestCallback(callback));
}
accessToken: function(token, tokenSecret, verifier, callback) {
oa.getOAuthAccessToken(token,
tokenSecret,
verifier,
callback);
},
exports.getPage = function(pi, endpoint, type, perPage, params, callback) {
var config = pi.config || {};
var auth = pi.auth;
var oa = new OAlib('http://www.flickr.com/services/oauth/request_token'
, 'http://www.flickr.com/services/oauth/access_token'
, pi.auth.consumerKey
, pi.auth.consumerSecret
, '1.0'
, null
, 'HMAC-SHA1'
, null
, {'Accept': '*/*', 'Connection': 'close'});
//var client = new Flickr(auth.consumerKey, auth.consumerSecret);
if (!config[endpoint]) config[endpoint] = {};
if(!config[endpoint].lastPage)
config[endpoint].lastPage = 0;
var thisPage = config[endpoint].lastPage + 1;
params.auth_token = auth.token;
params.per_page = perPage;
params.page = thisPage;
params.api_key = pi.auth.consumerKey;
params.format = 'json';
params.nojsoncallback = '1';
params.method = endpoint;
var type_s = type + 's';
oa.getProtectedResource('http://api.flickr.com/services/rest/?' + qs.stringify(params),
'GET', pi.auth.token, pi.auth.tokenSecret,
function (err, data, response) {
if (err) {
console.error('Network Error: ', err);
return callback(err);
}
var json = JSON.parse(data);
var page;
var pages;
if (json.stat && json.stat == "fail") {
return callback(json.message);
}
try {
page = parseInt(json[type_s].page);
pages = parseInt(json[type_s].pages);
} catch (E) {
console.error("Error processing json: %s from %s", E, response);
return callback("Error processing the json");
}
if(page > pages) { //whoa whoa whoa, bad news bears, page should never be greater than pages
// seems like there is a possiblity of pages === 0 if there are no photos
config[endpoint].lastPage = 0;
config[endpoint].totalPages = -1;
if (pages != 0) console.error('Flickr error, page > total pages: page ==', json[type_s].page, ', pages ==', json[type_s].pages);
} else if(page === pages) { // last page
config[endpoint].lastPage = 0;
config[endpoint].totalPages = -1;
} else { // still paging
config[endpoint].lastPage = page;
config[endpoint].totalPages = pages;
config.nextRun = -1;
}
callback(null, config, json[type_s][type]);
});
}
userMgr._findProviderByUserId(userId, TWITTER_PROVIDER, provider_id, function (err, user, provider) {
if (err) {
log.error(err, meta);
res.status(500).send(err);
return;
}
log.debug(provider, meta);
var count = 20;
var api_url = TWITTER_API_URL+"/statuses/user_timeline.json?screen_name="+ provider.providerId +
"&count=" + count;
if (last_id) {
api_url += "&";
api_url += "max_id=" + last_id;
}
log.debug(api_url, meta);
objOAuth.get(api_url, provider.token, provider.tokenSecret, function (error, body, response) {
if(error) {
log.error(error, meta);
log.error(response, meta);
res.status(error.statusCode).send(error);
return;
}
var result;
try {
result = JSON.parse(body);
}
catch(e) {
log.error(e, meta);
log.silly(body, meta);
res.status(500).send(e);
return;
}
log.debug(result);
if(!result.length) {
error = new Error("result is empty!");
log.error(error, meta);
log.error(result, meta);
res.status(500).send(error);
return;
}
var botPostList = new botFormat.BotPostList(TWITTER_PROVIDER, blog_id);
var postUrl = 'https://twitter.com';
postUrl += '/' + blog_id + '/status';
for (var i = 0; i < result.length; i += 1) {
var raw_post = result[i];
if (after) {
var post_date = new Date(raw_post.created_at);
var after_date = new Date(after);
if (post_date < after_date) {
//log.debug('post is before');
continue;
}
}
//https://twitter.com/kimalec7/status/599212089035476994
postUrl += '/' + raw_post.id_str;
var botPost = new botFormat.BotTextPost(raw_post.id_str, raw_post.text, raw_post.created_at, postUrl,
'', [], _convertBotTags(raw_post.entities.hashtags), []);
botPostList.posts.push(botPost);
botPostList.stopReculsive = false;
}
if(!after)
{
if(!(botPostList.posts[i-1])) {
error = new Error("posts in undefined !!");
log.error(error, meta);
res.status(500).send(error);
return;
}
if( (last_id === botPostList.posts[i-1].id.toString()) &&
(result.length === 1) ) {
log.debug("stop Recursive!!!!!", meta);
botPostList.stopReculsive = true;
}
}
res.send(botPostList);
});
});
function OAuth(consumer_key, consumer_secret, callback_url){
oauth.OAuth.call(this, getRequestTokenUrl, getAccessTokenUrl, consumer_key, consumer_secret, '1.0', callback_url, "HMAC-SHA1");
}
function F(args) {
return OAuth.apply(this, args);
}
var OAuth = require('oauth').OAuth;
var byline = require('byline');
var config = require('./config');
var byline = require('byline');
var oa = new OAuth('http://twitter.com/oauth/request_token',
'http://twitter.com/oauth/access_token',
config.consumer_key,
config.consumer_secret,
'1.0A', null, 'HMAC-SHA1');
var endpoint = 'https://userstream.twitter.com/1.1/user.json';
var req = oa.get(endpoint, config.access_token, config.access_secret);
req.on('response', function (res) {
res.setEncoding('utf8');
var ls = byline.createLineStream(res);
ls.on('data', function(line) {
if(line != '') {
var data = JSON.parse(line);
console.log(data);
}
});
ls.on('end', function () {
console.log('--- END ---');
});
});
req.end();
//
// processRequest - handles API call
//
function processRequest(req, res, next) {
if (config.debug) {
console.log("- processRequest() called");
console.log(util.inspect(req.body, null, 3));
};
var reqQuery = req.body,
params = reqQuery.params || {},
methodURL = reqQuery.methodUri,
httpMethod = reqQuery.httpMethod,
apiKey = reqQuery.apiKey,
apiSecret = reqQuery.apiSecret,
apiName = reqQuery.apiName
apiConfig = apisConfig[apiName],
username = reqQuery.username,
key = req.sessionID + ':' + apiName;
// Replace placeholders in the methodURL with matching params
for (var param in params) {
if (params.hasOwnProperty(param)) {
if (params[param] !== '') {
// URL params are prepended with ":"
var regx = new RegExp(':' + param);
// If the param is actually a part of the URL, put it in the URL and remove the param
if (!!regx.test(methodURL)) {
methodURL = methodURL.replace(regx, params[param]);
delete params[param]
}
} else {
delete params[param]; // Delete blank params
}
}
}
var baseHostInfo = apiConfig.baseURL.split(':');
var baseHostUrl = baseHostInfo[0],
baseHostPort = (baseHostInfo.length > 1) ? baseHostInfo[1] : "";
var paramString = query.stringify(params),
privateReqURL = apiConfig.protocol + '://' + apiConfig.baseURL + apiConfig.privatePath + methodURL + ((paramString.length > 0) ? '?' + paramString : ""),
options = {
headers: {},
protocol: apiConfig.protocol + ':',
host: baseHostUrl,
port: baseHostPort,
method: httpMethod,
path: apiConfig.publicPath + methodURL + ((paramString.length > 0) ? '?' + paramString : "")
};
if (apiConfig.oauth) {
console.log('Using OAuth');
// Three legged OAuth
if (apiConfig.oauth.type == 'three-legged' && (reqQuery.oauth == 'authrequired' || (req.session[apiName] && req.session[apiName].authed))) {
if (config.debug) {
console.log('Three Legged OAuth');
};
db.mget([key + ':apiKey',
key + ':apiSecret',
key + ':accessToken',
key + ':accessTokenSecret'
],
function(err, results) {
var apiKey = (typeof reqQuery.apiKey == "undefined" || reqQuery.apiKey == "undefined")?results[0]:reqQuery.apiKey,
apiSecret = (typeof reqQuery.apiSecret == "undefined" || reqQuery.apiSecret == "undefined")?results[1]:reqQuery.apiSecret,
accessToken = results[2],
accessTokenSecret = results[3];
console.log(apiKey);
console.log(apiSecret);
console.log(accessToken);
console.log(accessTokenSecret);
var oa = new OAuth(apiConfig.oauth.requestURL || null,
apiConfig.oauth.accessURL || null,
apiKey || null,
apiSecret || null,
apiConfig.oauth.version || null,
null,
apiConfig.oauth.crypt);
if (config.debug) {
console.log('Access token: ' + accessToken);
console.log('Access token secret: ' + accessTokenSecret);
console.log('key: ' + key);
};
oa.getProtectedResource(privateReqURL, httpMethod, accessToken, accessTokenSecret, function (error, data, response) {
req.call = privateReqURL;
// console.log(util.inspect(response));
if (error) {
console.log('Got error: ' + util.inspect(error));
if (error.data == 'Server Error' || error.data == '') {
req.result = 'Server Error';
} else {
req.result = error.data;
}
res.statusCode = error.statusCode
next();
} else {
req.resultHeaders = response.headers;
req.result = JSON.parse(data);
next();
}
});
}
);
} else if (apiConfig.oauth.type == 'two-legged' && reqQuery.oauth == 'authrequired') { // Two-legged
if (config.debug) {
console.log('Two Legged OAuth');
};
var body,
oa = new OAuth(null,
null,
apiKey || null,
apiSecret || null,
apiConfig.oauth.version || null,
null,
apiConfig.oauth.crypt);
var resource = options.protocol + '://' + options.host + options.path,
cb = function(error, data, response) {
if (error) {
if (error.data == 'Server Error' || error.data == '') {
req.result = 'Server Error';
} else {
console.log(util.inspect(error));
body = error.data;
}
res.statusCode = error.statusCode;
} else {
console.log(util.inspect(data));
var responseContentType = response.headers['content-type'];
switch (true) {
case /application\/javascript/.test(responseContentType):
case /text\/javascript/.test(responseContentType):
case /application\/json/.test(responseContentType):
body = JSON.parse(data);
break;
case /application\/xml/.test(responseContentType):
case /text\/xml/.test(responseContentType):
default:
}
}
// Set Headers and Call
if (response) {
req.resultHeaders = response.headers || 'None';
} else {
req.resultHeaders = req.resultHeaders || 'None';
}
req.call = url.parse(options.host + options.path);
req.call = url.format(req.call);
// Response body
req.result = body;
next();
};
switch (httpMethod) {
case 'GET':
console.log(resource);
oa.get(resource, '', '',cb);
break;
case 'PUT':
case 'POST':
oa.post(resource, '', '', JSON.stringify(obj), null, cb);
break;
case 'DELETE':
oa.delete(resource,'','',cb);
break;
}
} else {
// API uses OAuth, but this call doesn't require auth and the user isn't already authed, so just call it.
unsecuredCall();
}
} else {
// API does not use authentication
unsecuredCall();
}
// Unsecured API Call helper
function unsecuredCall() {
console.log('Unsecured Call');
// Add API Key to params, if any.
if (apiKey != '' && apiKey != 'undefined' && apiKey != undefined) {
if (options.path.indexOf('?') !== -1) {
options.path += '&';
}
else {
options.path += '?';
}
options.path += apiConfig.keyParam + '=' + apiKey;
}
if (username != '' && username != undefined) {
options.path += '&' + apiConfig.usernameParam + '=' + username;
}
// Perform signature routine, if any.
if (apiConfig.signature) {
if (apiConfig.signature.type == 'signed_md5') {
// Add signature parameter
var timeStamp = Math.round(new Date().getTime()/1000);
var sig = crypto.createHash('md5').update('' + apiKey + apiSecret + timeStamp + '').digest(apiConfig.signature.digest);
options.path += '&' + apiConfig.signature.sigParam + '=' + sig;
}
else if (apiConfig.signature.type == 'signed_sha256') { // sha256(key+secret+epoch)
// Add signature parameter
var timeStamp = Math.round(new Date().getTime()/1000);
var sig = crypto.createHash('sha256').update('' + apiKey + apiSecret + timeStamp + '').digest(apiConfig.signature.digest);
options.path += '&' + apiConfig.signature.sigParam + '=' + sig;
}
}
// Setup headers, if any
if (reqQuery.headerNames && reqQuery.headerNames.length > 0) {
if (config.debug) {
console.log('Setting headers');
};
var headers = {};
for (var x = 0, len = reqQuery.headerNames.length; x < len; x++) {
if (config.debug) {
console.log('Setting header: ' + reqQuery.headerNames[x] + ':' + reqQuery.headerValues[x]);
};
if (reqQuery.headerNames[x] != '') {
headers[reqQuery.headerNames[x]] = reqQuery.headerValues[x];
}
}
options.headers = headers;
}
if (!options.headers['Content-Length']) {
options.headers['Content-Length'] = 0;
}
if (config.debug) {
console.log("Inspecting options:");
console.log(util.inspect(options));
};
// API Call. response is the response from the API, res is the response we will send back to the user.
var apiCall = http.request(options, function(response) {
response.setEncoding('utf-8');
if (config.debug) {
console.log('HEADERS: ' + JSON.stringify(response.headers));
console.log('STATUS CODE: ' + response.statusCode);
};
res.statusCode = response.statusCode;
var body = '';
response.on('data', function(data) {
body += data;
})
response.on('end', function() {
delete options.agent;
var responseContentType = response.headers['content-type'];
switch (true) {
case /application\/javascript/.test(responseContentType):
case /application\/json/.test(responseContentType):
console.log(util.inspect(body));
// body = JSON.parse(body);
break;
case /application\/xml/.test(responseContentType):
case /text\/xml/.test(responseContentType):
default:
}
// Set Headers and Call
req.resultHeaders = response.headers;
req.call = url.parse(options.host + options.path);
req.call = url.format(req.call);
// Response body
req.result = body;
console.log(util.inspect(body));
next();
})
}).on('error', function(e) {
if (config.debug) {
console.log('HEADERS: ' + JSON.stringify(res.headers));
console.log("Got error: " + e.message);
console.log("Error: " + util.inspect(e));
};
});
apiCall.end();
}
}
url = require('url');
var config = {
rdioOauthRequestUrl: 'http://api.rdio.com/oauth/request_token',
rdioOauthAccessUrl: 'http://api.rdio.com/oauth/access_token',
rdioAuthUrl: 'https://www.rdio.com/oauth/authorize?oauth_token=',
rdioApiKey: 'm7nqqu42yx7augqf5u6ekxjh',
rdioApiSharedSecret: 'FRfXAsVExQ',
host: 'localhost',
port: '3000'
}
var oa = new OAuth(
config.rdioOauthRequestUrl,
config.rdioOauthAccessUrl,
config.rdioApiKey,
config.rdioApiSharedSecret,
"1.0",
"http://"+config.host+":"+config.port, "HMAC-SHA1"
);
oa.getOAuthRequestToken(function(error, oauthToken, oauthTokenSecret){
if (error) {
console.log("error:", error);
} else {
// redirect the authorize the token
console.log("requesting token");
open(config.rdioAuthUrl+oauthToken);
// start a server to catch the redirect
server = http.createServer(function (req, res) {
var express = require('express'),
url = require("url"),
querystring = require("querystring"),
path = require("path"),
auth = require("oauth");
var app = express.createServer();
var testVar = 'kittens';
var oa = new auth.OAuth("https://api.twitter.com/oauth/request_token",
"https://api.twitter.com/oauth/access_token",
"xJ3l6SLfdUo7qgBoiokaUw",
"t9oq5VhHoTpZWLDSunM8xE8tfPKmMXs1k9trs5xwWBI",
"1.0",
null,
"HMAC-SHA1");
oa.getOAuthRequestToken();
oa.getOAuthAccessToken();
app.get('/index.html', function(req, res){
if(typeof(url.parse(req.url).query) !== 'undefined'){
var query = url.parse(req.url).query;
}
if(querystring.parse(query).testVar)
testVar = querystring.parse(qs).myvar;
res.send(testVar);
});
app.get('/setTwitterStatus', function(req, res){