fme-twitter/fme-twitter.ts

Twitter module for aggregating twitter data

import { Log } from "fme-logger";
var L = new Log("FmeTwitter")
L.setLevel("info");

import * as Twit from "twit";
import * as TwitText from "twitter-text";
import {TwitterUsers} from "./models/users";
import * as mongo from "mongodb";
import { Tweet } from "./models/twitterModels";
import { AuthorModel } from "./models/twitterModels"
import { TwitterUserModel } from "./models/users";
import { Score,WordScore } from "./models/score";




export class FmeTwitter {
    wordScore:WordScore;
    users:TwitterUsers;
    twit:Twit;
    stream:Twit.Stream;
    adaptiveFilter: string[] = ["#breaking"];
    following: string[];
    blockedUsers: number[] = [];
    importantUsers: TwitterUserModel[] = [];
    listen:any;

    constructor(db:mongo.Db,keys:any) {
        this.twit = new Twit(keys);
        if (db) {
            this.users = new TwitterUsers(db);
            this.wordScore = new WordScore(db);
        }
    }

  
    addBlockedUser = (id:number) => {
        this.blockedUsers.push(id);
        this.users.addBlock(id);
    }
    
    isImportant = (id:number) => {
        var index = this.importantUsers.findIndex( (a) => {return a.id === id});
        if (index > -1 ) return true;
        return false; 
    }
    
    score = async (tweet:Tweet) => {
        var tweetScore = 0;
        var textArray = tweet.text.match(/\b(\w+)\b/g);
        if (textArray) {
            for (var i in textArray) {
                var word = textArray[i];
                if (word.length < 3) continue;
                var score = await this.wordScore.get(word) as number;
                tweetScore += score;
            }
        }
        return tweetScore;
    }

    startStream = async () => {
        return new Promise ( async ( resolve,reject ) => {
            try{
           
                L.debug("Initialiaze twitter stream")
                L.debug("Getting Blocked Users")
                this.blockedUsers = await this.users.getBlocked() as number[];
                L.debug("Getting important users");
                this.importantUsers = await this.users.getImportant() as TwitterUserModel[];

                var ids = this.importantUsers.map( a => a.id.toString());
                L.debug("Starting twitter stream",this.importantUsers.length)
                
                    this.stream =  this.twit.stream('statuses/filter',
                        {
                            "track" : this.adaptiveFilter,
                            "lang":"en",
                            "follow" : ids as any
                        }
                    );
                    
                    this.stream.on("tweet", async (tweet:Tweet) => {
                       // var user = await this.users.incPostCount(tweet.user);
                        if (typeof this.listen == "function") {
                            L.debug("pushing to the listener(s)");
                            this.listen(tweet);
                        }
                    })

                    this.stream.on("message", (m:any) => {
                        L.debug("message",m);
                    })

                    this.stream.on("connected", (m:any) => {
                        L.debug("connected",m);
                    })

                    this.stream.on("delete", (m:any) => {
                        L.debug("twitter Stream delete",m);
                    })

                    this.stream.on("limit", (m:any) => {
                        L.debug("twitter Stream Limit",m);
                    })

                    this.stream.on("connect",(m:any) => {
                        L.debug("twitter-stream connect",m.method);
                    })

                    this.stream.on("connected",(m:any) => {
                        L.debug("twitter-stream connected",m);
                    })

                    this.stream.on("error",(m:any) => {
                        L.debug("Twitter Error",m);
                    })

        } catch (err) {
            L.error(err)
            reject(err)
            return
        }
        L.debug("stream start completed")
        resolve( )
    })
       
      
    };

    stopStream = () => {
        this.stream.stop();
    }

    send = (message:string) => {
        this.twit.post('statuses/update',{status:message});
    }   

}