Java tutorial
package com.thinkbiganalytics.jira; /*- * #%L * thinkbig-jira-rest-client * %% * Copyright (C) 2017 ThinkBig Analytics * %% * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * #L% */ import com.google.common.base.Predicate; import com.google.common.cache.CacheBuilder; import com.google.common.cache.CacheLoader; import com.google.common.cache.LoadingCache; import com.google.common.collect.Collections2; import com.thinkbiganalytics.jira.domain.CreateIssue; import com.thinkbiganalytics.jira.domain.CreateMeta; import com.thinkbiganalytics.jira.domain.GetIssue; import com.thinkbiganalytics.jira.domain.Issue; import com.thinkbiganalytics.jira.domain.IssueBuilder; import com.thinkbiganalytics.jira.domain.IssueType; import com.thinkbiganalytics.jira.domain.Project; import com.thinkbiganalytics.jira.domain.ServerInfo; import com.thinkbiganalytics.jira.domain.User; import com.thinkbiganalytics.rest.JerseyRestClient; import com.thinkbiganalytics.rest.JodaTimeMapperProvider; import org.apache.commons.lang3.StringUtils; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.concurrent.TimeUnit; import javax.ws.rs.client.WebTarget; import javax.ws.rs.core.GenericType; /** */ public class JiraJerseyClient extends JerseyRestClient implements JiraClient { LoadingCache<String, List<String>> issueTypeNameCache; private String apiPath = "/rest/api/latest/"; public JiraJerseyClient(JiraRestClientConfig config) { super(config); this.apiPath = config.getApiPath(); // cache the Issue Types related to a project since they will not change much. // But if they do, expire the cache after a certain amount of time this.issueTypeNameCache = CacheBuilder.newBuilder().expireAfterAccess(20, TimeUnit.MINUTES) .build(new CacheLoader<String, List<String>>() { public List<String> load(String key) { try { return loadIssueTypeNamesForProject(key); } catch (JiraException e) { return null; } } }); //regiser the JoadTime mapper if (client != null) { client.register(JodaTimeMapperProvider.class); } } protected WebTarget getBaseTarget() { WebTarget target = super.getBaseTarget(); return target.path(apiPath); } public Issue getIssue(String key) throws JiraException { try { GetIssue getIssue = get("issue/" + key, null, GetIssue.class); Issue issue = new Issue(getIssue); return issue; } catch (Exception e) { throw new JiraException("Error getting Issue: " + key, e); } } /*** * Return the JIRA User that is allowed to be assigned issues for a given Project and UserName * * @param projectKey * @param username * @return * @ */ public User getAssignableUser(String projectKey, String username) { Map<String, Object> params = new HashMap<String, Object>(); params.put("project", projectKey); params.put("username", username); List<User> users = get("/user/assignable/search", params, new GenericType<List<User>>() { }); if (users != null && !users.isEmpty()) { return users.get(0); } return null; } /** * Check to see if a user is allowed to be assigned issues for a given project */ public boolean isAssignable(String projectKey, String username) { User user = null; try { user = getAssignableUser(projectKey, username); } catch (Exception e) { } return user != null; } /** * Return the CreateMeta Schema that needs to used to create new Jira Issues */ public CreateMeta getCreateMetadata(String projectKey) throws JiraException { try { Map<String, Object> params = new HashMap<String, Object>(); params.put("projectKeys", projectKey); params.put("expand", "projects.issuetypes.fields"); CreateMeta createData = get("/issue/createmeta", params, CreateMeta.class); return createData; } catch (Exception e) { throw new JiraException("Error getting Create Metadata for Project " + projectKey, e); } } /** * Return the list of valid IssueTypes for a given Jira Project */ public List<IssueType> getIssueTypesForProject(String projectKey) throws JiraException { CreateMeta createData = getCreateMetadata(projectKey); Project project = createData.getProject(); if (project != null) { return project.getIssueTypes(); } else { return null; } } /** * Return the List of Issue Type Names for a given Project */ private List<String> loadIssueTypeNamesForProject(String projectKey) throws JiraException { List<IssueType> issueTypes = null; issueTypes = getIssueTypesForProject(projectKey); List<String> names = new ArrayList<>(); if (issueTypes != null) { for (IssueType issueType : issueTypes) { names.add(issueType.getName()); } } return names; } /** * return the List of String names of the IssueTypes for a given Project */ public List<String> getIssueTypeNamesForProject(String projectKey) { return issueTypeNameCache.getUnchecked(projectKey); } /** * Check to see if a given issue type is valid for a Project */ public boolean isValidIssueType(String projectKey, final String issueTypeName) { List<String> issueTypes = getIssueTypeNamesForProject(projectKey); return isValidIssueType(issueTypes, issueTypeName); } /** * check gto see if the issueType List has the passed in issueTypeName */ public boolean isValidIssueType(List<String> issueTypes, final String issueTypeName) { if (issueTypes != null) { Predicate<String> matchesProject = new Predicate<String>() { @Override public boolean apply(String issueType) { return issueType.equals(issueTypeName); } }; Collection<String> matchingTypes = Collections2.filter(issueTypes, matchesProject); return matchingTypes != null && !matchingTypes.isEmpty(); } return false; } /** * Create a new Jira Issue */ public Issue createIssue(Issue issue) throws JiraException { String projectKey = issue.getProject() != null ? issue.getProject().getKey() : null; String issueType = issue.getIssueType() != null ? issue.getIssueType().getName() : null; String summary = issue.getSummary(); String description = issue.getDescription(); String assigneeName = issue.getAssignee() != null ? issue.getAssignee().getName() : null; //Validate the parameters List<String> issueTypes = getIssueTypeNamesForProject(projectKey); //Validate the Project Name if (issueTypes == null) { throw new JiraException("Unable to Create Issue: Project " + projectKey + " does not exist. Issue Details are: " + issue); } boolean validIssueType = isValidIssueType(issueTypes, issueType); if (!validIssueType) { //set it to the first one?? throw new JiraException( "Unable to Create Issue: Issue type " + issueType + " is not allowed for Project " + projectKey + ". Valid Issue Types are: " + issueTypes + ". Issue Details are:" + issue); } //Validate the Assignee if (StringUtils.isBlank(assigneeName)) { //default it to the current Rest client user name assigneeName = super.getUsername(); } boolean assignable = isAssignable(projectKey, assigneeName); if (!assignable) { throw new JiraException("Unable to Create Issue: User " + assigneeName + " is not allowed to be assigned issues for Project " + projectKey + ". Issue Details are:" + issue); } //Validate required fields if (StringUtils.isBlank(summary)) { throw new JiraException("Unable to Create Issue: Summary is required"); } if (StringUtils.isBlank(description)) { throw new JiraException("Unable to Create Issue: Description is required"); } try { //Transform it to a CreateIssue CreateIssue createIssue = new CreateIssue(issue); //Post it GetIssue response = post("/issue/", createIssue, GetIssue.class); //transform the result back to a populated issue issue = getIssue(response.getKey()); log.info("Created JIRA Issue {}, - {}", issue.getKey(), issue.getSummary()); } catch (Exception e) { String message = "Error Creating Issue " + issue; throw new JiraException(message, e); } return issue; } /** * Create a new Jira Issue */ public Issue createIssue(String projectKey, String summary, String description, String issueType, String assigneeName) throws JiraException { //validate issuetype before creating Issue issue = new IssueBuilder(projectKey, issueType).setSummary(summary).setDescription(description) .setAssignee(assigneeName).build(); return createIssue(issue); } public ServerInfo getServerInfo() throws JiraException { ServerInfo serverInfo = null; try { serverInfo = get("/serverInfo", null, ServerInfo.class); } catch (Exception e) { String message = "Error getting serverinfo " + e.getMessage(); throw new JiraException(message, e); } return serverInfo; } }