sio.sockets.on('connection', function(socket){
console.log('Web client connected');
var stream = T.stream('statuses/filter', { track: ['#'] }); //establish filter for hashtags
stream.on('tweet', function (tweet) {
var tagslistarr = tweet.text.match(/#\S+/g); // split the tweet into hashtags
if(tagslistarr)
{
console.log('Hashtags are: ',tagslistarr);
}
addtowindow(tagslistarr);
var size = heap.size();
console.log('size of PriorityQueue: ', size);
console.log('..................................................');
console.log('top-K Hashtags: ');
heap.display();
console.log('..................................................');
//sort the list of hashtags before sending it to client
globarr.sort(function(a,b) {return (a.value > b.value) ? 1 : ((b.value > a.value) ? -1 : 0);} );
//emit the meaningful data to the web browser client
socket.volatile.emit('ss-tweet', {
list: globarr,
});
});
// on client action 'Submit'
socket.on('ss-submit', function (data) {
k = data.k;
console.log('k value is: ', k);
w = data.w;
console.log('w value is: ', w);
first=0;
wcount=0;
heap.delete();
});
//on disconnection from client
socket.on('disconnect', function() {
console.log('Web client disconnected');
});
});
function streamArticleTweets(article) {
var tweetWords = parseHeadline(article);
var stream = T.stream('statuses/filter', { track: tweetWords });
stream.on('tweet', function (tweet) {
/* if you want to store more attributes from the tweet object, here is a great place to do it. Right now we're just storing
the geolocation data, but it's easy to store tweet text, username, etc. Tweet text is tweet.text */
// Create geodata object
if (tweet.coordinates) {
var geo = tweet.coordinates.coordinates;
var tweetObj = {
latitude: geo[1],
longitude: geo[0]
};
// Save to database
article.tweetQuery = tweetWords.join('');
article.tweets.push(tweetObj);
article.save();
console.log('added to database from', tweetWords);
}
})
// or search directly
// T.get('search/tweets', { q: tweetWords, count: 100 }, function(err, data, response) {
// for (var i = 0; i < data.statuses.length; i++) {
// // Add to database
// if (data.statuses[i].coordinants) {
// var geo = data.statuses[i].coordinants.coordinants;
// var tweetObj = {
// latitude: geo[1],
// longitude: geo[0]
// };
// console.log(tweetObj);
// }
// };
// })
}
add: function(topic){
stream && stream.stop();
topics.push(topic);
var stream = T.stream('statuses/filter', { track: topics });
stream.on('tweet', function (tweet) {
var hts = tweet.entities.hashtags.map(function(t){return '#'+t.text}).join(',');
var tw = {
who: '@'+tweet.user.screen_name,
what: tweet.text,
when: tweet.created_at,
where: tweet.geo || tweet.user.location,
why: hts,
how: 'twitter'
}
console.log(tw);
});
}
exports.tweets = function getTweets (number, filter, cb){
var stream = T.stream('statuses/filter', { track: filter, language: 'en'});
var allTweets = [];
var count = 0;
stream.on('tweet', function (tweet) {
allTweets.push(tweet.text);
console.log(tweet.text)
count += 1;
if (count === number){
stream.stop();
return cb(allTweets);
}
})
}
var startStream = function(trackName, token, secret) {
var T = new Twit({
consumer_key: process.env.TWITTER_CONSUMERKEY,
consumer_secret: process.env.TWITTER_CONSUMERSECRET,
access_token: token,
access_token_secret: secret
});
// Prefer to use statuses/filter, but 'user' is more reliable
twitterStream.stream = T.stream('user', {track: trackName});
console.log('Created stream instance:', trackName);
twitterStream.stream.on('tweet', function (tweet) {
// console.log('tweet found!');
onTweet(tweet, trackName);
});
};
var Tweetme = function(options){
var tweet = this;
var T = new Twit(options);
var stream = T.stream('user');
stream.on('direct_message', function (directMsg) {
tweet.emit('direct_message', directMsg);
});
this.sendDirectMessage = function(directMsg, callback){
T.post('direct_messages/new', directMsg, function(err, reply) {
if(err) console.log(err);
});
}
EventEmitter.call(this);
}
sendTrackStream: function(socket, trackName) {
console.log('Creating stream for:', trackName);
var stream = T.stream('statuses/filter', {
track: trackName/*,
locations: [-180, -90, 180, 90],
locations: [-122.75, 36.8, -121.75, 37.8, -74, 40, -73, 41]*/
});
stream.on('tweet', function(tweet) {
console.log(trackName, 'streamed new tweet:', tweet.id_str);
tweet.sentimentScore = sentiment.analyze(tweet.text).score;
socket.emit('tweet', tweet);
});
return stream;
},
io.on('connection', function(socket){
console.log('connected');
let coords = socket.handshake.query.coords.split(',');
let stream = T.stream('statuses/filter', { locations: coords });
stream.on('tweet', function (tweet) {
// Check to see if tweet has been sent
// if (tweets.indexOf(tweet.id) >= 0) {
io.emit('newTweet', tweet);
// }
// Store tweet by it's ID
tweets.push(tweet.id);
});
});
exports.stream = function(socket, msg) {
var T = new Twit({
consumer_key: secrets.twitter.consumerKey,
consumer_secret: secrets.twitter.consumerSecret,
access_token: "391188422-TGrNHdpWElJrzqELkpXJBQhe8EK2KIUuO5ojh4CG",
access_token_secret: "SMOTGnAixh2kf8R4V5SkEdJwJjG95EuDWUYnaVs0LOR3C",
});
var usBox = ['-124.13', '48.0', '-69.90', '30.1'];
var stream = T.stream('statuses/filter', {
track: msg.query,
location: [-180,-90,180,90],
language: "en"
});
stream.on('tweet', function(tweet) {
if (tweet.geo) {
// socket.emit('twitterStream', tweet);
sendFullDataSet(socket, tweet.text, tweet.user.name, tweet.user.screen_name, tweet.coordinates.coordinates[1], tweet.coordinates.coordinates[0]);
}
});
var maxId = null;
getTweets(1)
function getTweets(counter) {
if(counter === 10) {return;}
// console.log("using max Id: " + maxId);
T.get('search/tweets', { q: 'beyonce', count: 100, max_id: maxId}, function(err, data, response) {
for (var j = 0; j < data.statuses.length; j++) {
var tweet = data.statuses[j];
//console.log(tweet);
if (tweet.geo) {
// console.log("found one!");
sendFullDataSet(socket, tweet.text, tweet.user.name, tweet.user.screen_name, tweet.coordinates.coordinates[1], tweet.coordinates.coordinates[0]);
}
maxId = tweet.id - 1;
}
//maxId = data.search_metadata.max_id;
//console.log(maxId);
getTweets(++counter);
});
}
};
}, function (token, tokenSecret, profile, done) {
configTwitter.access_token = token;
configTwitter.access_token_secret = tokenSecret;
console.log('Successfully OAuth\n' + JSON.stringify(configTwitter, null, ' ') + '\n');
console.log('profile', profile);
require('./app/lib/share').configTwitter = configTwitter;
var T = new Twit(configTwitter);
//require('./app/lib/share').stream = T.stream('user', {
var stream = T.stream('user', {
track: profile.username
});
//var io = require('../lib/share').io;
//var stream = require('../lib/share').stream;
stream.on('tweet', function (tweet) {
//if (typeof tweet.retweeted_status === 'undefined') {
// return;
//}
console.log(tweet.user.name + ':' + tweet.text);
//SVG DOM injection
getImageBase64(tweet.user.profile_image_url, function (encode) {
//console.log('data:image/png;base64,' + encode); // replace link by data URI
tweet.user.profile_image_url = 'data:image/png;base64,' + encode;
io.sockets.emit('msg', tweet);
});
});
stream.on('connect', function(request) {
console.log('stream connection attempted.');
});
stream.on('connected', function (res) {
console.log('stream connected (' + res.statusCode + ')');
});
stream.on('reconnect', function (req, res, interval) {
console.log('stream reconnecting in ' + interval + ' (' + res.statusCode + ')');
});
return done(null, profile);
}));
exports.startStream = function(tag){
filter_stream = T.stream('statuses/filter', { track: '#'+tag});
/* When a Tweet is sent, this code will run */
filter_stream.on('tweet', function (tweet) {
text = tweet.text
text = cleanText(text)
if(text.match(/[a-z0-9]+\s*-\s*[a-z0-9]/i)){
tweetToSong(text)
.then(function(good){
//console.log(good)
tweet.text = text
tweetQueue.push(tweet)
}, function(bad){
console.log(bad)
})
}
});
}
// init streaming API.
(next) => {
let stream = twit.stream('statuses/filter', {
follow: stlk.id_str
})
stream.on('tweet', (tweet) => {
if(tweet.user.id_str !== stlk.id_str) return;
log(config.stalk.handle, 'tweeted', "'"+tweet.text+"'")
redis.addTweet(tweet)
events.emit('tweet', tweet);
});
stream.on('delete', (tweet) => {
tweet = tweet.delete.status;
redis.markDeleted(tweet.id_str, (err) => {
console.log('DELETEION EVENT ERROR: ', err);
})
redis.getTweet(tweet.id_str, (err, tweet) => {
if(err || tweet === null) {
log(config.stalk.handle, 'deleted a tweet we don\'t have archived.')
return false;
}
log(config.stalk.handle, 'deleted', "'"+tweet.text+"'");
events.emit('delete', tweet);
})
})
stream.on('connected', () => {
log('stalking has begun (connected to streaming API)')
})
stream.on('disconnect', () => {
log('stalking stopped, disconnected :(')
})
return next(false);
},
module.exports = function(server, twitterConfig) {
var T = new Twit(twitterConfig);
var wss = new WebSocketServer({ server: server });
var stream = T.stream('statuses/filter', {
locations: LOCATIONS.WORLD,
language: 'en'
});
wss.on('connection', function(ws) {
var pushTweet = pushTo(ws);
stream.on('tweet', pushTweet)
ws.on('close', function() {
stream.removeListener('tweet', pushTweet);
});
});
}
/**
* watch the gameideamachine user stream
* look for tweets at it
*/
function monitor() {
var stream = Twitter.stream('user');
stream.on('tweet', function (tweet) {
var message = tweet.text;
var command = message.replace('@gameideamachine','').trim().toLowerCase();
if(command === 'idea') {
reply(tweet, generator.generateSafe(null, tweet.user.screen_name));
} else if(data[command]) {
reply(tweet, generator.generateSafe(command, tweet.user.screen_name));
} else {
// unknown request- log somewhere?
return;
}
});
}
/**
* Go through the drakefacts text file and parse them into memory
*/
function initializeDrakeFacts(){
var rd = readline.createInterface({
input: fs.createReadStream('drakefacts.txt'),
output: process.stdout,
terminal: false
});
var count = 0;
rd.on('line', function(line) {
if (++count <= config.lineCutoff){
drakeFacts.push(line);
}
});
var stream = T.stream('statuses/filter', { track: config.tagsToTrack })
stream.on('tweet', function (tweet) {
var userName = tweet.user.screen_name;
postDrakeFact(userName);
});
}
.then(function(data) {
if(data.twitter_token && data.twitter_token_secret) {
var T = new Twit({
consumer_key: process.env.TWITTER_APIKEY,
consumer_secret: process.env.TWITTER_APISECRET,
access_token: data.twitter_token,
access_token_secret: data.twitter_token_secret
});
var stream = T.stream("user");
stream.on("tweet", function(tweet) {
counter++;
sails.sockets.emit(sails.sockets.id(req.socket), "twitter:user", {tweet: tweet});
});
sails.io.on("disconnect", function(socket) {
stream.stop();
});
}
});
process.nextTick(function () {
twit = new Twit({
consumer_key: TWITTER_CONSUMER_KEY,
consumer_secret: TWITTER_CONSUMER_SECRET,
access_token: token,
access_token_secret: tokenSecret
});
// Streaming de tweets
var stream = twit.stream('statuses/filter', { track: HASHTAG })
stream.on('tweet', function (tweet) {
app.io.broadcast('newTweet', tweet);
});
// To keep the example simple, the user's Twitter profile is returned to
// represent the logged-in user. In a typical application, you would want
// to associate the Twitter account with a user record in your database,
// and return that user instead.
return done(null, profile);
});
module.exports.saveOnRead = function(hashtag) {
var T = new Twit(env.twitter);
var stream = T.stream('statuses/filter', { track: hashtag });
stream.on('tweet', function (tweet) {
var geoJSON = tweet.coordinates;
if (geoJSON) {
var participant = {
name: tweet.user.name,
image: tweet.user.profile_image_url,
message: tweet.text,
twitter: tweet.user.screen_name,
loc: geoJSON
};
Participant.save(participant);
debug("[INFO] @" + tweet.user.screen_name + " : " + tweet.text);
} else {
debug("[ERRO] @" + tweet.user.screen_name + " not turned on the exact localization.");
}
});
};
prompt.get(['hashtagKey'], function (err, result) {
if (err) { return onErr(err); }
var sk = result.hashtagKey;
var dir = 'tweets';
if (!fs.existsSync(dir)){
fs.mkdirSync(dir);
}
var stream = client.stream('statuses/filter', { track: sk });
stream.on('tweet', function (data) {
console.log("via: "+data.user.screen_name+"/"+"Tweet: "+data.text+'\r\n'+'\r\n');
/*
var dataTosave = "{"+"\r"+
"Text: "+data.text+","+"\r\n"+
"Time: "+data.created_at+","+"\r\n"+
"Source: "+data.source+","+
"\r"+"}";
basically you can use these variables if you dont want to save the whole JSON
username: data.user.screen_name
created_at: data.created_at
location: data.user.location
etc ....
*/
fs.writeFile('tweets/'+data.user.screen_name+'.json',JSON.stringify(data, null, 4),function (err) {
if (err) throw err;
});
});
function onErr(err) {
console.log(err);
return 1;
}
});
_init_stream() {
this.stream = this.t.stream('user')
this.stream.on('tweet', (tweet) => {
if(!this._filter(tweet))
return
let command = this.cond.test(tweet)
if(!command) {
return
} else {
this.execute(command)
if(tweet.text.length < this.deleteLength &&
tweet.user.screen_name === this.keyOwner) {
this.t.post('statuses/destroy', { id: tweet.id_str }, (e, d) => 1 )
}
}
})
}
// Constructor
function twitterbot(bs,settings) {
var T = new Twit({
consumer_key: settings.Twitter.consumer_key,
consumer_secret: settings.Twitter.consumer_secret,
access_token: settings.Twitter.access_token,
access_token_secret: settings.Twitter.access_token_secret
});
var config = {nick: "tipsjcx"};
// get a stream of everything sendt to the bot
var stream = T.stream('statuses/filter', { track: config.nick})
stream.on('tweet', function (tweet) {
var arr = tweet.text.split(" ");
if (arr[0] != "@"+config.nick) return;
if (arr[1] == "register") handleRegister(tweet.user.screen_name, bs, T);
if ((arr[1] == "tip") && (arr.length > 4)) handleTip(tweet.user.screen_name, arr[2], arr[3], arr[4], bs, T);
if ((arr[1] == "balance")) handleBalance(tweet.user.screen_name, bs, T);
if ((arr[1] == "withdraw")&&(arr[3] == "sjcx")) handleWithdraw(tweet.user.screen_name, arr[4], arr[2] , bs, T);
});
}
init: function(twitterids) {
TwitterAPI.stream = T.stream('statuses/filter', {
//TODO: restart the stream when new trucks are added to foodler db
// Read new trucks and fetch twitter id by screen_name. It would be
// better to lookup the user id and store it in the foodler db during
// registration.
follow: twitterids
});
TwitterAPI.stream.on('tweet', function(tweet) {
if (tweet && tweet.text && tweet.id) {
//TODO: remove old tweets (2 weeks old)
var id = tweet.user.id_str
, name = tweet.user.screen_name
, time = (new Date(tweet.created_at)).getTime()
, data = JSON.stringify(tweet);
db.query(SQL_INSERT_TWEET, [id, time, data],
function (err, res) {
if (err)
console.error(err);
});
console.log(String('tweet: ' + tweet.user.screen_name).green);
} else {
console.error(String('tweet invalid: ' + tweet).red);
}
});
TwitterAPI.stream.on('disconnect', function(message) {
console.log('Disconnected from Twitter'.red);
console.log('It\'s Jackson, Alec, or Arthur\'s fault!\nOnly one person at a time.'.red);
//TODO: if disconnected wait 10 seconds and reconnect
});
},
socket.on('start stream', function() {
if (streamSF === null) {
streamSF = T.stream('statuses/filter', {locations: [ '-122.62', '37.64', '-121.98', '37.92' ]});
streamSF.on('tweet', function(tweet) {
if (users.length > 0) {
socket.emit('sf', tweet);
}
else {
console.log('Stream Shutdown')
streamSF.stop();
streamSF = null;
}
});
}
else {
streamSF.on('tweet', function(tweet) {
if (users.length > 0) {
socket.emit('sf', tweet);
}
});
}
});
socket.on('stream', function(params) {
var endpoint = params.endpoint || 'statuses/filter';
var options = {};
if (params.keywords) {
options.track = params.keywords;
}
if (params.locations) {
options.locations = params.locations;
}
if (params.users) {
options.follow = params.users;
}
if (params.language) {
options.language = params.language;
}
// Subscribe to the stream of Tweets matching the specified options.
var stream = twitter.stream(endpoint, options);
// Listen to the `connect` event.
stream.on('connect', function(params) {
console.log('Streaming from the Twitter API...');
});
// Emit an event with the Tweet information.
stream.on('tweet', function(tweet) {
io.sockets.emit('tweet', tweet);
});
// Listen to the `disconnect`/`stop` events to destroy the connection.
socket.on('disconnect', function(params) {
console.log('Streaming ended (disconnected).');
stream.stop();
});
socket.on('stop', function(params) {
console.log('Streaming ended (stopped).');
stream.stop();
});
});
// Listen to tweets
function(done) {
var stream = T.stream('statuses/filter', filter);
var n = 0;
stream.on('tweet', function(tweet) {
if (!tweet.geo || !tweet.geo.coordinates || tweet.geo.coordinates < 2) {
console.log('no geo');
return;
}
/*var text = tweet.text.toLowerCase();
if (text.indexOf('skate') == -1 &&
text.indexOf('skeitti') == -1 &&
text.indexOf('skeittaamaan') == -1) {
return;
}
*/
n++;
console.log('insert '+n);
collection.insert(tweet, function(err, data) {
if (err) done(err);
});
});
}
// TWITTER
//
// filter the public stream by the latitude/longitude bounded box of San Francisco
//
function getTweets(){
var Twit = require('twit')
var T = new Twit({
consumer_key: 'xL0BXTOaaCcQmVmLA6nlYQ'
, consumer_secret: 'Bek6nLcTnLl4rLxifZShemQd2SMsD4eIzyOyKo1WzE'
, access_token: '29187442-LorzteOUEh0T0EWVj4vIVmSOPx9jhZ0G8YsRDweId'
, access_token_secret: 'FkIwNhLo0ncZMPpsm7ayUulP6Z0Cm4Ta6T8GCe82vOP6J'
})
var fs = require('fs');
var geo = [ '-180', '-90', '180', '90' ];
var stream = T.stream('statuses/filter', { locations: geo, language: 'en' });
var i = 0;
var file = 0;
stream.on('tweet', function (tweet) {
fs.appendFile('tweets'+file+'.json', JSON.stringify(tweet)+"\n", function(err) {
if(err) {
console.log(err);
} else {
console.log("JSON saved to tweets"+i+".json");
}
});
i++;
if(i%500==0){
file++;
console.log("///")
setTimeout(function(){console.log("-->");stream.start();},1000);
stream.stop();
}
})
}
router.post('/mention', function(req, res) {
console.log('inside mention route');
//reset the pause to false.
pause = false;
//grab the text of the tweet.
var statusText = req.body.tweetStatus;
console.log('my statusText:', statusText);
//check to make sure the new tweet on mention is different then the previous one.
if (statusText != oldStatusText) {
stream = T.stream('statuses/filter', {track: '@BotGoatBasics'});
console.log('stream:', stream);
}
//Update the 'cashed statusText'. oldStatusText keeps the current tweet. saved globally.
oldStatusText = statusText;
console.log('oldStatusText:', oldStatusText);
//listen for a tweet to mention @BotGoatBasics
stream.on('tweet', function (tweetEvent) {
console.log('tweetEvent inside return from mention:', tweetEvent);
//only using the screen name of the person who mentioned the bot and the tweetId so that this response stays in the same conversation thread.
var reply_to = tweetEvent.in_reply_to_screen_name;
var name = tweetEvent.user.screen_name;
var txt = tweetEvent.text;
var reply = '@'+ name + ' ' + statusText;
var tweetId = tweetEvent.id_str;
console.log(reply);
//Tweet the response.
return T.post('statuses/update', {status: reply, in_reply_to_status_id: tweetId}, tweeted);
});
res.sendStatus(200).end();
});
streamTweets: function(callback) {
var stream,
emojiData,
emojis;
// Only use the "top" 400 emoji (determined Feb 26, 2014 using http://www.emojitracker.com/)
// if we still only have basic stream access... i.e.; if Twitter never got back to us. 😔
emojiData = new EmojiData({ top_emojis: config.twitter.has_basic_access });
emojis = emojiData.emojis;
var wholeWorld = [ "-180", "-90", "180", "90" ]
// Start streaming.
this.stream = stream = twitter_stream.stream("statuses/filter", { track: emojis });
stream.on("error", function (err) {
console.log("error!", err);
});
stream.on("tweet", function(tweet) {
var emojiTweet = new EmojiTweet(tweet, emojiData);
if (emojiTweet.isRetweet()) {
return;
}
if (emojiTweet.coordinates && emojiTweet.emojis.length > 0 ) {
_.each(emojiTweet.emojis, function(emoji) {
if (typeof(callback) == typeof(Function)) {
callback({
"emoji": emoji,
"unified": emojiData.emoji_mappings[emoji],
"coordinates": emojiTweet.coordinates
});
}
});
}
});
}
socket.on('updateTerm', function(searchTerm){
console.log('term updated', searchTerm)
// socket.emit('updatedTerm', searchTerm);
if(stream){
console.log('stopped stream');
stream.stop();
}
stream = twitter.stream('statuses/filter'
, {track: searchTerm
, language: 'en'
})
// , {locations:[-180,-90,180,90]})
stream.on('tweet', function (tweet) {
// console.log(Object.keys(tweet.coordinates));
if (tweet.place){
console.log(tweet.place.bounding_box.coordinates[0][0])
var data = {}
data.name = tweet.user.name
data.screen_name = tweet.user.screen_name
data.text = tweet.text
data.user_profile_image = tweet.user.profile_image_url
data.location = {"lat": tweet.place.bounding_box.coordinates[0][0][1],"lng": tweet.place.bounding_box.coordinates[0][0][0]}
data.full_name = tweet.place.full_name
console.log(data)
socket.emit('tweets', data)
} else if (tweet.coordinates && tweet.coordinates.coordinates){
console.log(tweet.coordinates.coordinates)
var data = {}
data.name = tweet.user.name
data.screen_name = tweet.user.screen_name
data.text = tweet.text
data.user_profile_image = tweet.user.profile_image_url
data.location = {"lat": tweet.coordinates.coordinates[0], "lng": tweet.coordinates.coordinates[1]}
console.log(data)
socket.emit('tweets', data); //sending info back to the client
}
})
})
stream : function( config ) {
var db = new dbs( config.set("db") ),
T = new Twit( config.get("twuiter") ),
stream = T.stream('statuses/filter', { track: config.get("tag") });
stream.on('tweet', function (data) {
if( !data.retweeted && data.retweet_count <= 0 ){
tuit = _.extend(data, lib.find( data, config ) );
switch ( tuit.tipo ) {
case 1:
db.insertarMadrazo( tuit, lib.console );
break;
case 2:
db.eliminarUsuario( tuit, lib.console );
break;
case 3:
db.insertarUsuario( tuit, lib.console );
break;
default:
break;
};
};
});
}