fme-twitter/models/users.ts

Twitter module for aggregating twitter data

import * as mongo from "mongodb";
import { Log } from "fme-logger";
var L = new Log("twitter-users");
import { AuthorModel } from "./twitterModels"

L.setLevel("info");

class WriteResult {
   "nMatched" : number;
   "nUpserted" : number;
   "nModified" : number;
}

export class TwitterUserModel {
    name:string;
    id:number;
    isBlocked:boolean = false;
    isImportant:boolean = false;
    postCount:number = 1;
    likes:number = 0;
    hates:number = 0;
    score:number = 50;
    followers:number = 0;
    follows:number = 0;
    tweets:number = 0;

}

export class TwitterUsers {
    users:TwitterUserModel[];
    collection:mongo.Collection;

    constructor (db:mongo.Db) {
        L.debug("contructor called",db.databaseName);
        this.collection = db.collection("twitter_users");
    }


    create = (user:AuthorModel) => {
        return new Promise ( async ( resolve,reject ) => {
            var newUser = new TwitterUserModel();
            newUser.id = user.id;
            newUser.name = user.name;
            newUser.followers = user.followers_count;
            newUser.follows = user.friends_count; 
            newUser.tweets = user.article_count;
            try{
                var rtn = await this.collection.update({id:user.id},newUser,{upsert:true});
            } catch (err) {
                L.error("create",err)
                reject(err)
                return
            }
            resolve(newUser)
        })
    }

    updateUser = (user:AuthorModel) => {
        return new Promise ( async ( resolve,reject ) => {
            try{
                
            } catch (err) {
                L.error("updateUser",err)
                reject(err)
                return
            }
            resolve( )
        })
    }

    get = (id:number) => {
        return new Promise ( async ( resolve,reject ) => {
            try{
                var user = await this.collection.find({id:id}).toArray()
            } catch (err) {
                L.error("get",err)
                reject(err)
                return
            }
            if (!user) resolve();
            else resolve(user[0])
        })
    }

    getImportant = () => {
        return new Promise ( async ( resolve,reject ) => {
            try{
               // L.info("In get Important")
                this.users = await this.collection.find({isImportant:true}).toArray();
            } catch (err) {
                L.error("getImportant",err)
                reject(err)
                return
            }
            resolve(this.users)
        })
    }

    getBlocked = () => {
        return new Promise ( async ( resolve,reject ) => {
            try{
                this.users = await this.collection.find({isBlocked:true}).toArray();
            } catch (err) {
                L.error("getBlocked",err)
                reject(err)
                return
            }
            resolve( this.users.map((a)=>{return a.id}) )
        })
    }

    remove = (user:TwitterUserModel) => {
        return new Promise ( async ( resolve,reject ) => {
            try{
                var rtn = await this.collection.remove({id:user.id});
            } catch (err) {
                L.error("remove",err)
                reject(err)
                return
            }
            resolve(true)
        })
    }

    addImportant = (id:number) => {
        return new Promise ( async ( resolve,reject ) => {
            try{
                var rtn = await this.collection.update({id:id},{$set:{isImportant:true}},{upsert:true});
            } catch (err) {
                L.error("addImportant",err)
                reject(err)
                return
            }
            resolve( true )
        })  
    }


    addBlock = (id:number) => {
        return new Promise ( async ( resolve,reject ) => {
            try{
                var rtn = await this.collection.update({id:id},{$set:{isBlocked:true}});
            } catch (err) {
                L.error("addBlock",err)
                reject(err)
                return
            }
            resolve( true )
        })  
    }

    removeBlock = (id:number) => {
        return new Promise ( async ( resolve,reject ) => {
            try{
                var rtn = await this.collection.update({id:id},{$set:{isBlocked:false}});
            } catch (err) {
                L.error("removeBlock",err)
                reject(err)
                return
            }
            resolve( true )
        })  
    }

    incLikes = (id:number) => {
        return new Promise ( async ( resolve,reject ) => {
            try{
                var rtn = await this.collection.update({id:id},{$inc:{likes:1}});
            } catch (err) {
                L.error("incLikes",err)
                reject(err)
                return
            }
            resolve(true)
        })
    }

    incHates = (id:number) => {
        return new Promise ( async ( resolve,reject ) => {
            try{
                var rtn = await this.collection.update({id:id},{$inc:{hates:1}}) ;
            } catch (err) {
                L.error("incHates",err)
                reject(err)
                return
            }
            resolve(true )
        })
    }

    incPostCount = (twitterUser:AuthorModel) => {
        return new Promise ( async ( resolve,reject ) => {
            try{
                var updateUser:any = await this.collection.findOneAndUpdate({id:twitterUser.id},{$inc:{postCount:1}}) as TwitterUserModel;
                if (!updateUser.value) {
                    var fmeUser = await this.create(twitterUser) as any;
                } else {
                    fmeUser = updateUser.value;
                }
            } catch (err) {
                L.error("incPostCount",err)
                reject(err)
                return
            }
            resolve(fmeUser);
        })
    }


}