import com.taskadapter.redmineapi.RedmineException; //导入依赖的package包/类
private void createNewIssue(ILoggingEvent event, String hash) throws RedmineException {
    Issue issue = IssueFactory.create(projectId, title + " - " + dateFormat.format(new Date(event.getTimeStamp())));

    String description = transformDescription(event);

    if (gitSupport) {
        String gitNavigation = showGitNavigation(event);

        issue.setDescription(gitNavigation + description);
    } else {
        issue.setDescription(description);
    }

    issue = issueManager.createIssue(issue);

    maps.put(hash, issue.getId());
}
 

import com.taskadapter.redmineapi.RedmineException; //导入依赖的package包/类
/**
 * Delivers a list of a child entries.
 * 
 * @param classs
 *            target class.
 */
public <T> List<T> getChildEntries(Class<?> parentClass, String parentKey, Class<T> classs) throws RedmineException {
	final EntityConfig<T> config = getConfig(classs);
	final URI uri = getURIConfigurator().getChildObjectsURI(parentClass,
			parentKey, classs, new BasicNameValuePair("limit", String.valueOf(objectsPerPage)));

	HttpGet http = new HttpGet(uri);
	String response = send(http);
	final JSONObject responseObject;
	try {
		responseObject = RedmineJSONParser.getResponse(response);
		return JsonInput.getListNotNull(responseObject, config.multiObjectName, config.parser);
	} catch (JSONException e) {
		throw new RedmineFormatException("Bad categories response " + response, e);
	}
}
 

import com.taskadapter.redmineapi.RedmineException; //导入依赖的package包/类
public void addUserToGroup(int userId, int groupId) throws RedmineException {
	logger.debug("adding user " + userId + " to group " + groupId + "...");
	URI uri = getURIConfigurator().getChildObjectsURI(Group.class, Integer.toString(groupId), User.class);
	HttpPost httpPost = new HttpPost(uri);
	final StringWriter writer = new StringWriter();
	final JSONWriter jsonWriter = new JSONWriter(writer);
	try {
		jsonWriter.object().key("user_id").value(userId).endObject();
	} catch (JSONException e) {
		throw new RedmineInternalError("Unexpected exception", e);
	}
	String body = writer.toString();
	setEntity(httpPost, body);
	String response = send(httpPost);
	logger.debug(response);
}
 

import com.taskadapter.redmineapi.RedmineException; //导入依赖的package包/类
public void addWatcherToIssue(int watcherId, int issueId) throws RedmineException {
	logger.debug("adding watcher " + watcherId + " to issue " + issueId + "...");
	URI uri = getURIConfigurator().getChildObjectsURI(Issue.class, Integer.toString(issueId), Watcher.class);
	HttpPost httpPost = new HttpPost(uri);
	final StringWriter writer = new StringWriter();
	final JSONWriter jsonWriter = new JSONWriter(writer);
	try {
		jsonWriter.object().key("user_id").value(watcherId).endObject();
	} catch (JSONException e) {
		throw new RedmineInternalError("Unexpected exception", e);
	}
	String body = writer.toString();
	setEntity(httpPost, body);
	String response = send(httpPost);
	logger.debug(response);
}
 

import com.taskadapter.redmineapi.RedmineException; //导入依赖的package包/类
@Override
public Void processContent(BasicHttpResponse content)
		throws RedmineException {
	final byte[] buffer = new byte[4096 * 4];
	int readed;
	try {
		final InputStream input = content.getStream();
		try {
			while ((readed = input.read(buffer)) > 0)
				outStream.write(buffer, 0, readed);
		} finally {
			input.close();
		}
	} catch (IOException e) {
		throw new RedmineCommunicationException(e);
	}
	return null;
}
 

import com.taskadapter.redmineapi.RedmineException; //导入依赖的package包/类
@Override
public void validateConnection(TaskRepository repository) throws RedmineException
{	
	RedmineClient client = createClientFromTaskRepository(repository, new CachedRepositoryConfiguration());
	
	try
	{
		client.validateConnection();
	}
	catch (RedmineException e)
	{
		throw e;
	}
	finally
	{
		client.shutdown();
	}
}
 

import com.taskadapter.redmineapi.RedmineException; //导入依赖的package包/类
private File getConfigurationFileForUrl(String repositoryUrl) throws RedmineException
{
	String encodedFilename = null; 
	
	try
	{
		encodedFilename = URLEncoder.encode(repositoryUrl,"UTF-8");
	}
	catch (UnsupportedEncodingException e)
	{
		throw new RedmineException("Failed to encode repository url as filename",e);
	}
	
	File destinationFile = stateLocationPath.append(encodedFilename).toFile();
	return destinationFile;
}
 

import com.taskadapter.redmineapi.RedmineException; //导入依赖的package包/类
@Override
	public Iterable<Issue> getIssuesByProject(Project project) throws RedmineException
	{
		List<Issue> issues = manager.getIssueManager().getIssues(project.getIdentifier(),null,Include.journals);
		
//		List<Issue> issuesWithJournals = new ArrayList<Issue>();
//		
//		for(Issue i : issues)
//		{
//			Issue issueWithJournals = manager.getIssueManager().getIssueById(i.getId(), Include.journals);
//			issuesWithJournals.add(issueWithJournals);
//		}
//		
//		return issuesWithJournals;
		
		return issues;
	}
 

import com.taskadapter.redmineapi.RedmineException; //导入依赖的package包/类
public void loadConfiguration() throws RedmineException
{
	User u = manager.getUserManager().getCurrentUser();
	
	configuration.setCurrentUser(u);
	
	if(configuration.isEmpty())
	{
		for(Membership m : u.getMemberships())
		{
			Project p = manager.getProjectManager().getProjectById(m.getProject().getId());
			
			configuration.addProject(p);
			
			List<Version> versions = manager.getProjectManager().getVersions(m.getProject().getId());
			
			configuration.addVersionsToProject(p, versions);
		}
		
		configuration.addStatuses(manager.getIssueManager().getStatuses());
		configuration.addTrackers(manager.getIssueManager().getTrackers());
		configuration.addUsers(manager.getUserManager().getUsers());		
	}
	
}
 

import com.taskadapter.redmineapi.RedmineException; //导入依赖的package包/类
@Override
public TaskData getTaskData(TaskRepository repository, String taskIdOrKey, IProgressMonitor monitor)
		throws CoreException
{

	try
	{
		IRedmineClient client = getClientManager().getClient(repository);
		
		Issue issue = client.getIssueById(Integer.parseInt(taskIdOrKey));
		
		
		return taskDataHandler.createTaskDataFromIssue(repository, issue, client.getCachedRepositoryConfiguration());
		
	}
	catch (RedmineException e)
	{
		throw new CoreException(new RepositoryStatus(Status.ERROR, RedmineCorePlugin.PLUGIN_ID, RepositoryStatus.ERROR_NETWORK, "Error performing query.",e));
	}
}
 

import com.taskadapter.redmineapi.RedmineException; //导入依赖的package包/类
@Override
public RepositoryInfo validateRepository(TaskRepository repository, IProgressMonitor monitor) throws CoreException
{
	RepositoryInfo info = new RepositoryInfo(new RepositoryVersion("1"));		
	
	try
	{
		clientManager.validateConnection(repository);
	}
	catch (RedmineException e)
	{
		throw new CoreException(new Status(IStatus.ERROR, RedmineCorePlugin.PLUGIN_ID, "Error connecting to repository",e));
	}
	
	return info;
}
 

import com.taskadapter.redmineapi.RedmineException; //导入依赖的package包/类
@Override
public InputStream getContent(TaskRepository repository, ITask task, TaskAttribute attachmentAttribute,
		IProgressMonitor monitor) throws CoreException
{
	TaskAttachmentMapper mapper = TaskAttachmentMapper.createFrom(attachmentAttribute);
			
	try
	{
		IRedmineClient client = redmineRepositoryConnector.getClientManager().getClient(repository);
		Attachment attachment = client.getAttachmentById(Integer.parseInt(mapper.getAttachmentId()));
		return client.downloadAttachment(attachment);
	}
	catch (RedmineException e)
	{
		throw new CoreException(new RepositoryStatus(Status.ERROR, RedmineCorePlugin.PLUGIN_ID, RepositoryStatus.ERROR_NETWORK, "Error downloading attachment.",e));
	}		
}
 

import com.taskadapter.redmineapi.RedmineException; //导入依赖的package包/类
private String getClosingMessage() {
    Validate.notNull(redmineGovernorConfiguration, "Redmine Governor configuration must be set.");

    String username = null;
    try {
        final User apiKeyUser = redmineManager.getUserManager().getCurrentUser();
        username = apiKeyUser.getLogin();
    } catch (RedmineException e) {
        logger.log(Level.WARNING, "Could not get redmine user.", e);
    }

    if (username == null || username.isEmpty()) {
        username = "unknown";
    }

    return String.format(redmineGovernorConfiguration.getClosingMessage(), username);
}
 

import com.taskadapter.redmineapi.RedmineException; //导入依赖的package包/类
private String getOpeningMessage() {
    Validate.notNull(redmineGovernorConfiguration, "Redmine Governor configuration must be set.");

    String username = null;
    try {
        final User apiKeyUser = redmineManager.getUserManager().getCurrentUser();
        username = apiKeyUser.getLogin();
    } catch (RedmineException e) {
        logger.log(Level.WARNING, "Could not get redmine user.", e);
    }

    if (username == null || username.isEmpty()) {
        username = "unknown";
    }

    return String.format(redmineGovernorConfiguration.getOpeningMessage(), username);
}
 

import com.taskadapter.redmineapi.RedmineException; //导入依赖的package包/类
/**
 * @see com.googlesource.gerrit.plugins.hooks.its.ItsFacade#addComment(java.lang.String,
 *      java.lang.String)
 */
@Override
public void addComment(final String issueId, final String comment)
    throws IOException {

  if (comment == null || comment.trim().isEmpty()) {
    return;
  }

  execute(new Callable<String>() {
    @Override
    public String call() throws Exception {
      Issue issue = new Issue();
      issue.setId(convertIssueId(issueId));
      issue.setNotes(comment);

      try {
        redmineManager.update(issue);
      } catch (RedmineException e) {
        LOGGER.error("Error in add comment: {}", e.getMessage(), e);
        throw new IOException(e.getMessage(), e);
      }
      return issueId;
    }
  });
}
 

import com.taskadapter.redmineapi.RedmineException; //导入依赖的package包/类
private void doPerformAction(final String issueKey, final String actionName)
    throws IOException, RedmineException {

  Integer statusId = getStatusId(actionName);

  if (statusId != null) {
    LOGGER.debug("Executing action " + actionName + " on issue " + issueKey);
    Issue issue = new Issue();
    issue.setId(valueOf(issueKey));
    issue.setStatusId(statusId);
    redmineManager.update(issue);
  } else {
    LOGGER.error("Action " + actionName
        + " not found within available actions");
    throw new InvalidTransitionException("Action " + actionName
        + " not executable on issue " + issueKey);
  }
}
 

import com.taskadapter.redmineapi.RedmineException; //导入依赖的package包/类
/**
 * {@inheritDoc}
 * 
 * @see hudson.tasks.UserNameResolver#findNameFor(hudson.model.User)
 */
@Override
public String findNameFor(hudson.model.User u) {
    LOGGER.info("Search username for {}", u);

    RedmineManager redmineManager = getRedmineManager();
    if (redmineManager == null) {
        return null;
    }

    String userId = u.getId();
    try {
        return redmineManager.getUserByLogin(userId).getFullName();
    } catch (RedmineException e) {
        LOGGER.info("User {} not found: {}", userId, e.getMessage());
        return null;
    }
}
 

import com.taskadapter.redmineapi.RedmineException; //导入依赖的package包/类
/**
 * {@inheritDoc}
 * 
 * @see hudson.tasks.MailAddressResolver#findMailAddressFor(hudson.model.User)
 */
@Override
public String findMailAddressFor(hudson.model.User u) {

    RedmineManager redmineManager = getRedmineManager();
    if (redmineManager == null) {
        return null;
    }

    try {
        return redmineManager.getUserByLogin(u.getId()).getMail();
    } catch (RedmineException e) {
        LOGGER.error("Email not found for {}", u);
        return null;
    }
}
 

import com.taskadapter.redmineapi.RedmineException; //导入依赖的package包/类
protected List<Version> getVersions(boolean requireReleased) {
    try {
        List<com.taskadapter.redmineapi.bean.Version> versions = project.getRedmineManager()
                .getVersions(Integer.valueOf(project.getProjectId()));
        List<Version> result = new ArrayList<Version>(versions.size());
        for (com.taskadapter.redmineapi.bean.Version version : versions) {
            Version convert = convert(version);
            if ( convert.isReleased()==requireReleased ) {
                result.add(convert);
            }
        }
        return result;
    } catch (RedmineException e) {
        throw new RuntimeException(e);
    }
}
 

import com.taskadapter.redmineapi.RedmineException; //导入依赖的package包/类
@Override
public void releaseVersion(String versionValue) {
    try {
        List<com.taskadapter.redmineapi.bean.Version> versions = project.getRedmineManager()
                .getVersions(Integer.valueOf(project.getProjectId()));
        for (com.taskadapter.redmineapi.bean.Version version : versions) {
            if ( versionValue.equals(version.getName()) ) {
                version.setDueDate(new Date());
                version.setDueDate(null);
                version.setStatus("closed");
                project.getRedmineManager().update(version);
                return;
            }
        }
    } catch (RedmineException e) {
        throw new RuntimeException(e);
    }
    throw new RuntimeException("Version not found");
}