We had the same problem.
The restAPI (/rest/api/2/issue/{issueIdOrKey}) that is behind de IssueRestClient contains max. 20 worklogs per issue.
Te same for the SearchRestClient: the restAPI (/rest/api/2/search) also returns max. 20 worklogs per issue.
The only restAPI, that returns all the worklogs, is this one: /rest/api/2/issue/{issueIdOrKey}/worklog. Unfortunately, there is no corresponding Java RestClient in JRJC.
After looking into the JRJC code, I created some new classes, based on the existing code.
First I created a new IssueWorklogsRestClient interface with its class. There is one method getIssueWorklogs(BasicIssue issue) that returns a List of Worklogs per issue:
public interface IssueWorklogsRestClient
{
Promise<List<Worklog>> getIssueWorklogs(BasicIssue issue);
}
public class AsynchronousIssueWorklogsRestClient extends AbstractAsynchronousRestClient implements IssueWorklogsRestClient
{
private final WorklogsJsonParser worklogsParser = new WorklogsJsonParser();
private final URI baseUri;
public AsynchronousIssueWorklogsRestClient(final URI baseUri, final HttpClient client)
{
super(client);
this.baseUri = baseUri;
}
@Override
public Promise<List<Worklog>> getIssueWorklogs(final BasicIssue issue)
{
final UriBuilder uriBuilder = UriBuilder.fromUri(baseUri);
uriBuilder.path("issue").path(issue.getKey()).path("worklog");
worklogsParser.setIssue(issue);
return getAndParse(uriBuilder.build(), worklogsParser);
}
}
I also created a new WorklogsJsonParser, based on the existing IssueJsonParser
public class WorklogsJsonParser implements JsonObjectParser<List<Worklog>>
{
private BasicIssue basicIssue;
public void setIssue(BasicIssue issue)
{
this.basicIssue = issue;
}
@Nullable
private <T> Collection<T> parseOptionalArray(final JSONObject json, final JsonWeakParser<T> jsonParser, final String... path)
throws JSONException
{
final JSONArray jsonArray = JsonParseUtil.getNestedOptionalArray(json, path);
if (jsonArray == null)
{
return null;
}
final Collection<T> res = new ArrayList<T>(jsonArray.length());
for (int i = 0; i < jsonArray.length(); i++)
{
res.add(jsonParser.parse(jsonArray.get(i)));
}
return res;
}
@Override
public List<Worklog> parse(JSONObject s) throws JSONException
{
final Collection<Worklog> worklogs;
final URI selfUri = basicIssue.getSelf();
worklogs = parseOptionalArray(s, new JsonWeakParserForJsonObject<Worklog>(new WorklogJsonParserV5(selfUri)), WORKLOGS_FIELD.id);
if(worklogs==null)
{
return Collections.<Worklog>emptyList();
}
return new ArrayList(worklogs);
}
private static class JsonWeakParserForJsonObject<T> implements JsonWeakParser<T>
{
private final JsonObjectParser<T> jsonParser;
public JsonWeakParserForJsonObject(JsonObjectParser<T> jsonParser)
{
this.jsonParser = jsonParser;
}
private <T> T convert(Object o, Class<T> clazz) throws JSONException
{
try
{
return clazz.cast(o);
} catch (ClassCastException e)
{
throw new JSONException("Expected [" + clazz.getSimpleName() + "], but found [" + o.getClass().getSimpleName() + "]");
}
}
@Override
public T parse(Object o) throws JSONException
{
return jsonParser.parse(convert(o, JSONObject.class));
}
}
private interface JsonWeakParser<T>
{
T parse(Object o) throws JSONException;
}
}
finally I created a subclass+interface of the existing JiraRestClient that creates the new IssueWorklogsClient
public interface JiraRestClientPlus extends JiraRestClient
{
IssueWorklogsRestClient getIssueWorklogRestClient();
}
public class AsynchronousJiraRestClientPlus extends AsynchronousJiraRestClient implements JiraRestClientPlus
{
private final IssueWorklogsRestClient issueWorklogsRestClient;
public AsynchronousJiraRestClientPlus(final URI serverUri, final DisposableHttpClient httpClient)
{
super(serverUri,httpClient);
final URI baseUri = UriBuilder.fromUri(serverUri).path("/rest/api/latest").build(); // '/rest/api/latest' or '/rest/api/2'
issueWorklogsRestClient = new AsynchronousIssueWorklogsRestClient(baseUri, httpClient);
}
@Override
public IssueWorklogsRestClient getIssueWorklogRestClient()
{
return issueWorklogsRestClient;
}
}
+ a subclass of the existing AsynchronousJiraRestClientFactory to create the new JiraRestClientPlus
public class AsynchronousJiraRestClientFactoryPlus extends AsynchronousJiraRestClientFactory
{
@Override
public JiraRestClientPlus create(final URI serverUri, final AuthenticationHandler authenticationHandler)
{
final DisposableHttpClient httpClient = new AsynchronousHttpClientFactory()
.createClient(serverUri, authenticationHandler);
return new AsynchronousJiraRestClientPlus(serverUri, httpClient);
}
@Override
public JiraRestClientPlus createWithBasicHttpAuthentication(final URI serverUri, final String username, final String password)
{
return create(serverUri, new BasicHttpAuthenticationHandler(username, password));
}
@Override
public JiraRestClientPlus create(final URI serverUri, final HttpClient httpClient)
{
final DisposableHttpClient disposableHttpClient = new AsynchronousHttpClientFactory().createClient(httpClient);
return new AsynchronousJiraRestClientPlus(serverUri, disposableHttpClient);
}
}
For the rest, I use my existing code, but added a extra check that when worklogs.size >=20, it will get the worklogs by using the new IssueWorklogsRestClient.
You must be a registered user to add a comment. If you've already registered, sign in. Otherwise, register and sign in.