REST API is returning only 20 worklogs per issue

Dejan Nedic

We are using the REST API to retrieve some information from JIRA for reporting purposes. Basically, we are getting the number of reported hours per project/project category in a specific time period.

Recently we have noticed that the numbers of reported hours are not correct i.e. that those are smaller than the real numbers in JIRA. The analysis has shown that the getWorklogs method called on an issue is returning only up to 20 worklogs. This looks like some kind of pagination, but we were not able to find this limitation anywhere in the documentation.

Can somebody please shed some light on this?

fmeheus

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.