async internal Task <IEnumerable <Discussion> > GetDiscussionsAsync(MergeRequestKey mrk, CachedDiscussionsTimestamp?cachedRevisionTimestamp) { IEnumerable <Discussion> cachedDiscussions = cachedRevisionTimestamp.HasValue ? GlobalCache.GetDiscussions(mrk, cachedRevisionTimestamp.Value) : null; if (cachedDiscussions != null) { return(cachedDiscussions); } Task <IEnumerable <Discussion> > task = callWithSharedClient( async(client) => await OperatorCallWrapper.Call( async() => (IEnumerable <Discussion>)(await client.RunAsync( async(gl) => await gl.Projects.Get(mrk.ProjectKey.ProjectName).MergeRequests.Get(mrk.IId). Discussions.LoadAllTaskAsync())))); IEnumerable <Discussion> discussions = await task; if (cachedRevisionTimestamp.HasValue) { GlobalCache.SetDiscussions(mrk, discussions, cachedRevisionTimestamp.Value); } return(discussions); }
async internal Task <IEnumerable <Commit> > GetCommitsAsync(string projectName, int iid, string cachedRevisionTimestamp) { // If MaxCommitsToLoad exceeds 100, need to call LoadAllTaskAsync() w/o PageFilter Debug.Assert(Constants.MaxCommitsToLoad <= 100); MergeRequestKey mrk = new MergeRequestKey(new ProjectKey(Hostname, projectName), iid); IEnumerable <Commit> cachedCommits = cachedRevisionTimestamp != null ? GlobalCache.GetCommits(mrk, cachedRevisionTimestamp) : null; if (cachedCommits != null) { return(cachedCommits); } Task <IEnumerable <Commit> > task = callWithSharedClient( async(client) => await OperatorCallWrapper.Call( async() => (IEnumerable <Commit>) await client.RunAsync( async(gl) => await gl.Projects.Get(projectName).MergeRequests.Get(iid).Commits.LoadTaskAsync( new GitLabSharp.Accessors.PageFilter(Constants.MaxCommitsToLoad, 1))))); IEnumerable <Commit> commits = await task; if (cachedRevisionTimestamp != null) { GlobalCache.SetCommits(mrk, commits, cachedRevisionTimestamp); } return(commits); }
async internal Task <IEnumerable <Version> > GetVersionsAsync(string projectName, int iid, string cachedRevisionTimestamp) { MergeRequestKey mrk = new MergeRequestKey(new ProjectKey(Hostname, projectName), iid); IEnumerable <Version> cachedVersions = cachedRevisionTimestamp != null ? GlobalCache.GetVersions(mrk, cachedRevisionTimestamp) : null; if (cachedVersions != null) { return(cachedVersions); } Task <IEnumerable <Version> > task = callWithSharedClient( async(client) => await OperatorCallWrapper.Call( async() => (IEnumerable <Version>) await client.RunAsync( async(gl) => await gl.Projects.Get(projectName).MergeRequests.Get(iid).Versions.LoadAllTaskAsync()))); IEnumerable <Version> versions = await task; if (cachedRevisionTimestamp != null) { GlobalCache.SetVersions(mrk, versions, cachedRevisionTimestamp); } return(versions); }
internal Task <Commit> GetCommitAsync(string projectName, string id) { // TODO Add ability to store free commits in GlobalCache Commit cachedCommit = GlobalCache.GetCommit(new ProjectKey(Hostname, projectName), id); if (cachedCommit != null) { return(Task.FromResult(cachedCommit)); } return(callWithSharedClient( async(client) => await OperatorCallWrapper.Call( async() => (Commit)await client.RunAsync( async(gl) => await gl.Projects.Get(projectName).Repository.Commits.Get(id).LoadTaskAsync())))); }
async internal Task <User> SearchUserByUsernameAsync(string username) { User user = GlobalCache.GetUser(Hostname, username); if (user == null) { var users = await callWithSharedClient( async (client) => await OperatorCallWrapper.Call( async() => (IEnumerable <User>) await client.RunAsync( async(gl) => await gl.Users.SearchByUsernameTaskAsync(username)))); if (!users.Any()) { return(null); } user = users.First(); GlobalCache.AddUser(Hostname, user); } return(user); }