drksephy / git-technetium

Repository for a github powered application built using the MEAN stack

git-technetium

Repository for a github powered application built using the MEAN stack. The following features are planned:

[X] Create modules for viewing statistics on a repository 
[ ] Build meaningful graphs using D3 
[ ] Ability to export reports to PDF
[ ] Unit testing using Mocha/PhantomJS where applicable
[ ] Centralized Issue Tracker
[ ] Repository Subscription Manager
[ ] Integrate application with Bitbucket API

A more detailed set of current tasks can be found here: task list.

Dependencies

After cloning this repository, the first step is to install all dependencies.

git-technetium$ npm install
git-technetium$ bower install

NOTE: If you are on a Mac, you will need to run sudo npm install.

Getting Started

Inside of your Github account settings, please register this application in order to obtain a client_id and client_secret. This will allow you to make up to 5000 requests per hour, and allows for quicker testing. For help on registering an application, see this link Once you have obtained these keys, modify config.js as shown below:

var CLIENT_ID = 'YOUR_CLIENT_ID';
var CLIENT_SECRET = 'YOUR_CLIENT_SECRET';

Useful Libraries / Links

• istanbul - JS code coverage tool.
• karma-runner - Powerful test runner supporting several testing frameworks.
• async.js - A library with powerful functions for dealing with asynchronous code.
• pdfmake - A client/server-side PDF printing library.
• QUnit - A powerful JavaScript unit-testing framework.
• UnitJS - Another powerful JavaScript unit-testing framework.
• mocha - A JavaScript testing framework with powerful testing features.
• D3 - A JavaScript library for using documents as data. Useful for a wide array of graphs.
• PhantomJS - A headless WebKit with a JavaScript API, useful for testing with frameworks such as Mocha.
• Git API - Github API.
• Bitbucket API Console - A web console for interacting with the Bitbucket API.

git-technetium's Issues

Pagination problems

As we have recently discovered, the github API only returns a fixed amount of data at a time. The rest of any queried data can be retrieved by pagination. Therefore, we need a clean method of chaining several requests and checking if the needed data is not empty. If it is not empty on each page, we chain requests until we run into an empty set of data, i.e we are done parsing data.

Query and display the commit totals on the client

In order to display the number of commits for each user in a repository, the following needs to be built:

• Pass the repository name as a parameter from the client to the server.
• An AngularJS Factory for getting the data. from the server.
• An AngularJS Controller for handling the data
• An AngularJS Partial for displaying the data.

Create server route for querying pull requests

The server obtains the number of pull requests per contributor by having a route in which the server have access to the repository and queries.

Create basic controller for angular.js site

A basic controller for controlling the basic angular.js site needs to be built.

Create partial for displaying all issues data on client

The view for the issues. The user will be able to input a repository name into a form. As per the assigned task, the user can expect to see all issue titles for the repository, regardless of its state (open, closed, etc.), provided that a valid, existing repository name was given.

Front-end needs to be built

Once more features start to come in, a front-end needs to be built. It can be taken from another site (such as a template or a theme), or it can be built from scratch.

Everyone can contribute to this, and we will decide which front-end is the best for this application. Any useful themes/templates should be posted here.

Parse pull request comments data before sending to client

Before sending the JSON response to the client, a parser must be written to prepare the data to be sent by the server.

Create factory for getting number of issues assigned per contributor data on client from server

The factory will handle the request to the endpoint defined in the server route for getting the number of assigned issues per contributor. The factory will handle the following:

• Send the provided repository name to the server
• Returns the server response to wherever this factory is called

Create controller for handling pull request data on client

The client must have a controller to handle the logic when the user visits the respective pulls view. The controller will handle for following:

Accepting the user-defined repository name
Making the call to the pulls factory
Receiving the response from the pulls factory
Sending the response to the pulls view

Create partial for displaying issues opened per contributor data on client

The view for the issues. The user will be able to input a repository name into a form. As per the assigned task, the user can expect to see all the tally of opened issues per contributor for the repository, provided that a valid, existing repository name was given.

Create controller for handling issues opened per contributor data on client

The client must have a controller to handle the logic when the user visits the respective number of issues opened per contributor view. The controller will handle for following:

• Accepting the user-defined repository name
• Making the call to the opened issues factory
• Receiving the response from the opened issues factory
• Sending the response to the issues opened per contributor view

Create partial for displaying pull request comments data on client

A partial is needed to properly render the pull request comments per contributor.

Create partial for displaying number of issues closed per contributor on client

The view for the number of issues closed per contributor. The user will be able to input a repository name into a form. As per the assigned task, the user can expect to see all the tally of closed issues per contributor for the repository, provided that a valid, existing repository name was given.

Create server route for querying pull request comments

The server obtains the number of pull requests comments per contributor by having a route in which the server have access to the repository and queries.

Create factory for getting data on client from server

The factory will handle the request to the issues endpoint defined in the server route for getting issues. The factory will handle the following:

• Send the provided repository name to the server
• Returns the server response to wherever this factory is called

Create partial for displaying pull request data on client

A partial is needed to properly render the pull requests.

Create controller for handling number of issues closed per contributor data on client

The client must have a controller to handle the logic when the user visits the respective number of issues closed per contributor view. The controller will handle for following:

• Accepting the user-defined repository name
• Making the call to the closed issues factory
• Receiving the response from the closed issues factory
• Sending the response to the number of issues closed per contributor view

Create server route for querying issues opened per contributor

The server must have a route in which the client can access in order to obtain the number of opened issues per contributor for the repository.

Create partial for displaying number of issues assigned per contributor on client

The view for the number of issues assigned per contributor. The user will be able to input a repository name into a form. As per the assigned task, the user can expect to see all the tally of assigned issues per contributor for the repository, provided that a valid, existing repository name was given.

Write parser for commits per contributors data

Before sending the JSON response to the client, a parser must be written to prepare the data to be sent by the server.

Create factory for getting issue comments data on client from server

The factory will handle the request to the issue comments endpoint defined in the server route for getting issue comments per contributor. The factory will handle the following:

• Send the provided repository name to the server
• Returns the server response to wherever this factory is called

Parse issues opened per contributor data before sending to client

The server must first obtain the repository issue data from the GitHub API and then parse the necessary data relevant to our application. As per the assigned task, the following data will be parsed:

• Issues opened
• Name of contributor who opened the issue

Then the server must tally up which contributor opened which issue. Once all issues are tallied, the server will send the data to the client.

Create server route for querying number of issues closed per contributor

The server must have a route in which the client can access in order to obtain the number of issues closed per contributor for the repository.

Create minimalistic express.js server

Create a barebones server which has a single basic route.

Parse number of issues assigned per contributor data before sending to client

The server must first obtain the repository issue data from the GitHub API and then parse the necessary data relevant to our application. As per the assigned task, the following data will be parsed:

• Issues assigned
• Name of contributor who was assigned the issue

Then the server must tally up which contributor was assigned which issue. Once all issues are tallied, the server will send the data to the client.

Create server route for querying issue comments

The server obtains the number of issue comments per contributor by having a route in which the server have access to the repository and queries.

Create server route for querying number of issues assigned per contributor

The server must have a route in which the client can access in order to obtain the number of assigned issues per contributor for the repository.

Create factory for getting commit comment data

A factory needs to be built to fetch the commit comment data from the back-end server.

Parse pull requests data before sending to client

Before sending the JSON response to the client, a parser must be written to prepare the data to be sent by the server.

Create factory for getting number of issues closed per contributor data on client from server

The factory will handle the request to the endpoint defined in the server route for getting the number of closed issues per contributor. The factory will handle the following:

• Send the provided repository name to the server
• Returns the server response to wherever this factory is called

Create route for querying lines of code added/deleted

A server-side route needs to be built in order to query the lines of code data from github's api.

Create server route for querying commit comments

The server-side application needs a route which will be used to query data from github's commit endpoint, which in turn accumulates all comments for each contributor in a given repository.

Parse commit comments per contributor before passing to client

The data received by Github's api (commit comments per contributor) needs to be parsed before being handed to the client. This helps in building partials to render the data.

Create controller for handling pull request comments data on client

The client must have a controller to handle the logic when the user visits the respective pull requests comments view. The controller will handle for following:

• Accepting the user-defined repository name
• Making the call to the pull request comments factory
• Receiving the response from the pull request comments factory
• Sending the response to the pull request comments view

Build route for querying number of commits

In order to return the number of commits per contributor in a repository, a route must be built on the server which queries the https://developer.github.com/v3/repos/statistics/ endpoint.

Create server route for querying getting issues

The server must first have a route in which the client can access in order to obtain the issues for the repository.

Create controller for handling issue data on client

The client must have a controller to handle the logic when the user visits the respective issues view. The controller will handle for following:

• Accepting the user-defined repository name
• Making the call to the issues factory
• Receiving the response from the issue factory
• Sending the response to the issues view

Parse issue comments data before sending to client

Before sending the JSON response to the client, a parser must be written to prepare the data to be sent by the server.

Parse number of issues closed per contributor data before sending to client

The server must first obtain the repository issue data from the GitHub API and then parse the necessary data relevant to our application. As per the assigned task, the following data will be parsed:

• Issues closed
• Name of contributor who was closed the issue

Then the server must tally up which contributor closed which issue. Once all issues are tallied, the server will send the data to the client.

Create factory for getting lines of code data

In order to send the request and get the data for lines of code, a factory method must be built to handle this interaction with the server.

Create controller for handling number of issues assigned per contributor data on client

The client must have a controller to handle the logic when the user visits the respective number of issues assigned per contributor view. The controller will handle for following:

• Accepting the user-defined repository name
• Making the call to the assigned issues factory
• Receiving the response from the assigned issues factory
• Sending the response to the number of issues assigned per contributor view

Parse data before sending to client

The server must first obtain repository issue data from the GitHub API and then parse the necessary data relevant to our application. As per the assigned task, the following data will be parsed:

• Issue title

Create partial for displaying issue comment data on client

A partial is needed to properly render the issue comments.

Create factory for getting data (pull requests) on client from server

The factory will handle the request to the pulls endpoint defined in the server route for getting pull request per contributor. The factory will handle the following:

Send the provided repository name to the server
Returns the server response to wherever this factory is called

Create partial for displaying commit comment data

A partial needs to be written to properly render the commit comment data.

Create factory for getting pull request comments data on client from server

The factory will handle the request to the pull request comments endpoint defined in the server route for getting pull request comments per contributor. The factory will handle the following:

• Send the provided repository name to the server
• Returns the server response to wherever this factory is called

Create dependencies for base application

Any packages needed for running a minimalistic application need to be placed into package.json and bower.json files.

Create factory for getting issues opened per contributor data on client from server

The factory will handle the request to the issues endpoint defined in the server route for getting the number of opened issues per contributor. The factory will handle the following:

• Send the provided repository name to the server
• Returns the server response to wherever this factory is called

Create controller for handling issue comment data on client

The client must have a controller to handle the logic when the user visits the respective issue comments view. The controller will handle for following:

• Accepting the user-defined repository name
• Making the call to the issue comments factory
• Receiving the response from the issue comments factory
• Sending the response to the issue comments view

Create controller for handling commit comment data on client

A controller needs to be built which receives data from a factory method. The controller will return the commit data to a partial for rendering.