public GitHubRequest <GistModel> CreateGist(GistCreateModel gist) { //Great... The RestSharp serializer can't handle this object... //Dictionary<string, obj> confuses it and converts it into {"key": "ok", "value": "dokie"} //instead of {"ok": "dokie"} var obj = new Dictionary <string, object>(); obj.Add("description", gist.Description); obj.Add("public", gist.Public); var files = new Dictionary <string, object>(); obj.Add("files", files); if (gist.Files != null) { foreach (var f in gist.Files.Keys) { var content = new Dictionary <string, object>(); files.Add(f, content); content.Add("content", gist.Files[f].Content); } } return(GitHubRequest.Post <GistModel>(Client.ApiUri + "/gists", obj)); }
public GitHubRequestAsyncHandle SearchRepositoriesAsync(string repo, Action<IEnumerable<Repository>> callback, Action<GitHubException> onError) { Ensure.ArgumentNotNull(repo, "repo"); var resource = string.Format("/repos/search/{0}", repo.Replace(' ', '+')); var request = new GitHubRequest(resource, API.v2, Method.GET); return _client.CallApiAsync<RepositorySearchResults>( request, resp => callback(resp.Data.Repositories.Select( r => new Repository { Owner = new User { Login = r.Owner }, Name = r.Name, Description = r.Description, Language = r.Language, NumberOfForks = r.Forks, NumberOfWatchers = r.Watchers, Url = r.Url, CreatedDate = r.CreatedAt, LastUpdatedDate = r.PushedAt, IsFork = r.IsFork, IsPrivate = r.IsPrivate, OpenIssues = r.OpenIssues, HomePage = r.HomePage, Size = r.Size, })), onError); }
public void CallApiAsync_ShouldPassRequestParameters_ToRestRequest() { var expectedKey = "foo"; var expectedValue = "bar"; var mockFactory = new Mock <IRestClientFactory>(MockBehavior.Strict); var mockRestClient = new Mock <IRestClient>(MockBehavior.Strict); mockFactory.Setup <IRestClient>(f => f.CreateRestClient(It.IsAny <string>())).Returns(mockRestClient.Object); mockRestClient .Setup(c => c.ExecuteAsync <object>( It.Is <IRestRequest>(r => r.Parameters.Where(p => (p.Name == expectedKey) && ((string)p.Value == expectedValue)) .Count() == 1), It.IsAny <Action <IRestResponse <object>, RestRequestAsyncHandle> >())) .Returns(_testHandle) .Callback <IRestRequest, Action <IRestResponse <object>, RestRequestAsyncHandle> >((r, c) => c(new RestResponse <object>(), _testHandle)); mockRestClient.SetupSet(c => c.Authenticator = It.IsAny <IAuthenticator>()); var client = CreateClient(mockFactory.Object); var request = new GitHubRequest("resource", API.v2, NGitHub.Web.Method.POST, new NGitHub.Web.Parameter(expectedKey, expectedValue)); client.CallApiAsync <object>(request, o => { }, e => { }); mockRestClient.VerifyAll(); }
public GitHubRequestAsyncHandle CreateIssueAsync(string user, string repo, string title, string body, string assignee, string mileStone, string[] labels, Action <Issue> callback, Action <GitHubException> onError) { Requires.ArgumentNotNull("user", user); Requires.ArgumentNotNull("repo", repo); Requires.ArgumentNotNull("title", title); var resource = string.Format("/repos/{0}/{1}/issues", user, repo); var request = new GitHubRequest(resource, API.v3, Method.POST, new IssueDto { Title = title, Body = body, Assignee = assignee, Milestone = mileStone, Labels = labels }); return(_client.CallApiAsync <Issue>(request, r => callback(r.Data), onError)); }
public GitHubRequestAsyncHandle CreateCommentAsync(string user, string repo, int issueNumber, string comment, Action <Comment> callback, Action <GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); Requires.ArgumentNotNull(repo, "repo"); Requires.ArgumentNotNull(comment, "comment"); var resource = string.Format("/repos/{0}/{1}/issues/{2}/comments", user, repo, issueNumber); var request = new GitHubRequest(resource, API.v3, Method.POST, new CommentDto { Body = comment }); return(_client.CallApiAsync <Comment>(request, r => callback(r.Data), onError)); }
public Task <GitHubResponse <IEnumerable <IssueComment> > > IssueComments(string repoFullName, int issueNumber, DateTimeOffset?since, GitHubCacheDetails cacheOptions, RequestPriority priority) { var request = new GitHubRequest($"repos/{repoFullName}/issues/{issueNumber}/comments", cacheOptions, priority); request.AddParameter("since", since); return(FetchPaged(request, (IssueComment x) => x.Id)); }
public GitHubRequestAsyncHandle CreateCommentAsync(string user, string repo, int pullRequestId, int commentIdToReplyTo, string body, Action <CommitComment> callback, Action <GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); Requires.ArgumentNotNull(repo, "repo"); Requires.ArgumentNotNull(body, "body"); var resource = string.Format("/repos/{0}/{1}/pulls/{2}/comments", user, repo, pullRequestId); var request = new GitHubRequest(resource, API.v3, Method.POST, new ReplyCommentDto { Body = body, InReplyTo = commentIdToReplyTo }); return(_client.CallApiAsync <CommitComment>(request, r => callback(r.Data), onError)); }
public GitHubRequestAsyncHandle CreateIssueAsync(string user, string repo, string title, string body, string assignee, string mileStone, string[] labels, Action<Issue> callback, Action<GitHubException> onError) { Requires.ArgumentNotNull("user", user); Requires.ArgumentNotNull("repo", repo); Requires.ArgumentNotNull("title", title); var resource = string.Format("/repos/{0}/{1}/issues", user, repo); var request = new GitHubRequest(resource, API.v3, Method.POST, new IssueDto { Title = title, Body = body, Assignee = assignee, Milestone = mileStone, Labels = labels }); return _client.CallApiAsync<Issue>(request, r => callback(r.Data), onError); }
private Task <GitHubResponse <g.Account> > GitHubUser(string accessToken, CancellationToken cancellationToken) { AccessToken = accessToken; var request = new GitHubRequest("user"); return(_handlerPipeline.Fetch <g.Account>(this, request, cancellationToken)); }
public GitHubRequestAsyncHandle FollowAsync(string user, Action callback, Action <GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); var resource = string.Format("/user/following/{0}", user); var request = new GitHubRequest(resource, API.v3, Method.PUT); return(_gitHubClient.CallApiAsync <object>( request, r => { Debug.Assert(false, "all responses should be errors"); callback(); }, ex => { if (ex.Response.StatusCode == HttpStatusCode.NoContent) { callback(); return; } onError(ex); })); }
public GitHubRequest <GistModel> EditGist(GistEditModel gist) { var obj = new Dictionary <string, object>(); obj.Add("description", gist.Description); var files = new Dictionary <string, object>(); obj.Add("files", files); if (gist.Files != null) { foreach (var f in gist.Files.Keys) { if (gist.Files[f] == null) { files.Add(f, null); } else { var content = new Dictionary <string, object>(); files.Add(f, content); content.Add("content", gist.Files[f].Content); if (gist.Files[f].Filename != null) { content.Add("filename", gist.Files[f].Filename); } } } } return(GitHubRequest.Patch <GistModel>(Uri, obj)); }
public Task <GitHubResponse <IEnumerable <Milestone> > > Milestones(string repoFullName, GitHubCacheDetails cacheOptions, RequestPriority priority) { var request = new GitHubRequest($"repos/{repoFullName}/milestones", cacheOptions, priority); request.AddParameter("state", "all"); return(FetchPaged(request, (Milestone x) => x.Id)); }
public static Task RequestModel<TRequest>(this MvxViewModel viewModel, GitHubRequest<TRequest> request, bool forceDataRefresh, Action<GitHubResponse<TRequest>> update) where TRequest : new() { if (forceDataRefresh) { request.CheckIfModified = false; request.RequestFromCache = false; } var application = Mvx.Resolve<IApplicationService>(); var uiThrad = Mvx.Resolve<IUIThreadService>(); return Task.Run(async () => { var result = await application.Client.ExecuteAsync(request).ConfigureAwait(false); uiThrad.MarshalOnUIThread(() => update(result)); if (result.WasCached) { request.RequestFromCache = false; Task.Run(async () => { try { var r = await application.Client.ExecuteAsync(request).ConfigureAwait(false); uiThrad.MarshalOnUIThread(() => update(r)); } catch (NotModifiedException) { System.Diagnostics.Debug.WriteLine("Not modified: " + request.Url); } }).FireAndForget(); } }); }
public GitHubRequestAsyncHandle CreateCommentAsync(string user, string repo, int pullRequestId, string commitId, string body, string path, int position, Action<CommitComment> callback, Action<GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); Requires.ArgumentNotNull(repo, "repo"); Requires.ArgumentNotNull(body, "body"); Requires.ArgumentNotNull(path, "path"); var resource = string.Format("/repos/{0}/{1}/pulls/{2}/comments", user, repo, pullRequestId); var request = new GitHubRequest(resource, API.v3, Method.POST, new { commit_id = commitId, body = body, path = path, position = position }); return _client.CallApiAsync<CommitComment>(request, r => callback(r.Data), onError); }
public GitHubRequestAsyncHandle IsWatchingAsync(string user, string repo, Action <bool> callback, Action <GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); Requires.ArgumentNotNull(repo, "repo"); var resource = string.Format("/user/watched/{0}/{1}", user, repo); var request = new GitHubRequest(resource, API.v3, Method.GET); return(_client.CallApiAsync <object>( request, r => { Debug.Assert(false, "all responses should be errors"); callback(true); }, e => { if (e.Response.StatusCode == HttpStatusCode.NoContent) { callback(true); return; } if (e.Response.StatusCode == HttpStatusCode.NotFound) { callback(false); return; } onError(e); })); }
public Task <GitHubResponse <IEnumerable <Account> > > OrganizationMembers(string orgLogin, string role, GitHubCacheDetails cacheOptions, RequestPriority priority) { // defaults: filter=all, role=all var request = new GitHubRequest($"orgs/{orgLogin}/members", cacheOptions, priority); request.AddParameter("role", role); return(FetchPaged(request, (Account x) => x.Id)); }
public Task <GitHubResponse <IEnumerable <IssueEvent> > > Events(string repoFullName, GitHubCacheDetails cacheOptions, RequestPriority priority) { var request = new GitHubRequest($"repos/{repoFullName}/issues/events", cacheOptions, priority); request.AddParameter("sort", "updated"); request.AddParameter("direction", "asc"); return(FetchPaged(request, (IssueEvent x) => x.Id)); }
public GitHubRequestAsyncHandle GetAuthenticatedUserAsync(Action<User> callback, Action<GitHubException> onError) { var request = new GitHubRequest("/user", API.v3, Method.GET); return _gitHubClient.CallApiAsync<User>(request, r => callback(r.Data), onError); }
public GitHubRequest <List <RepositoryModel> > GetAll(string affiliation = null, int page = 1, int perPage = 100) { return(GitHubRequest.Get <List <RepositoryModel> >(Uri + "/repos", new { page, per_page = perPage, affiliation })); }
public static Task SimpleCollectionLoad <T>(this ReactiveList <T> viewModel, GitHubRequest <List <T> > request, bool?forceDataRefresh) where T : new() { return(viewModel.RequestModel(request, forceDataRefresh, response => { viewModel.CreateMore(response, m => { }, viewModel.AddRange); viewModel.Reset(response.Data); })); }
private Task <GitHubResponse <IEnumerable <Project> > > Projects(string endpoint, GitHubCacheDetails cacheOptions, RequestPriority priority) { var request = new GitHubRequest(endpoint, cacheOptions, priority) { AcceptHeaderOverride = "application/vnd.github.inertia-preview.iso8601+json", }; return(FetchPaged(request, (Project p) => p.Id)); }
public Task <GitHubResponse <IEnumerable <PullRequestComment> > > PullRequestComments(string repoFullName, DateTimeOffset?since, GitHubCacheDetails cacheOptions, RequestPriority priority) { var request = new GitHubRequest($"repos/{repoFullName}/pulls/comments", cacheOptions, priority) .AddParameter("since", since) .AddParameter("sort", "updated") .AddParameter("direction", "asc"); return(FetchPaged(request, (PullRequestComment x) => x.Id)); }
public Task <GitHubResponse <IEnumerable <PullRequest> > > PullRequests(string repoFullName, string sort, string direction, uint skipPages, uint maxPages, GitHubCacheDetails cacheOptions, RequestPriority priority) { var request = new GitHubRequest($"repos/{repoFullName}/pulls", cacheOptions, priority); request.AddParameter("state", "all"); request.AddParameter("sort", sort); request.AddParameter("direction", direction); return(FetchPaged(request, (PullRequest x) => x.Id, maxPages, skipPages)); }
public GitHubRequestAsyncHandle GetAuthenticatedUserAsync(Action <User> callback, Action <GitHubException> onError) { var request = new GitHubRequest("/user", API.v3, Method.GET); return(_gitHubClient.CallApiAsync <User>(request, r => callback(r.Data), onError)); }
public Task <GitHubResponse <IEnumerable <Reaction> > > IssueCommentReactions(string repoFullName, long commentId, GitHubCacheDetails cacheOptions, RequestPriority priority) { var request = new GitHubRequest($"repos/{repoFullName}/issues/comments/{commentId}/reactions", cacheOptions, priority) { // Reactions are in beta AcceptHeaderOverride = "application/vnd.github.squirrel-girl-preview+json", }; return(FetchPaged(request, (Reaction x) => x.Id)); }
public GitHubRequest <bool> MarkRepoAsRead(string username, string repository, DateTime?lastReadAt = null) { var data = new Dictionary <string, string>(); if (lastReadAt != null) { data.Add("last_read_at", string.Concat(lastReadAt.Value.ToString("s"), "Z")); } return(GitHubRequest.Put <bool>(Client.ApiUri + "/repos/" + username + "/" + repository + "/notifications", data)); }
public Task <GitHubResponse <IEnumerable <Reaction> > > PullRequestCommentReactions(string repoFullName, long commentId, GitHubCacheDetails cacheOptions, RequestPriority priority) { var request = new GitHubRequest($"repos/{repoFullName}/pulls/comments/{commentId}/reactions", cacheOptions, priority) { // https://developer.github.com/v3/reactions/#list-reactions-for-a-pull-request-review-comment AcceptHeaderOverride = "application/vnd.github.squirrel-girl-preview+json" }; return(FetchPaged(request, (Reaction x) => x.Id)); }
public Task <GitHubResponse <Issue> > Issue(string repoFullName, int number, GitHubCacheDetails cacheOptions, RequestPriority priority) { var request = new GitHubRequest($"repos/{repoFullName}/issues/{number}", cacheOptions, priority) { // https://developer.github.com/v3/issues/#reactions-summary AcceptHeaderOverride = "application/vnd.github.squirrel-girl-preview+json" }; return(EnqueueRequest <Issue>(request)); }
public Task <GitHubResponse <IEnumerable <ContentsFile> > > ListDirectoryContents(string repoFullName, string directoryPath, GitHubCacheDetails cacheOptions, RequestPriority priority) { if (!directoryPath.StartsWith("/", StringComparison.Ordinal)) { directoryPath = "/" + directoryPath; } var request = new GitHubRequest($"repos/{repoFullName}/contents{directoryPath}", cacheOptions, priority); return(FetchPaged(request, (ContentsFile f) => f.Path)); }
public GitHubRequest <List <IssueModel> > GetAll(int page = 1, int perPage = 100, string filter = null, string state = null, string labels = null, string sort = null, string direction = null, string since = null) { return(GitHubRequest.Get <List <IssueModel> >(Uri, new { Filter = filter, State = state, Labels = labels, Sort = sort, Direction = direction, Since = since, page = page, per_page = perPage })); }
public GitHubRequest <bool> MarkAsRead(DateTime?lastReadAt = null) { var data = new Dictionary <string, string>(); if (lastReadAt != null) { data.Add("last_read_at", string.Concat(lastReadAt.Value.ToString("s"), "Z")); } return(GitHubRequest.Put <bool>(Uri, data)); }
public Task <GitHubResponse <byte[]> > FileContents(string repoFullName, string filePath, GitHubCacheDetails cacheOptions, RequestPriority priority) { if (!filePath.StartsWith("/", StringComparison.Ordinal)) { filePath = "/" + filePath; } var request = new GitHubRequest($"repos/{repoFullName}/contents{filePath}", cacheOptions, priority); return(EnqueueRequest <byte[]>(request)); }
public Task <GitHubResponse <IEnumerable <Issue> > > IssueMentions(DateTimeOffset?since, uint maxPages, GitHubCacheDetails cacheOptions = null, RequestPriority priority = RequestPriority.Background) { var request = new GitHubRequest($"/issues", cacheOptions, priority) .AddParameter("state", "all") .AddParameter("sort", "updated") .AddParameter("direction", "asc") .AddParameter("filter", "mentioned") .AddParameter("since", since); return(FetchPaged(request, (Issue x) => x.Id, maxPages)); }
public GitHubRequest <List <CommitModel> > GetAll(string sha = null) { if (sha == null) { return(GitHubRequest.Get <List <CommitModel> >(Uri)); } else { return(GitHubRequest.Get <List <CommitModel> >(Uri, new { sha = sha })); } }
public GitHubRequestAsyncHandle FollowAsync(string user, Action callback, Action<GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); string resource = string.Format("/user/following/{0}", user); var request = new GitHubRequest(resource, API.v3, Method.PUT); return _gitHubClient.CallApiAsync<object>(request, s => callback(), onError); }
public GitHubRequestAsyncHandle GetOrganizationsAsync(string user, Action<IEnumerable<User>> callback, Action<GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); var resource = string.Format("/users/{0}/orgs", user); var request = new GitHubRequest(resource, API.v3, Method.GET); return _client.CallApiAsync<List<User>>(request, r => callback(r.Data), onError); }
public GitHubRequestAsyncHandle GetBranchesAsync(string user, string repo, Action<IEnumerable<Branch>> callback, Action<GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); Requires.ArgumentNotNull(repo, "repo"); var resource = string.Format("/repos/{0}/{1}/branches", user, repo); var request = new GitHubRequest(resource, API.v3, Method.GET); return _client.CallApiAsync<List<Branch>>(request, r => callback(r.Data), onError); }
public GitHubRequestAsyncHandle ForkAsync(string user, string repo, Action<Repository> callback, Action<GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); Requires.ArgumentNotNull(repo, "repo"); // TODO: Allow for forking into an Org... var resource = string.Format("/repos/{0}/{1}/forks", user, repo); var request = new GitHubRequest(resource, API.v3, Method.POST); return _client.CallApiAsync<Repository>(request, r => callback(r.Data), onError); }
public GitHubRequestAsyncHandle GetMembersAsync(string organization, int page, Action<IEnumerable<User>> callback, Action<GitHubException> onError) { Requires.ArgumentNotNull(organization, "organization"); var resource = string.Format("/orgs/{0}/members", organization); var request = new GitHubRequest(resource, API.v3, Method.GET, Parameter.Page(page)); return _client.CallApiAsync<List<User>>(request, r => callback(r.Data), onError); }
public GitHubRequestAsyncHandle GetFollowingAsync(string user, int page, Action<IEnumerable<User>> callback, Action<GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); string resource = string.Format("/users/{0}/following", user); var request = new GitHubRequest(resource, API.v3, Method.GET, Parameter.Page(page)); return _gitHubClient.CallApiAsync<List<User>>(request, r => callback(r.Data), onError); }
public GitHubRequestAsyncHandle GetCommitAsync(string user, string repo, string sha, Action<Commit> callback, Action<GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); Requires.ArgumentNotNull(repo, "repo"); Requires.ArgumentNotNull(sha, "sha"); var resource = string.Format("/repos/{0}/{1}/commits/{2}", user, repo, sha); var request = new GitHubRequest(resource, API.v3, Method.GET); return _client.CallApiAsync<Commit>(request, r => callback(r.Data), onError); }
public GitHubRequestAsyncHandle SearchUsersAsync(string query, Action<IEnumerable<User>> callback, Action<GitHubException> onError) { Ensure.ArgumentNotNull(query, "user"); var resource = string.Format("/user/search/{0}", query.Replace(' ', '+')); var request = new GitHubRequest(resource, API.v2, Method.GET); return _client.CallApiAsync<UserSearchResults>( request, r => callback(r.Data.Users.Select(u => new User { Login = u.Login, Name = u.Name, PublicRepos = u.PublicRepoCount, Location = u.Location, GravatarId = u.GravatarId, Type = u.Type, Followers = u.Followers })), onError); }
public GitHubRequestAsyncHandle FollowAsync(string user, Action callback, Action<GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); var resource = string.Format("/user/following/{0}", user); var request = new GitHubRequest(resource, API.v3, Method.PUT); return _gitHubClient.CallApiAsync<object>( request, r => { Debug.Assert(false, "all responses should be errors"); callback(); }, ex => { if (ex.Response.StatusCode == HttpStatusCode.NoContent) { callback(); return; } onError(ex); }); }
public GitHubRequestAsyncHandle CreateCommentAsync(string user, string repo, int issueNumber, string comment, Action<Comment> callback, Action<GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); Requires.ArgumentNotNull(repo, "repo"); Requires.ArgumentNotNull(comment, "comment"); var resource = string.Format("/repos/{0}/{1}/issues/{2}/comments", user, repo, issueNumber); var request = new GitHubRequest(resource, API.v3, Method.POST, new CommentDto { Body = comment }); return _client.CallApiAsync<Comment>(request, r => callback(r.Data), onError); }
private GitHubRequestAsyncHandle GetRepositoriesAsyncInternal( string resource, int page, int perPage, Action<IEnumerable<Repository>> callback, Action<GitHubException> onError) { var request = new GitHubRequest(resource, API.v3, Method.GET, Parameter.Page(page), Parameter.PerPage(perPage)); return _client.CallApiAsync<List<Repository>>(request, r => callback(r.Data), onError); }
public GitHubRequestAsyncHandle UnwatchAsync(string user, string repo, Action callback, Action<GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); Requires.ArgumentNotNull(repo, "repo"); var resource = string.Format("/user/watched/{0}/{1}", user, repo); var request = new GitHubRequest(resource, API.v3, Method.DELETE); return _client.CallApiAsync<object>( request, r => { Debug.Assert(false, "all responses should be errors"); callback(); }, ex => { if (ex.Response.StatusCode == HttpStatusCode.NoContent) { callback(); return; } onError(ex); }); }
public GitHubRequestAsyncHandle GetForksAsync(string user, string repo, int page, int perPage, Action<IEnumerable<Repository>> callback, Action<GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); Requires.ArgumentNotNull(repo, "repo"); var resource = string.Format("/repos/{0}/{1}/forks", user, repo); var request = new GitHubRequest(resource, API.v3, Method.GET); return GetRepositoriesAsyncInternal(resource, page, perPage, callback, onError); }
public GitHubRequestAsyncHandle GetPullRequestAsync(string user, string repo, int pullRequestId, Action<PullRequest> callback, Action<GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); Requires.ArgumentNotNull(repo, "repo"); string resource = string.Format("/repos/{0}/{1}/pulls/{2}", user, repo, pullRequestId); var request = new GitHubRequest(resource, API.v3, Method.GET); return _client.CallApiAsync<PullRequest>(request, r => callback(r.Data), onError); }
public GitHubRequestAsyncHandle IsPullRequestMergedAsync(string user, string repo, int pullRequestId, Action<bool> callback, Action<GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); Requires.ArgumentNotNull(repo, "repo"); var resource = string.Format("/repos/{0}/{1}/pulls/{2}/merge", user, repo, pullRequestId); var request = new GitHubRequest(resource, API.v3, Method.GET); return _client.CallApiAsync<object>( request, r => { Debug.Assert(false, "all responses should be errors"); callback(true); }, e => { if (e.Response.StatusCode == HttpStatusCode.NoContent) { callback(true); return; } if (e.Response.StatusCode == HttpStatusCode.NotFound) { callback(false); return; } onError(e); }); }
public GitHubRequestAsyncHandle GetPullRequestsAsync(string user, string repo, State state, int page, Action<IEnumerable<PullRequest>> callback, Action<GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); Requires.ArgumentNotNull(repo, "repo"); var resource = string.Format("/repos/{0}/{1}/pulls", user, repo); var request = new GitHubRequest(resource, API.v3, Method.GET, Parameter.State(state)); return _client.CallApiAsync<List<PullRequest>>(request, r => callback(r.Data), onError); }
public void CallApiAsync_ShouldPassRequestParameters_ToRestRequest() { var expectedKey = "foo"; var expectedValue = "bar"; var mockFactory = new Mock<IRestClientFactory>(MockBehavior.Strict); var mockRestClient = new Mock<IRestClient>(MockBehavior.Strict); mockFactory.Setup<IRestClient>(f => f.CreateRestClient(It.IsAny<string>())).Returns(mockRestClient.Object); mockRestClient .Setup(c => c.ExecuteAsync<object>( It.Is<IRestRequest>(r => r.Parameters.Where(p => (p.Name == expectedKey) && ((string)p.Value == expectedValue)) .Count() == 1), It.IsAny<Action<RestResponse<object>, RestRequestAsyncHandle>>())) .Returns(_testHandle) .Callback<IRestRequest, Action<RestResponse<object>, RestRequestAsyncHandle>>((r, c) => c(new RestResponse<object>(), _testHandle)); mockRestClient.SetupSet(c => c.Authenticator = It.IsAny<IAuthenticator>()); var client = CreateClient(mockFactory.Object); var request = new GitHubRequest("resource", API.v2, NGitHub.Web.Method.POST, new NGitHub.Web.Parameter(expectedKey, expectedValue)); client.CallApiAsync<object>(request, o => { }, e => { }); mockRestClient.VerifyAll(); }
public GitHubRequestAsyncHandle CreateCommentAsync(string user, string repo, int pullRequestId, int commentIdToReplyTo, string body, Action<CommitComment> callback, Action<GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); Requires.ArgumentNotNull(repo, "repo"); Requires.ArgumentNotNull(body, "body"); string resource = string.Format("/repos/{0}/{1}/pulls/{2}/comments", user, repo, pullRequestId); var request = new GitHubRequest(resource, API.v3, Method.POST, new ReplyCommentDto { Body = body, InReplyTo = commentIdToReplyTo }); return _client.CallApiAsync<CommitComment>(request, r => callback(r.Data), onError); }
public GitHubRequestAsyncHandle GetIssuesAsync(string user, string repo, State state, int page, Action<IEnumerable<Issue>> callback, Action<GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); Requires.ArgumentNotNull(repo, "repo"); var resource = string.Format("/repos/{0}/{1}/issues", user, repo); var request = new GitHubRequest(resource, API.v3, Method.GET, Parameter.State(state), Parameter.Page(page)); // We can't just deserialize every response as a List<Issue> because // repos that do not support issues will return: // { "message": "Issues are disabled for this repo" } // return _client.CallApiAsync( request, r => { List<Issue> issues = null; try { issues = JsonConvert.DeserializeObject<List<Issue>>(r.Content); } catch { onError(new GitHubException(r, ErrorType.Unknown)); return; } callback(issues); }, e => { if (e.Response.StatusCode == HttpStatusCode.Gone) { // This is the code that is returned when issues are disabled. callback(new Issue[] { }); return; } onError(e); }); }
public GitHubRequestAsyncHandle UnfollowAsync(string user, Action callback, Action<GitHubException> onError) { string resource = string.Format("/user/unfollowing/{0}", user); var request = new GitHubRequest(resource, API.v3, Method.DELETE); return _gitHubClient.CallApiAsync<object>(request, s => callback(), onError); }
public GitHubRequestAsyncHandle GetUserAsync(string user, Action<User> callback, Action<GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); string resource = string.Format("/users/{0}", user); var request = new GitHubRequest(resource, API.v3, Method.GET); return _gitHubClient.CallApiAsync<User>(request, r => callback(r.Data), onError); }
public GitHubRequestAsyncHandle GetCommentsAsync(string user, string repo, int issueNumber, int page, Action<IEnumerable<Comment>> callback, Action<GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); Requires.ArgumentNotNull(repo, "repo"); var resource = string.Format("/repos/{0}/{1}/issues/{2}/comments", user, repo, issueNumber); var request = new GitHubRequest(resource, API.v3, Method.GET, Parameter.Page(page)); return _client.CallApiAsync<List<Comment>>(request, r => callback(r.Data), onError); }
public GitHubRequestAsyncHandle GetCommitsAsync(string user, string repo, string branch, string lastSha, Action<IEnumerable<Commit>> callback, Action<GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); Requires.ArgumentNotNull(repo, "repo"); Requires.ArgumentNotNull(branch, "branch"); var resource = string.Format("/repos/{0}/{1}/commits", user, repo); var request = new GitHubRequest(resource, API.v3, Method.GET, new Parameter("last_sha", lastSha ?? string.Empty), new Parameter("top", branch)); // We can't just deserialize every response as a List<Commit> because // repos that has no commits will return: // { "message": "The repository is empty." } // return _client.CallApiAsync( request, r => { List<Commit> issues = null; try { issues = JsonConvert.DeserializeObject<List<Commit>>(r.Content); } catch { onError(new GitHubException(r, ErrorType.Unknown)); return; } callback(issues); }, e => { if (e.Response.StatusCode == HttpStatusCode.Conflict) { // This is the code that is returned when a repo is empty. callback(new Commit[] { }); return; } onError(e); }); }
public GitHubRequestAsyncHandle GetFilesAsync(string user, string repo, int pullRequestId, int page, Action<IEnumerable<FileChanges>> callback, Action<GitHubException> onError) { Requires.ArgumentNotNull(user, "user"); Requires.ArgumentNotNull(repo, "repo"); var resource = string.Format("/repos/{0}/{1}/pulls/{2}/files", user, repo, pullRequestId); var request = new GitHubRequest(resource, API.v3, Method.GET, Parameter.Page(page)); return _client.CallApiAsync<List<FileChanges>>(request, r => callback(r.Data), onError); }
public void CallApiAsync_ShouldExecuteRestRequestWithGivenRequestMethod() { var expectedMethod = NGitHub.Web.Method.OPTIONS; var request = new GitHubRequest("foo/bar", API.v3, expectedMethod); var mockRestClient = new Mock<IRestClient>(MockBehavior.Strict); var mockFactory = new Mock<IRestClientFactory>(MockBehavior.Strict); mockFactory.Setup<IRestClient>(f => f.CreateRestClient(Constants.ApiV3Url)) .Returns(mockRestClient.Object); mockRestClient.Setup(c => c.ExecuteAsync<object>( It.Is<IRestRequest>(r => r.Method == expectedMethod.ToRestSharpMethod()), It.IsAny<Action<RestResponse<object>, RestRequestAsyncHandle>>())) .Returns(_testHandle); mockRestClient.SetupSet(c => c.Authenticator = It.IsAny<IAuthenticator>()); var githubClient = CreateClient(mockFactory.Object); githubClient.CallApiAsync<object>(request, o => { }, e => { }); mockRestClient.VerifyAll(); }
public void CallApiAsync_ShouldExecuteRestRequestWithGivenRequestResource() { string expectedResource = "foo/bar"; var request = new GitHubRequest(expectedResource, API.v3, Method.OPTIONS); var mockRestClient = new Mock<IRestClient>(MockBehavior.Strict); var mockFactory = new Mock<IRestClientFactory>(MockBehavior.Strict); mockFactory.Setup(f => f.CreateRestClient(Constants.ApiV3Url)) .Returns(mockRestClient.Object); mockRestClient.Setup(c => c.ExecuteAsync( It.Is<IRestRequest>(r => r.Resource == expectedResource), It.IsAny<Action<IRestResponse<object>, RestRequestAsyncHandle>>())) .Returns(_testHandle); mockRestClient.SetupSet(c => c.Authenticator = It.IsAny<IAuthenticator>()); GitHubClient githubClient = CreateClient(mockFactory.Object); githubClient.CallApiAsync<object>(request, o => { }, e => { }); mockRestClient.VerifyAll(); }