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);
}
