3548 lines
155 KiB
JavaScript
3548 lines
155 KiB
JavaScript
/**
|
||
* mixin repos
|
||
*
|
||
* Copyright 2012 Cloud9 IDE, Inc.
|
||
*
|
||
* This product includes software developed by
|
||
* Cloud9 IDE, Inc (http://c9.io).
|
||
*
|
||
* Author: Mike de Boer <info@mikedeboer.nl>
|
||
**/
|
||
|
||
"use strict";
|
||
|
||
var error = require("./../../error");
|
||
var Util = require("./../../util");
|
||
|
||
var repos = module.exports = {
|
||
repos: {}
|
||
};
|
||
|
||
(function() {
|
||
/** section: github
|
||
* repos#getAll(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - type (String): Optional. Possible values: `all`, `owner`, `public`, `private`, `member`. Default: `all`. Validation rule: ` ^(all|owner|public|private|member)$ `.
|
||
* - sort (String): Optional. Possible values: `created`, `updated`, `pushed`, `full_name`. Default: `full_name`. Validation rule: ` ^(created|updated|pushed|full_name)$ `.
|
||
* - direction (String): Optional. Validation rule: ` ^(asc|desc)$ `.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getAll = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getFromUser(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - type (String): Optional. Possible values: `all`, `owner`, `member`. Default: `public`. Validation rule: ` ^(all|owner|member)$ `.
|
||
* - sort (String): Optional. Possible values: `created`, `updated`, `pushed`, `full_name`. Default: `full_name`. Validation rule: ` ^(created|updated|pushed|full_name)$ `.
|
||
* - direction (String): Optional. Validation rule: ` ^(asc|desc)$ `.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getFromUser = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getFromOrg(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - org (String): Required.
|
||
* - type (String): Optional. Possible values: `all`, `public`, `member`. Default: `all`. Validation rule: ` ^(all|public|member)$ `.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getFromOrg = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#create(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - name (String): Required.
|
||
* - description (String): Optional.
|
||
* - homepage (String): Optional.
|
||
* - private (Boolean): Optional. True to create a private repository, false to create a public one. Creating private repositories requires a paid GitHub account. Default is false.
|
||
* - has_issues (Boolean): Optional. True to enable issues for this repository, false to disable them. Default is true.
|
||
* - has_wiki (Boolean): Optional. True to enable the wiki for this repository, false to disable it. Default is true.
|
||
* - has_downloads (Boolean): Optional. True to enable downloads for this repository, false to disable them. Default is true.
|
||
* - auto_init (Boolean): Optional. True to create an initial commit with empty README. Default is false
|
||
* - gitignore_template (String): Optional. Desired language or platform .gitignore template to apply. Ignored if auto_init parameter is not provided.
|
||
**/
|
||
this.create = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#createFromOrg(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - org (String): Required.
|
||
* - name (String): Required.
|
||
* - description (String): Optional.
|
||
* - homepage (String): Optional.
|
||
* - private (Boolean): Optional. True to create a private repository, false to create a public one. Creating private repositories requires a paid GitHub account. Default is false.
|
||
* - has_issues (Boolean): Optional. True to enable issues for this repository, false to disable them. Default is true.
|
||
* - has_wiki (Boolean): Optional. True to enable the wiki for this repository, false to disable it. Default is true.
|
||
* - has_downloads (Boolean): Optional. True to enable downloads for this repository, false to disable them. Default is true.
|
||
* - auto_init (Boolean): Optional. True to create an initial commit with empty README. Default is false
|
||
* - gitignore_template (String): Optional. Desired language or platform .gitignore template to apply. Ignored if auto_init parameter is not provided.
|
||
* - team_id (Number): Optional. The id of the team that will be granted access to this repository. This is only valid when creating a repo in an organization. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.createFromOrg = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#get(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
**/
|
||
this.get = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#one(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - id (String): Required.
|
||
**/
|
||
this.one = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#update(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - name (String): Required.
|
||
* - description (String): Optional.
|
||
* - homepage (String): Optional.
|
||
* - private (Boolean): Optional. True to create a private repository, false to create a public one. Creating private repositories requires a paid GitHub account. Default is false.
|
||
* - has_issues (Boolean): Optional. True to enable issues for this repository, false to disable them. Default is true.
|
||
* - has_wiki (Boolean): Optional. True to enable the wiki for this repository, false to disable it. Default is true.
|
||
* - has_downloads (Boolean): Optional. True to enable downloads for this repository, false to disable them. Default is true.
|
||
* - default_branch (String): Optional. Updates the default branch for this repository.
|
||
**/
|
||
this.update = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#delete(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
**/
|
||
this.delete = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#merge(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - base (String): Required. The branch (or git ref) you want your changes pulled into. This should be an existing branch on the current repository. You cannot submit a pull request to one repo that requests a merge to a base of another repo.
|
||
* - head (String): Required. The branch (or git ref) where your changes are implemented.
|
||
* - commit_message (String): Optional. Commit message to use for the merge commit. If omitted, a default message will be used.
|
||
**/
|
||
this.merge = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getContributors(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - anon (Boolean): Optional. Set to 1 or true to include anonymous contributors in results.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getContributors = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getLanguages(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getLanguages = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getTeams(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getTeams = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getTags(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getTags = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getBranches(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getBranches = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getBranch(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - branch (String): Required.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getBranch = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getCollaborators(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getCollaborators = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getCollaborator(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - collabuser (String): Required.
|
||
**/
|
||
this.getCollaborator = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#addCollaborator(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - collabuser (String): Required.
|
||
**/
|
||
this.addCollaborator = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#removeCollaborator(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - collabuser (String): Required.
|
||
**/
|
||
this.removeCollaborator = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getCommits(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - sha (String): Optional. Sha or branch to start listing commits from.
|
||
* - path (String): Optional. Only commits containing this file path will be returned.
|
||
* - author (String): Optional. GitHub login or email address by which to filter by commit author.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
* - since (Date): Optional. Timestamp in ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ
|
||
* - until (Date): Optional. Timestamp in ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ
|
||
**/
|
||
this.getCommits = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getCommit(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - sha (String): Required.
|
||
**/
|
||
this.getCommit = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getAllCommitComments(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getAllCommitComments = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getCommitComments(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - sha (String): Required.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getCommitComments = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#createCommitComment(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - sha (String): Required.
|
||
* - body (String): Required.
|
||
* - commit_id (String): Required. Sha of the commit to comment on.
|
||
* - path (String): Optional. Relative path of the file to comment on.
|
||
* - position (Number): Optional. Line index in the diff to comment on.
|
||
* - line (Number): Optional. Line number in the file to comment on. Defaults to 1.
|
||
**/
|
||
this.createCommitComment = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getCommitComment(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - id (String): Required.
|
||
**/
|
||
this.getCommitComment = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#updateCommitComment(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - id (String): Required.
|
||
* - body (String): Required.
|
||
**/
|
||
this.updateCommitComment = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#compareCommits(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - base (String): Required. The branch (or git ref) you want your changes pulled into. This should be an existing branch on the current repository. You cannot submit a pull request to one repo that requests a merge to a base of another repo.
|
||
* - head (String): Required. The branch (or git ref) where your changes are implemented.
|
||
**/
|
||
this.compareCommits = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#deleteCommitComment(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - id (String): Required.
|
||
**/
|
||
this.deleteCommitComment = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getReadme(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - ref (String): Optional. The String name of the Commit/Branch/Tag. Defaults to master.
|
||
**/
|
||
this.getReadme = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getContent(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - path (String): Optional. The content path.
|
||
* - ref (String): Optional. The String name of the Commit/Branch/Tag. Defaults to master.
|
||
**/
|
||
this.getContent = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#createContent(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - content (String): Optional.
|
||
* - message (String): Optional.
|
||
* - path (String): Optional. The content path.
|
||
* - ref (String): Optional. The String name of the Commit/Branch/Tag. Defaults to master.
|
||
**/
|
||
this.createContent = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#createFile(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - path (String): Required. The content path.
|
||
* - message (String): Required. The commit message.
|
||
* - content (String): Required. The new file content, Base64 encoded.
|
||
* - branch (String): Optional. The branch name. If not provided, uses the repository’s default branch (usually master).
|
||
* - author (Json): Optional.
|
||
* - committer (Json): Optional.
|
||
**/
|
||
this.createFile = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#updateFile(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - path (String): Required. The content path.
|
||
* - message (String): Required. The commit message.
|
||
* - content (String): Required. The updated file content, Base64 encoded.
|
||
* - sha (String): Required. The blob SHA of the file being replaced.
|
||
* - branch (String): Optional. The branch name. If not provided, uses the repository’s default branch (usually master).
|
||
* - author (Json): Optional.
|
||
* - committer (Json): Optional.
|
||
**/
|
||
this.updateFile = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#deleteFile(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - path (String): Required. The content path.
|
||
* - message (String): Required. The commit message.
|
||
* - sha (String): Required. The blob SHA of the file being removed.
|
||
* - branch (String): Optional. The branch name. If not provided, uses the repository’s default branch (usually master).
|
||
* - author (Json): Optional.
|
||
* - committer (Json): Optional.
|
||
**/
|
||
this.deleteFile = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getArchiveLink(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - ref (String): Optional. String of the name of the fully qualified reference (ie: heads/master). If it doesn’t have at least one slash, it will be rejected.
|
||
* - archive_format (String): Required. Either tarball or zipball Validation rule: ` ^(tarball|zipball)$ `.
|
||
**/
|
||
this.getArchiveLink = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getDownloads(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getDownloads = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getDownload(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - id (String): Required.
|
||
**/
|
||
this.getDownload = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#deleteDownload(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - id (String): Required.
|
||
**/
|
||
this.deleteDownload = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getForks(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - sort (String): Optional. Possible values: `newest`, `oldest`, `watchers`, default: `newest`. Validation rule: ` ^(newest|oldest|watchers)$ `.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getForks = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#fork(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - organization (String): Optional. Organization login. The repository will be forked into this organization.
|
||
**/
|
||
this.fork = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getKeys(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getKeys = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getKey(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - id (String): Required.
|
||
**/
|
||
this.getKey = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#createKey(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - title (String): Required.
|
||
* - key (String): Required.
|
||
**/
|
||
this.createKey = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#updateKey(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - id (String): Required.
|
||
* - title (String): Required.
|
||
* - key (String): Required.
|
||
**/
|
||
this.updateKey = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#deleteKey(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - id (String): Required.
|
||
**/
|
||
this.deleteKey = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getStargazers(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getStargazers = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getStarred(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getStarred = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getStarredFromUser(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getStarredFromUser = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getStarring(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getStarring = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#star(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
**/
|
||
this.star = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#unStar(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
**/
|
||
this.unStar = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getWatchers(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getWatchers = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getWatched(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getWatched = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getWatchedFromUser(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getWatchedFromUser = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getWatching(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getWatching = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#watch(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
**/
|
||
this.watch = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#unWatch(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
**/
|
||
this.unWatch = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getHooks(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getHooks = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getHook(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - id (String): Required.
|
||
**/
|
||
this.getHook = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#createHook(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - name (String): Required.
|
||
* - config (Json): Required. A Hash containing key/value pairs to provide settings for this hook. These settings vary between the services and are defined in the github-services repo. Booleans are stored internally as `1` for true, and `0` for false. Any JSON true/false values will be converted automatically.
|
||
* - events (Array): Optional. Determines what events the hook is triggered for. Default: `['push']`.
|
||
* - active (Boolean): Optional. Determines whether the hook is actually triggered on pushes.
|
||
**/
|
||
this.createHook = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#updateHook(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - id (String): Required.
|
||
* - name (String): Required.
|
||
* - config (Json): Required. A Hash containing key/value pairs to provide settings for this hook. Modifying this will replace the entire config object. These settings vary between the services and are defined in the github-services repo. Booleans are stored internally as `1` for true, and `0` for false. Any JSON true/false values will be converted automatically.
|
||
* - events (Array): Optional. Determines what events the hook is triggered for. This replaces the entire array of events. Default: `['push']`.
|
||
* - add_events (Array): Optional. Determines a list of events to be added to the list of events that the Hook triggers for.
|
||
* - remove_events (Array): Optional. Determines a list of events to be removed from the list of events that the Hook triggers for.
|
||
* - active (Boolean): Optional. Determines whether the hook is actually triggered on pushes.
|
||
**/
|
||
this.updateHook = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#testHook(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - id (String): Required.
|
||
**/
|
||
this.testHook = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#deleteHook(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - id (String): Required.
|
||
**/
|
||
this.deleteHook = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getStatsContributors(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
**/
|
||
this.getStatsContributors = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getStatsCommitActivity(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
**/
|
||
this.getStatsCommitActivity = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getStatsCodeFrequency(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
**/
|
||
this.getStatsCodeFrequency = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getStatsParticipation(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
**/
|
||
this.getStatsParticipation = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getStatsPunchCard(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
**/
|
||
this.getStatsPunchCard = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getDeployments(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - sha (String): Optional. The short or long sha that was recorded at creation time. Default: none.
|
||
* - ref (String): Optional. The name of the ref. This can be a branch, tag, or sha. Default: none.
|
||
* - task (String): Optional. The name of the task for the deployment. e.g. deploy or deploy:migrations. Default: none.
|
||
* - environment (String): Optional. The name of the environment that was deployed to. e.g. staging or production. Default: none.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - page (Number): Optional. Page number of the results to fetch. Validation rule: ` ^[0-9]+$ `.
|
||
* - per_page (Number): Optional. A custom page size up to 100. Default is 30. Validation rule: ` ^[0-9]+$ `.
|
||
**/
|
||
this.getDeployments = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#createDeployment(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - ref (String): Required. The ref to deploy. This can be a branch, tag, or sha.
|
||
* - task (String): Required. The named task to execute. e.g. deploy or deploy:migrations. Default: deploy
|
||
* - auto_merge (Boolean): Optional. Optional parameter to merge the default branch into the requested ref if it is behind the default branch. Default: true
|
||
* - required_contexts (Array): Optional. Optional array of status contexts verified against commit status checks. If this parameter is omitted from the parameters then all unique contexts will be verified before a deployment is created. To bypass checking entirely pass an empty array. Defaults to all unique contexts.
|
||
* - payload (String): Optional. Optional JSON payload with extra information about the deployment. Default: ''
|
||
* - environment (String): Optional. The name of the environment that was deployed to. e.g. staging or production. Default: none.
|
||
* - description (String): Optional. Optional short description. Default: ''
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
**/
|
||
this.createDeployment = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#getDeploymentStatuses(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - id (String): Required.
|
||
**/
|
||
this.getDeploymentStatuses = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
/** section: github
|
||
* repos#createDeploymentStatus(msg, callback) -> null
|
||
* - msg (Object): Object that contains the parameters and their values to be sent to the server.
|
||
* - callback (Function): function to call when the request is finished with an error as first argument and result data as second argument.
|
||
*
|
||
* ##### Params on the `msg` object:
|
||
*
|
||
* - headers (Object): Optional. Key/ value pair of request headers to pass along with the HTTP request. Valid headers are: 'If-Modified-Since', 'If-None-Match', 'Cookie', 'User-Agent', 'Accept', 'X-GitHub-OTP'.
|
||
* - state (String): Optional. The state of the status. Can be one of pending, success, error, or failure.
|
||
* - target_url (String): Optional. The target URL to associate with this status. This URL should contain output to keep the user updated while the task is running or serve as historical information for what happened in the deployment. Default: ''
|
||
* - description (String): Optional. A short description of the status. Default: ''
|
||
* - user (String): Required.
|
||
* - repo (String): Required.
|
||
* - id (String): Required.
|
||
**/
|
||
this.createDeploymentStatus = function(msg, block, callback) {
|
||
var self = this;
|
||
this.client.httpSend(msg, block, function(err, res) {
|
||
if (err)
|
||
return self.sendError(err, null, msg, callback);
|
||
|
||
var ret;
|
||
try {
|
||
ret = res.data;
|
||
var contentType = res.headers["content-type"];
|
||
if (contentType && contentType.indexOf("application/json") !== -1)
|
||
ret = JSON.parse(ret);
|
||
}
|
||
catch (ex) {
|
||
if (callback)
|
||
callback(new error.InternalServerError(ex.message), res);
|
||
return;
|
||
}
|
||
|
||
if (!ret)
|
||
ret = {};
|
||
if (typeof ret == "object") {
|
||
if (!ret.meta)
|
||
ret.meta = {};
|
||
["x-ratelimit-limit", "x-ratelimit-remaining", "x-ratelimit-reset", "x-oauth-scopes", "link", "location", "last-modified", "etag", "status"].forEach(function(header) {
|
||
if (res.headers[header])
|
||
ret.meta[header] = res.headers[header];
|
||
});
|
||
}
|
||
|
||
if (callback)
|
||
callback(null, ret);
|
||
});
|
||
};
|
||
|
||
}).call(repos.repos);
|