Twitter followers overlap (HarshCasper#1007)

* initial setup

* twitter functions added

* pseudo code

* functions initialized

* printLongArray func added

* overlap followers function done

* minor changes

* Readme added

* readme updated

Author: jhamadhav

.gitignore

@@ -300,4 +300,4 @@ chromedriver.exe
 node_modules
 
 #Twitter_Unfollowers
-db.json
+db.json

JavaScript/Twitter_Followers_Overlap/README.md

@@ -0,0 +1,27 @@
+# Twitter_Followers_Overlap
+
+**Twitter_Followers_Overlap** a script to list the followers that are common between two twitter users.
+- It uses Twitter API to fetch followers of any user *(provided as input)*.
+- Then compares them to give names of people that are common between both the users.
+
+## Setup instructions
+
+- Get your [Twitter developer account](https://developer.twitter.com/en) and follow the steps there to generate your **bearer key**
+- In a file named `apiTokens.js` in the Twitter_Followers_Overlap folder, enter your bearer key : ![File content](https://i.imgur.com/qGWVd7h.png)
+- Open terminal and do the following : 
+- `cd Rotten-Scripts\JavaScript\Twitter_Followers_Overlap`
+- Run `npm install` to install all necessary dependencies
+- Run `node Twitter_Followers_Overlap.js` and Voila! you are ready to go 😉
+
+## Output
+
+![Output Pic](https://i.imgur.com/9klb2d9.png)
+
+## Author(s)
+
+Hi I'm [Madhav Jha](https://github.jhamadhav.com) author of this script.
+
+## Disclaimer
+
+- **DO NOT forget to get your bearer key from your [Twitter developer account](https://developer.twitter.com/en) and ALWAYS keep it a SECRET!!!**
+- **Do not try for accounts with followers count more than few thousands, even though the script works you will exhaust your twitter API limit before the process ends.**

JavaScript/Twitter_Followers_Overlap/apiTokens.js

@@ -0,0 +1,3 @@
+exports.data = {
+    "bearer": "Enter your bearer key here"
+}

JavaScript/Twitter_Followers_Overlap/package-lock.json

@@ -0,0 +1,15 @@
+{
+  "name": "twitter_followers_overlap",
+  "version": "1.0.0",
+  "description": "A script to list the followers that are common between two twitter users.",
+  "main": "twitter_followers_overlap.js",
+  "scripts": {
+    "twitter_followers_overlap_run": "node twitter_followers_overlap.js"
+  },
+  "author": "Madhav Jha",
+  "license": "ISC",
+  "dependencies": {
+    "needle": "^2.6.0",
+    "prompt-sync": "^4.2.0"
+  }
+}

JavaScript/Twitter_Followers_Overlap/package.json

@@ -0,0 +1,80 @@
+const needle = require('needle');
+const api = require("./apiTokens")
+
+const bearerToken = api.data.bearer;
+
+const getUserId = async (username) => {
+    let endpointURL = "https://api.twitter.com/2/users/by?usernames="
+    const params = {
+        usernames: `${username}`,
+        "expansions": "pinned_tweet_id"
+    }
+
+    // this is the HTTP header that adds bearer token authentication
+    const res = await needle('get', endpointURL, params, {
+        headers: {
+            "User-Agent": "v2UserLookupJS",
+            "authorization": `Bearer ${bearerToken}`
+        }
+    })
+
+    if (res.body) {
+        return res.body;
+    } else {
+        throw new Error('Unsuccessful request')
+    }
+}
+const getFollowers = async (userId) => {
+    let url = `https://api.twitter.com/2/users/${userId}/followers`;
+    let users = [];
+    let params = {
+        "max_results": 1000
+    }
+
+    const options = {
+        headers: {
+            "User-Agent": "v2FollowersJS",
+            "authorization": `Bearer ${bearerToken}`
+        }
+    }
+
+    let hasNextPage = true;
+    let nextToken = null;
+
+    while (hasNextPage) {
+        let resp = await getPage(params, options, nextToken, url);
+        if (resp && resp.meta && resp.meta.result_count && resp.meta.result_count > 0) {
+            if (resp.data) {
+                users.push.apply(users, resp.data);
+            }
+            if (resp.meta.next_token) {
+                nextToken = resp.meta.next_token;
+            } else {
+                hasNextPage = false;
+            }
+        } else {
+            hasNextPage = false;
+        }
+    }
+
+    return users
+}
+
+const getPage = async (params, options, nextToken, url) => {
+    if (nextToken) {
+        params.next_token = nextToken;
+    }
+
+    try {
+        const resp = await needle('get', url, params, options);
+
+        if (resp.statusCode != 200) {
+            console.log(`${resp.statusCode} ${resp.statusMessage}:\n${resp.body}`);
+            return;
+        }
+        return resp.body;
+    } catch (err) {
+        throw new Error(`Request failed: ${err}`);
+    }
+}
+module.exports = { getUserId, getFollowers };

JavaScript/Twitter_Followers_Overlap/twitterFunc.js

@@ -0,0 +1,73 @@
+const prompt = require("prompt-sync")();
+const twt = require("./twitterFunc")
+
+const printLongArray = (arr, step = 100) => {
+    if (arr.length <= 0) {
+        return 0;
+    }
+    let start = 0, end = 0;
+    end = Math.min(step, arr.length);
+
+    let userInp = prompt(`Do you want to see list from ${start} to ${end} (y/n): `) || "n"
+    while (userInp == "y" && end <= arr.length && start != end) {
+        subArr = arr.slice(start, end)
+        console.table(subArr)
+        start = end;
+        end = Math.min(end + step, arr.length)
+        if (start == end) {
+            break;
+        }
+        userInp = prompt(`Do you want to see list from ${start} to ${end} (y/n): `) || "n"
+    }
+}
+
+const getOverlappingFollowers = (arr1, arr2) => {
+    let arr1IDs = arr1.map(user => user.id);
+    let arr2IDs = arr2.map(user => user.id);
+    let overlap = []
+    let overlapIDs = []
+
+    // from arr1IDs -> arr2IDs
+    for (let i = 0; i < arr1IDs.length; i++) {
+        if (arr2IDs.indexOf(arr1IDs[i]) != -1 && overlapIDs.indexOf(arr1IDs[i]) == -1) {
+            overlapIDs.push(arr1IDs[i])
+            overlap.push(arr1[i]);
+        }
+    };
+
+    // from arr2IDs -> arr1IDs
+    for (let i = 0; i < arr2IDs.length; i++) {
+        if (arr1IDs.indexOf(arr2IDs[i]) != -1 && overlapIDs.indexOf(arr2IDs[i]) == -1) {
+            overlapIDs.push(arr2IDs[i])
+            overlap.push(arr2[i]);
+        }
+    };
+    return overlap;
+}
+
+const init = async () => {
+    console.log("\n===============================");
+    console.log("---Twitter Followers Overlap---");
+    console.log("===============================\n");
+
+    let user1 = prompt("Enter first username : ");
+    let user2 = prompt("Enter second username : ");
+
+    console.log("\nFetching...Data....Please..Wait...!\n");
+
+    let user1ID = await twt.getUserId(user1)
+    let user2ID = await twt.getUserId(user2)
+
+    let user1Followers = await twt.getFollowers(user1ID["data"][0].id);
+    let user2Followers = await twt.getFollowers(user2ID["data"][0].id);
+
+    let overlapFollowers = getOverlappingFollowers(user1Followers, user2Followers);
+
+    console.log(`There are ${overlapFollowers.length} Overlapping followers!!! \n`);
+    printLongArray(overlapFollowers);
+    console.log("\n---END---\n");
+
+}
+
+// entry function
+init()