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);
}
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);
}
internal static Task <Project> SearchProjectAsync(GitLabTaskRunner client, string projectname)
{
return(OperatorCallWrapper.Call(
async() =>
(Project)await client.RunAsync(
async(gl) =>
await gl.Projects.Get(projectname).LoadTaskAsync())));
}
internal static Task <User> SearchCurrentUserAsync(GitLabTaskRunner client)
{
return(OperatorCallWrapper.Call(
async() =>
(User)await client.RunAsync(
async(gl) =>
await gl.CurrentUser.LoadTaskAsync())));
}
internal Task <User> GetCurrentUserAsync()
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
() =>
CommonOperator.SearchCurrentUserAsync(client))));
}
internal Task <IEnumerable <MergeRequest> > SearchMergeRequestsAsync(
SearchCriteria searchCriteria, int?maxResults, bool onlyOpen)
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
() =>
CommonOperator.SearchMergeRequestsAsync(client, searchCriteria, maxResults, onlyOpen))));
}
internal Task <IEnumerable <Branch> > GetBranches(string search)
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
async() =>
(IEnumerable <Branch>)(await client.RunAsync(async(gl) =>
await gl.Projects.Get(_projectname).Repository.Branches.LoadTaskAsync(search))))));
}
internal Task <MergeRequest> GetMergeRequestAsync(string projectName, int iid, bool?includeRebaseInProgress = null)
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
async() =>
(MergeRequest)await client.RunAsync(
async(gl) =>
await gl.Projects.Get(projectName).MergeRequests.Get(iid).LoadTaskAsync(includeRebaseInProgress)))));
}
internal Task <User> SearchCurrentUserAsync()
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
async() =>
(User)await client.RunAsync(
async(gl) =>
await gl.CurrentUser.LoadTaskAsync()))));
}
internal Task <IEnumerable <MergeRequest> > SearchMergeRequestsAsync(SearchQuery searchQuery)
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
async() =>
(IEnumerable <MergeRequest>)(await client.RunAsync(
async(gl) =>
await(new MergeRequestSearchProcessor(searchQuery).Process(gl)))))));
}
internal Task <IEnumerable <User> > GetUsers()
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
async() =>
(IEnumerable <User>) await client.RunAsync(
async(gl) =>
await gl.Users.LoadAllTaskAsync()))));
}
internal Task <MergeRequestApprovalConfiguration> GetApprovalsAsync(string projectName, int iid)
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
async() =>
(MergeRequestApprovalConfiguration)await client.RunAsync(
async(gl) =>
await gl.Projects.Get(projectName).MergeRequests.Get(iid).GetApprovalConfigurationTaskAsync()))));
}
internal Task DeleteBranchAsync(string name)
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
async() =>
await client.RunAsync(
async(gl) =>
await gl.Projects.Get(_projectname).Repository.Branches.Get(name).DeleteTaskAsync()))));
}
internal Task <MergeRequest> CreateMergeRequest(string projectName, CreateNewMergeRequestParameters parameters)
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
async() =>
(MergeRequest)(await client.RunAsync(
async(gl) =>
await gl.Projects.Get(projectName).MergeRequests.CreateNewTaskAsync(parameters))))));
}
internal Task <File> LoadFileAsync(string filename, string sha)
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
async() =>
(File)(await client.RunAsync(
async(gl) =>
await gl.Projects.Get(_projectname).Repository.Files.Get(filename).LoadTaskAsync(sha))))));
}
internal Task <Branch> CreateNewBranchAsync(string name, string sha)
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
async() =>
(Branch)(await client.RunAsync(async(gl) =>
await gl.Projects.Get(_projectname).Repository.Branches.CreateNewTaskAsync(
new CreateNewBranchParameters(name, sha)))))));
}
internal Task <IEnumerable <CommitRef> > LoadCommitRefsAsync(string sha)
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
async() =>
(IEnumerable <CommitRef>)(await client.RunAsync(
async(gitlab) =>
await gitlab.Projects.Get(_projectname).Repository.Commits.Get(sha).LoadRefsTaskAsync())))));
}
internal Task <IEnumerable <User> > GetUsersAsync(string projectname)
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
async() =>
(IEnumerable <User>) await client.RunAsync(
async(gl) =>
await gl.Projects.Get(projectname).Users.LoadAllTaskAsync()))));
}
internal Task <Comparison> CompareAsync(string from, string to)
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
async() =>
(Comparison)await client.RunAsync(
async(gl) =>
await gl.Projects.Get(_projectname).Repository.CompareAsync(new CompareParameters(from, to))))));
}
internal Task <IEnumerable <Version> > GetVersionsAsync(string projectName, int iid)
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
async() =>
(IEnumerable <Version>) await client.RunAsync(
async(gl) =>
await gl.Projects.Get(projectName).MergeRequests.Get(iid).Versions.LoadAllTaskAsync()))));
}
internal Task <Project> SearchProjectAsync(string projectname)
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
async() =>
(Project)await client.RunAsync(
async(gl) =>
await gl.Projects.Get(projectname).LoadTaskAsync()))));
}
internal Task <Commit> GetCommitAsync(string projectName, string id)
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
async() =>
(Commit)await client.RunAsync(
async(gl) =>
await gl.Projects.Get(projectName).Repository.Commits.Get(id).LoadTaskAsync()))));
}
internal Task <IEnumerable <Discussion> > GetDiscussionsAsync(MergeRequestKey mrk)
{
return(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())))));
}
internal Task <IEnumerable <Project> > GetProjects()
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
async() =>
(IEnumerable <Project>) await client.RunAsync(
async(gl) =>
await gl.Projects.LoadAllTaskAsync(
new GitLabSharp.Accessors.ProjectsFilter(false, true, true))))));
}
internal Task DeleteNoteAsync(MergeRequestKey mrk, int noteId)
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
async() =>
await client.RunAsync(
async(gl) =>
await gl.Projects.Get(mrk.ProjectKey.ProjectName).MergeRequests.Get(mrk.IId).
Notes.Get(noteId).DeleteTaskAsync()))));
}
internal Task <Discussion> CreateDiscussionAsync(MergeRequestKey mrk, NewDiscussionParameters parameters)
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
async() =>
(Discussion)await client.RunAsync(
async(gl) =>
await gl.Projects.Get(mrk.ProjectKey.ProjectName).MergeRequests.Get(mrk.IId).
Discussions.CreateNewTaskAsync(parameters)))));
}
internal Task <Discussion> GetDiscussionAsync(MergeRequestKey mrk, string discussionId)
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
async() =>
(Discussion)(await client.RunAsync(
async(gitlab) =>
await gitlab.Projects.Get(mrk.ProjectKey.ProjectName).MergeRequests.Get(mrk.IId).
Discussions.Get(discussionId).LoadTaskAsync())))));
}
internal Task AddSpanAsync(bool add, TimeSpan span, MergeRequestKey mrk)
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
async() =>
await client.RunAsync(
async(gl) =>
await gl.Projects.Get(mrk.ProjectKey.ProjectName).MergeRequests.Get(mrk.IId).AddSpentTimeAsync(
new AddSpentTimeParameters(add, span))))));
}
internal Task CreateNoteAsync(MergeRequestKey mrk, CreateNewNoteParameters parameters)
{
return(callWithSharedClient(
async(client) =>
await OperatorCallWrapper.Call(
async() =>
await client.RunAsync(
async(gl) =>
await gl.Projects.Get(mrk.ProjectKey.ProjectName).MergeRequests.Get(mrk.IId).
Notes.CreateNewTaskAsync(parameters)))));
}