You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
326 lines
8.3 KiB
326 lines
8.3 KiB
const routes = require('express').Router();
|
|
const got = require("got");
|
|
const cache = require('memory-cache');
|
|
const dotenv = require("dotenv").config();
|
|
const GITHUB_API = "https://api.github.com";
|
|
const authenticate = `client_id=${process.env.CLIENT_ID}&client_secret=${process.env.CLIENT_SECRET}`;
|
|
|
|
const API_FOLLOWING = "/following";
|
|
const API_FOLLOWERS = "/followers";
|
|
const API_USER_PATH = "/users/";
|
|
const API_ORGS_PATH = "/orgs/";
|
|
const API_PAGINATION_SIZE = 100; // 100 is the max, 30 is the default
|
|
// if this is too large, it would be infeasible to make graphs for people following popular people
|
|
const API_MAX_PAGES = 2;
|
|
const API_PAGINATION = "&per_page=" + API_PAGINATION_SIZE;
|
|
|
|
const REPOS_PATH = "/repos";
|
|
|
|
|
|
/**
|
|
* Queries data from the github APi server and returns it as
|
|
* a json object in a promise.
|
|
*
|
|
* This makes no attempt to cache
|
|
*
|
|
* @param {*} requestURL endpoint on githubapi: ex: /users/jrtechs/following
|
|
*/
|
|
const queryGithubAPIRaw = async requestURL => {
|
|
let queryURL = requestURL.includes("?page=")
|
|
? `${GITHUB_API}${requestURL}&${authenticate}`
|
|
:`${GITHUB_API}${requestURL}?${authenticate}`;
|
|
console.log(queryURL);
|
|
try {
|
|
const req = await got(queryURL, { json: true });
|
|
cache.put(requestURL, req);
|
|
return req;
|
|
} catch (error) {
|
|
console.log(error);
|
|
cache.put(requestURL, `${error.statusCode} - ${error.statusMessage}`);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Queries data from the github api server
|
|
* and caches the results locally.
|
|
*
|
|
* @param {*} requestURL
|
|
*/
|
|
const queryGitHubAPI = async requestURL => {
|
|
const apiData = cache.get(requestURL);
|
|
|
|
if (apiData) {
|
|
console.log("Fetched From Cache");
|
|
return apiData
|
|
}
|
|
|
|
try {
|
|
return await queryGithubAPIRaw(requestURL);
|
|
} catch (error) {
|
|
console.log(error);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Fetches all content from a particular github api endpoint
|
|
* using their pagination schema.
|
|
*
|
|
* @param {*} username username of github client
|
|
* @param {*} apiPath following or followers
|
|
* @param {*} page current pagination page
|
|
* @param {*} lst list we are building on
|
|
*/
|
|
const fetchAllWithPagination = async (apiPath, page, lst) => {
|
|
try {
|
|
const req = await queryGithubAPIRaw(`${apiPath}?page=${page}${API_PAGINATION}`);
|
|
if (req.body.hasOwnProperty("length")) {
|
|
const list = lst.concat(req.body);
|
|
if(page < API_MAX_PAGES && req.length === API_PAGINATION_SIZE) {
|
|
const redo = await fetchAllWithPagination(apiPath, page + 1, list);
|
|
return redo;
|
|
}
|
|
return list;
|
|
}
|
|
} catch (error) {
|
|
console.log("Error with api request");
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Makes a copy of a JS object with certain properties
|
|
*
|
|
* @param {*} props
|
|
* @param {*} obj
|
|
*/
|
|
function copyWithProperties(props, obj)
|
|
{
|
|
var newO = new Object();
|
|
for(var i =0; i < props.length; i++)
|
|
{
|
|
newO[props[i]] = obj[props[i]];
|
|
}
|
|
return newO;
|
|
}
|
|
|
|
|
|
/**
|
|
* Combines the list of friends and followers ignoring duplicates
|
|
* that are already in the list. (person is both following and followed by someone)
|
|
*
|
|
* This also removes any unused properties like events_url and organizations_url
|
|
*
|
|
* @param {*} followingAndFollowers
|
|
*/
|
|
const minimizeFriends = people => {
|
|
let friendLst = [];
|
|
let ids = new Set();
|
|
people.forEach(person => {
|
|
if(!ids.has(person.id)) {
|
|
ids.add(person.id);
|
|
friendLst.push({
|
|
login: person.login,
|
|
avatar_url: person.avatar_url
|
|
});
|
|
}
|
|
});
|
|
return friendLst;
|
|
}
|
|
|
|
|
|
/**
|
|
* Fetches all the people that are either following or is followed
|
|
* by a person on github. This will cache the results to make simultaneous
|
|
* connections easier and less demanding on the github API.
|
|
*
|
|
* @param {*} user
|
|
*/
|
|
const queryFriends = async user => {
|
|
const cacheHit = cache.get("/friends/" + user);
|
|
if (cacheHit){
|
|
console.log("Friends cache hit");
|
|
return cacheHit;
|
|
}
|
|
|
|
try {
|
|
const followers = await fetchAllWithPagination(API_USER_PATH + user + API_FOLLOWERS, 1, []);
|
|
const following = await fetchAllWithPagination(API_USER_PATH + user + API_FOLLOWING, 1, []);
|
|
const fList = minimizeFriends(following.concat(followers));
|
|
cache.put(`/friends/${user}`, fList);
|
|
return fList;
|
|
} catch (error) {
|
|
console.log("API Error", err);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
*
|
|
* Fetches all of the members of an organization from the
|
|
* API or cache
|
|
*
|
|
* /orgs/RITlug/members?page=1
|
|
*
|
|
* @param {*} orgName
|
|
*/
|
|
const getOrganizationMembers = async orgName => {
|
|
const cacheHit = cache.get("/org/users/" + orgName);
|
|
if (cacheHit){
|
|
console.log("Org members cache hit");
|
|
return cacheHit;
|
|
}
|
|
|
|
try {
|
|
const members = await fetchAllWithPagination(API_ORGS_PATH + orgName + "/members", 1, []);
|
|
const membersMin = minimizeFriends(members);
|
|
cache.put("/org/users/" + orgName, membersMin);
|
|
return membersMin;
|
|
} catch (error) {
|
|
console.log(error);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Minimizes the JSON for a list of repositories
|
|
*
|
|
* @param {*} repositories
|
|
*/
|
|
const minimizeRepositories = repositories => {
|
|
let rList = [];
|
|
repositories.forEach(repo => {
|
|
rList.push(copyWithProperties(["name", "created_at", "homepage",
|
|
"description", "language", "forks", "watchers",
|
|
"open_issues_count", "license", "html_url"],
|
|
repo));
|
|
})
|
|
|
|
return rList;
|
|
}
|
|
|
|
|
|
/**
|
|
* Fetches all repositories from the API
|
|
*
|
|
* @param {*} user name of org/user
|
|
* @param {*} orgsOrUsers either /users/ or /orgs/
|
|
*/
|
|
const queryRepositories = async (user, orgsOrUsers) => {
|
|
const cacheHit = cache.get(user + REPOS_PATH);
|
|
if (cacheHit) {
|
|
console.log("Repositories cache hit");
|
|
return cacheHit;
|
|
}
|
|
|
|
try {
|
|
const repos = await fetchAllWithPagination(orgsOrUsers + user + REPOS_PATH, 1, []);
|
|
const minRepos = minimizeRepositories(repos);
|
|
cache.put(`${user}${REPOS_PATH}`, minRepos);
|
|
return minRepos;
|
|
} catch (error) {
|
|
console.log(error)
|
|
console.log("bad things went down");
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* /users/name/following/followers
|
|
*/
|
|
routes.get("/friends/:name", async (req, res)=> {
|
|
try {
|
|
const query = await queryFriends(req.params.name);
|
|
res.json(query);
|
|
} catch (error) {
|
|
res.status(500).json({error: 'API error fetching friends'});
|
|
}
|
|
});
|
|
|
|
|
|
|
|
routes.get("/org/users/:name", async (request, res) => {
|
|
try {
|
|
const orgMembers = await getOrganizationMembers(request.params.name);
|
|
res.json(orgMembers).end();
|
|
} catch (error) {
|
|
res
|
|
.status(500)
|
|
.json({error: 'API error fetching friends'})
|
|
.end();
|
|
}
|
|
});
|
|
|
|
|
|
routes.get("/repositories/:name", async (req, res) => {
|
|
try {
|
|
const repos = await queryRepositories(req.params.name, API_USER_PATH);
|
|
res.json(repos).end();
|
|
} catch (error) {
|
|
res.status(500)
|
|
.json({error: 'API error fetching friends'})
|
|
.end();
|
|
}
|
|
});
|
|
|
|
|
|
routes.get("/org/repositories/:name", (request, result)=>
|
|
{
|
|
queryRepositories(request.params.name, API_ORGS_PATH).then(repos=>
|
|
{
|
|
result.json(repos)
|
|
.end();
|
|
}).catch(error=>
|
|
{
|
|
result.status(500)
|
|
.json({error: 'API error fetching friends'})
|
|
.end();
|
|
});
|
|
});
|
|
|
|
|
|
routes.get('/*', (request, result) =>
|
|
{
|
|
var gitHubAPIURL = request.url;
|
|
|
|
result.setHeader('Content-Type', 'application/json');
|
|
queryGitHubAPI(gitHubAPIURL).then((data)=>
|
|
{
|
|
if(data.hasOwnProperty("id") || data[0].hasOwnProperty("id"))
|
|
{
|
|
result.write(JSON.stringify(data));
|
|
}
|
|
else
|
|
{
|
|
result.write("[]");
|
|
}
|
|
result.end();
|
|
}).catch((error)=>
|
|
{
|
|
try
|
|
{
|
|
if(error.hasOwnProperty("id") || error[0].hasOwnProperty("id"))
|
|
{
|
|
result.write(JSON.stringify(error));
|
|
}
|
|
else
|
|
{
|
|
result.write("[]");
|
|
}
|
|
|
|
}
|
|
catch(error)
|
|
{
|
|
result.write("[]");
|
|
};
|
|
result.end();
|
|
});
|
|
|
|
if(cache.size() > 50000)
|
|
{
|
|
cache.clear();
|
|
}
|
|
});
|
|
|
|
module.exports = routes;
|