/*******************************************************************************
* Copyright (c) 2004, 2009 Eugene Kuleshov and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Eugene Kuleshov - initial API and implementation
*******************************************************************************/
package org.eclipse.mylyn.internal.web.tasks;
import static org.eclipse.mylyn.internal.web.tasks.Util.isPresent;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.codec.EncoderException;
import org.apache.commons.codec.net.URLCodec;
import org.apache.commons.httpclient.Header;
import org.apache.commons.httpclient.HostConfiguration;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpException;
import org.apache.commons.httpclient.HttpMethod;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import org.apache.commons.lang.StringEscapeUtils;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.mylyn.commons.net.AbstractWebLocation;
import org.eclipse.mylyn.commons.net.AuthenticationCredentials;
import org.eclipse.mylyn.commons.net.AuthenticationType;
import org.eclipse.mylyn.commons.net.WebLocation;
import org.eclipse.mylyn.commons.net.WebUtil;
import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
import org.eclipse.mylyn.tasks.core.IRepositoryManager;
import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
import org.eclipse.mylyn.tasks.core.data.TaskAttributeMapper;
import org.eclipse.mylyn.tasks.core.data.TaskData;
import org.eclipse.mylyn.tasks.core.data.TaskDataCollector;
import org.eclipse.mylyn.tasks.core.data.TaskMapper;
import org.eclipse.mylyn.tasks.core.sync.ISynchronizationSession;
import org.eclipse.mylyn.tasks.ui.TaskRepositoryLocationUiFactory;
import org.eclipse.mylyn.tasks.ui.TasksUi;
import com.sun.syndication.feed.module.DCModule;
import com.sun.syndication.feed.synd.SyndEntry;
import com.sun.syndication.feed.synd.SyndFeed;
import com.sun.syndication.io.SyndFeedInput;
import com.sun.syndication.io.XmlReader;
/**
* Generic connector for web based issue tracking systems
*
* @author Eugene Kuleshov
*/
public class WebRepositoryConnector extends AbstractRepositoryConnector {
public static final String REPOSITORY_TYPE = "web"; //$NON-NLS-1$
public static final String PROPERTY_TASK_CREATION_URL = "taskCreationUrl"; //$NON-NLS-1$
public static final String PROPERTY_TASK_URL = "taskUrl"; //$NON-NLS-1$
public static final String PROPERTY_QUERY_URL = "queryUrl"; //$NON-NLS-1$
public static final String PROPERTY_QUERY_METHOD = "queryMethod"; //$NON-NLS-1$
public static final String PROPERTY_QUERY_REGEXP = "queryPattern"; //$NON-NLS-1$
public static final String PROPERTY_LOGIN_FORM_URL = "loginFormUrl"; //$NON-NLS-1$
public static final String PROPERTY_LOGIN_TOKEN_REGEXP = "loginTokenPattern"; //$NON-NLS-1$
public static final String PROPERTY_LOGIN_REQUEST_METHOD = "loginRequestMethod"; //$NON-NLS-1$
public static final String PROPERTY_LOGIN_REQUEST_URL = "loginRequestUrl"; //$NON-NLS-1$
public static final String PARAM_PREFIX = "param_"; //$NON-NLS-1$
public static final String PARAM_SERVER_URL = "serverUrl"; //$NON-NLS-1$
public static final String PARAM_USER_ID = "userId"; //$NON-NLS-1$
public static final String PARAM_PASSWORD = "password"; //$NON-NLS-1$
public static final String PARAM_LOGIN_TOKEN = "loginToken"; //$NON-NLS-1$
public static final String REQUEST_POST = "POST"; //$NON-NLS-1$
public static final String REQUEST_GET = "GET"; //$NON-NLS-1$
private static final String COMPLETED_STATUSES = "completed|fixed|resolved|invalid|verified|deleted|closed|done"; //$NON-NLS-1$
public static final String KEY_TASK_PREFIX = "taskPrefix"; //$NON-NLS-1$
public static final String KEY_QUERY_TEMPLATE = "UrlTemplate"; //$NON-NLS-1$
public static final String KEY_QUERY_PATTERN = "Regexp"; //$NON-NLS-1$
private static final String USER_AGENT = "WebTemplatesConnector"; //$NON-NLS-1$
private final static Date DEFAULT_DATE = new Date(0);
@Override
public String getConnectorKind() {
return REPOSITORY_TYPE;
}
@Override
public String getLabel() {
return Messages.WebRepositoryConnector_Web_Template_Advanced_;
}
@Override
public boolean canCreateNewTask(TaskRepository repository) {
return repository.hasProperty(PROPERTY_TASK_CREATION_URL);
}
@Override
public boolean canCreateTaskFromKey(TaskRepository repository) {
return repository.hasProperty(PROPERTY_TASK_URL);
}
@Override
public boolean canSynchronizeTask(TaskRepository taskRepository, ITask task) {
return false;
}
// @Override
// public AbstractTask createTaskFromExistingId(TaskRepository repository, final String id, IProgressMonitor monitor)
// throws CoreException {
// if (REPOSITORY_TYPE.equals(repository.getConnectorKind())) {
// String taskPrefix = evaluateParams(repository.getProperty(PROPERTY_TASK_URL), repository);
//
// final WebTask task = new WebTask(id, id, taskPrefix, repository.getRepositoryUrl(), REPOSITORY_TYPE);
//
// RetrieveTitleFromUrlJob job = new RetrieveTitleFromUrlJob(taskPrefix + id) {
// @Override
// protected void setTitle(String pageTitle) {
// task.setSummary(pageTitle);
// TasksUiPlugin.getTaskList().notifyTaskChanged(task, false);
// }
// };
// job.schedule();
//
// return task;
// }
//
// return null;
// }
@Override
public TaskData getTaskData(TaskRepository repository, String taskId, IProgressMonitor monitor)
throws CoreException {
String taskPrefix = evaluateParams(repository.getProperty(PROPERTY_TASK_URL), repository);
TaskData taskData = createTaskData(repository, taskId);
TaskMapper mapper = new TaskMapper(taskData, true);
mapper.setCreationDate(DEFAULT_DATE);
mapper.setTaskUrl(taskPrefix + taskId);
mapper.setValue(KEY_TASK_PREFIX, taskPrefix);
// bug 300310: only update the summary on forced refreshes
mapper.setSummary(taskId);
try {
String pageTitle = WebUtil.getTitleFromUrl(new WebLocation(taskPrefix + taskId), monitor);
if (pageTitle != null) {
mapper.setSummary(pageTitle);
}
} catch (IOException e) {
// log to error log?
}
taskData.getRoot()
.getMappedAttribute(TaskAttribute.SUMMARY)
.getMetaData()
.putValue("forced", Boolean.TRUE.toString());
return taskData;
}
@SuppressWarnings("restriction")
@Override
public String getRepositoryUrlFromTaskUrl(String url) {
if (url == null) {
return null;
}
// lookup repository using task prefix url
IRepositoryManager repositoryManager = TasksUi.getRepositoryManager();
for (TaskRepository repository : repositoryManager.getRepositories(getConnectorKind())) {
String taskUrl = evaluateParams(repository.getProperty(PROPERTY_TASK_URL), repository);
if (taskUrl != null && !taskUrl.equals("") && url.startsWith(taskUrl)) { //$NON-NLS-1$
return repository.getRepositoryUrl();
}
}
for (IRepositoryQuery query : org.eclipse.mylyn.internal.tasks.ui.util.TasksUiInternal.getTaskList()
.getQueries()) {
TaskRepository repository = repositoryManager.getRepository(query.getConnectorKind(),
query.getRepositoryUrl());
if (repository != null) {
String queryUrl = evaluateParams(query.getAttribute(KEY_TASK_PREFIX), //
getQueryParams(query), repository);
if (queryUrl != null && !queryUrl.equals("") && url.startsWith(queryUrl)) { //$NON-NLS-1$
return query.getRepositoryUrl();
}
}
}
return null;
}
public static Map<String, String> getQueryParams(IRepositoryQuery query) {
Map<String, String> params = new LinkedHashMap<String, String>();
Map<String, String> attributes = query.getAttributes();
for (String name : attributes.keySet()) {
if (name.startsWith(WebRepositoryConnector.PARAM_PREFIX)) {
params.put(name, attributes.get(name));
}
}
return params;
}
@Override
public String getTaskIdFromTaskUrl(String url) {
if (url == null) {
return null;
}
IRepositoryManager repositoryManager = TasksUi.getRepositoryManager();
for (TaskRepository repository : repositoryManager.getRepositories(getConnectorKind())) {
String start = evaluateParams(repository.getProperty(PROPERTY_TASK_URL), repository);
if (start != null && url.startsWith(start)) {
return url.substring(start.length());
}
}
return null;
}
@Override
public String getTaskUrl(String repositoryUrl, String taskId) {
IRepositoryManager repositoryManager = TasksUi.getRepositoryManager();
TaskRepository repository = repositoryManager.getRepository(getConnectorKind(), repositoryUrl);
if (repository != null) {
String prefix = evaluateParams(repository.getProperty(PROPERTY_TASK_URL), repository);
return prefix + taskId;
}
return null;
}
@Override
public IStatus performQuery(TaskRepository repository, IRepositoryQuery query, TaskDataCollector resultCollector,
ISynchronizationSession session, IProgressMonitor monitor) {
Map<String, String> queryParameters = getQueryParams(query);
String queryUrl = evaluateParams(query.getUrl(), queryParameters, repository);
try {
String content = fetchResource(queryUrl, queryParameters, repository);
String taskPrefixAttribute = query.getAttribute(KEY_TASK_PREFIX);
if (!Util.isPresent(taskPrefixAttribute)) {
return performRssQuery(content, monitor, resultCollector, repository);
} else {
String taskPrefix = evaluateParams(taskPrefixAttribute, queryParameters, repository);
String queryPattern = evaluateParams(query.getAttribute(KEY_QUERY_PATTERN), queryParameters, repository);
return performQuery(content, queryPattern, taskPrefix, monitor, resultCollector, repository);
}
} catch (IOException e) {
String msg = e.getMessage() == null ? e.toString() : e.getMessage();
return new Status(IStatus.ERROR, TasksWebPlugin.ID_PLUGIN, IStatus.ERROR, //
Messages.WebRepositoryConnector_Could_not_fetch_resource + queryUrl + "\n" + msg, e); //$NON-NLS-1$
}
}
@Override
public boolean isRepositoryConfigurationStale(TaskRepository repository, IProgressMonitor monitor)
throws CoreException {
return false;
}
@Override
public void updateRepositoryConfiguration(TaskRepository repository, IProgressMonitor monitor) throws CoreException {
// ignore
}
@Override
public void updateTaskFromTaskData(TaskRepository repository, ITask task, TaskData taskData) {
preProcessTaskData(task, taskData);
TaskMapper mapper = new TaskMapper(taskData);
if (Util.isPresent(mapper.getValue(KEY_TASK_PREFIX))) {
task.setAttribute(KEY_TASK_PREFIX, mapper.getValue(KEY_TASK_PREFIX));
task.setTaskKey(task.getTaskId());
} else {
// do not show task id for RSS items
task.setTaskKey(null);
}
mapper.applyTo(task);
}
private void preProcessTaskData(ITask task, TaskData taskData) {
if (task.getSummary() != null && task.getSummary().length() > 0) {
// bug 300310: if task already has a summary, keep it
TaskAttribute summaryAttribute = taskData.getRoot().getMappedAttribute(TaskAttribute.SUMMARY);
if (summaryAttribute != null && Boolean.parseBoolean(summaryAttribute.getMetaData().getValue("forced"))) {
summaryAttribute.setValue(task.getSummary());
}
}
}
public static IStatus performQuery(String resource, String regexp, String taskPrefix, IProgressMonitor monitor,
TaskDataCollector resultCollector, TaskRepository repository) {
NamedPattern p = new NamedPattern(regexp, Pattern.CASE_INSENSITIVE | Pattern.MULTILINE | Pattern.DOTALL
| Pattern.UNICODE_CASE | Pattern.CANON_EQ);
Matcher matcher = p.matcher(resource);
if (!matcher.find()) {
return Status.OK_STATUS;
} else {
boolean isCorrect = true;
do {
if (p.getGroups().isEmpty()) {
// "classic" mode, no named patterns
if (matcher.groupCount() < 2) {
isCorrect = false;
}
if (matcher.groupCount() >= 1) {
String id = matcher.group(1);
String description = matcher.groupCount() > 1 ? cleanup(matcher.group(2), repository) : null;
description = unescapeHtml(description);
TaskData data = createTaskData(repository, id);
TaskMapper mapper = new TaskMapper(data, true);
mapper.setCreationDate(DEFAULT_DATE);
mapper.setTaskUrl(taskPrefix + id);
mapper.setSummary(description);
mapper.setValue(KEY_TASK_PREFIX, taskPrefix);
resultCollector.accept(data);
}
} else {
String id = p.group("Id", matcher); //$NON-NLS-1$
String description = p.group("Description", matcher); //$NON-NLS-1$
if (id == null || description == null) {
isCorrect = false;
}
if (id != null) {
description = unescapeHtml(description);
String owner = unescapeHtml(cleanup(p.group("Owner", matcher), repository)); //$NON-NLS-1$
String type = unescapeHtml(cleanup(p.group("Type", matcher), repository)); //$NON-NLS-1$
TaskData data = createTaskData(repository, id);
TaskMapper mapper = new TaskMapper(data, true);
mapper.setCreationDate(DEFAULT_DATE);
mapper.setTaskUrl(taskPrefix + id);
mapper.setSummary(description);
mapper.setValue(KEY_TASK_PREFIX, taskPrefix);
mapper.setOwner(owner);
mapper.setTaskKind(type);
String status = p.group("Status", matcher); //$NON-NLS-1$
if (status != null) {
if (COMPLETED_STATUSES.contains(status.toLowerCase())) {
// TODO set actual completion date here
mapper.setCompletionDate(DEFAULT_DATE);
}
}
resultCollector.accept(data);
}
}
} while (matcher.find() && !monitor.isCanceled());
if (isCorrect) {
return Status.OK_STATUS;
} else {
return new Status(IStatus.ERROR, TasksWebPlugin.ID_PLUGIN, IStatus.ERROR,
Messages.WebRepositoryConnector_Require_two_matching_groups, null);
}
}
}
private static TaskData createTaskData(TaskRepository taskRepository, String id) {
TaskData data = new TaskData(new TaskAttributeMapper(taskRepository), WebRepositoryConnector.REPOSITORY_TYPE,
taskRepository.getRepositoryUrl(), id);
data.setPartial(true);
return data;
}
private static String unescapeHtml(String text) {
if (text == null) {
return ""; //$NON-NLS-1$
}
return StringEscapeUtils.unescapeHtml(text);
}
private static String cleanup(String text, TaskRepository repository) {
if (text == null) {
return null;
}
// Has to disable this for now. See bug 166737 and bug 166936
// try {
// text = URLDecoder.decode(text, repository.getCharacterEncoding());
// } catch (UnsupportedEncodingException ex) {
// // ignore
// }
text = text.replaceAll("<!--.+?-->", ""); //$NON-NLS-1$ //$NON-NLS-2$
String[] tokens = text.split(" |\\t|\\n|\\r"); //$NON-NLS-1$
StringBuilder sb = new StringBuilder();
String sep = ""; //$NON-NLS-1$
for (String token : tokens) {
if (token.length() > 0) {
sb.append(sep).append(token);
sep = " "; //$NON-NLS-1$
}
}
return sb.toString();
}
public static IStatus performRssQuery(String content, IProgressMonitor monitor, TaskDataCollector resultCollector,
TaskRepository repository) {
SyndFeedInput input = new SyndFeedInput();
try {
SyndFeed feed = input.build(new XmlReader(new ByteArrayInputStream(content.getBytes())));
SimpleDateFormat df = new SimpleDateFormat("yy-MM-dd HH:mm"); //$NON-NLS-1$
Iterator<?> it;
for (it = feed.getEntries().iterator(); it.hasNext();) {
SyndEntry entry = (SyndEntry) it.next();
String author = entry.getAuthor();
if (author == null) {
DCModule module = (DCModule) entry.getModule("http://purl.org/dc/elements/1.1/"); //$NON-NLS-1$
author = module.getCreator();
}
Date date = entry.getUpdatedDate();
if (date == null) {
date = entry.getPublishedDate();
}
if (date == null) {
DCModule module = (DCModule) entry.getModule("http://purl.org/dc/elements/1.1/"); //$NON-NLS-1$
date = module.getDate();
}
String entryUri = entry.getLink();
if (entryUri == null) {
entryUri = entry.getUri();
}
String entrTitle = entry.getTitle();
TaskData data = createTaskData(repository, entryUri.replaceAll("-", "%2D")); //$NON-NLS-1$ //$NON-NLS-2$
TaskMapper schema = new TaskMapper(data, true);
schema.setSummary(((date == null ? "" : df.format(date) + " - ") + entrTitle)); //$NON-NLS-1$ //$NON-NLS-2$
schema.setCreationDate(date);
schema.setOwner(author);
schema.setTaskUrl(entryUri);
resultCollector.accept(data);
}
return Status.OK_STATUS;
} catch (Exception e) {
String msg = e.getMessage() == null ? e.toString() : e.getMessage();
return new Status(IStatus.ERROR, TasksWebPlugin.ID_PLUGIN, IStatus.ERROR, //
Messages.WebRepositoryConnector_Failed_to_parse_RSS_feed + "\"" + msg + "\"", e); //$NON-NLS-1$ //$NON-NLS-2$
}
}
public static String fetchResource(String url, Map<String, String> params, TaskRepository repository)
throws IOException {
HttpClient client = new HttpClient();
WebUtil.configureHttpClient(client, USER_AGENT);
AbstractWebLocation location = new TaskRepositoryLocationUiFactory().createWebLocation(repository);
HostConfiguration hostConfiguration = WebUtil.createHostConfiguration(client, location, null);
loginRequestIfNeeded(client, hostConfiguration, params, repository);
GetMethod method = new GetMethod(url);
// method.setFollowRedirects(false);
return requestResource(url, client, hostConfiguration, method);
}
private static void loginRequestIfNeeded(HttpClient client, HostConfiguration hostConfiguration,
Map<String, String> params, TaskRepository repository) throws HttpException, IOException {
if (repository.getCredentials(AuthenticationType.REPOSITORY) == null
|| !isPresent(repository.getProperty(PROPERTY_LOGIN_REQUEST_URL))) {
return;
}
String loginFormUrl = evaluateParams(repository.getProperty(PROPERTY_LOGIN_FORM_URL), params, repository);
String loginToken = evaluateParams(repository.getProperty(PROPERTY_LOGIN_TOKEN_REGEXP), params, repository);
if (isPresent(loginFormUrl) || isPresent(loginToken)) {
GetMethod method = new GetMethod(loginFormUrl);
// method.setFollowRedirects(false);
String loginFormPage = requestResource(loginFormUrl, client, hostConfiguration, method);
if (loginFormPage != null) {
Pattern p = Pattern.compile(loginToken);
Matcher m = p.matcher(loginFormPage);
if (m.find()) {
params.put(PARAM_PREFIX + PARAM_LOGIN_TOKEN, m.group(1));
}
}
}
String loginRequestUrl = evaluateParams(repository.getProperty(PROPERTY_LOGIN_REQUEST_URL), params, repository);
requestResource(loginRequestUrl, client, hostConfiguration, getLoginMethod(params, repository));
}
public static HttpMethod getLoginMethod(Map<String, String> params, TaskRepository repository) {
String requestMethod = repository.getProperty(PROPERTY_LOGIN_REQUEST_METHOD);
String requestTemplate = repository.getProperty(PROPERTY_LOGIN_REQUEST_URL);
String requestUrl = evaluateParams(requestTemplate, params, repository);
if (REQUEST_GET.equals(requestMethod)) {
return new GetMethod(requestUrl);
// method.setFollowRedirects(false);
}
int n = requestUrl.indexOf('?');
if (n == -1) {
return new PostMethod(requestUrl);
}
PostMethod postMethod = new PostMethod(requestUrl.substring(0, n));
// TODO this does not take into account escaped values
n = requestTemplate.indexOf('?');
String[] requestParams = requestTemplate.substring(n + 1).split("&"); //$NON-NLS-1$
for (String requestParam : requestParams) {
String[] nv = requestParam.split("="); //$NON-NLS-1$
if (nv.length == 1) {
postMethod.addParameter(nv[0], ""); //$NON-NLS-1$
} else {
String value = evaluateParams(nv[1], getParams(repository, params), false);
postMethod.addParameter(nv[0], value);
}
}
return postMethod;
}
private static String requestResource(String url, HttpClient client, HostConfiguration hostConfiguration,
HttpMethod method) throws IOException, HttpException {
String refreshUrl = null;
try {
client.executeMethod(hostConfiguration, method);
// int statusCode = client.executeMethod(method);
// if (statusCode == 300 || statusCode == 301 || statusCode == 302 || statusCode == 303 || statusCode == 307) {
// Header location = method.getResponseHeader("Location");
// if (location != null) {
// refreshUrl = location.getValue();
// if (!refreshUrl.startsWith("/")) {
// refreshUrl = "/" + refreshUrl;
// }
// }
// }
refreshUrl = getRefreshUrl(url, method);
if (refreshUrl == null) {
return method.getResponseBodyAsString();
}
} finally {
method.releaseConnection();
}
method = new GetMethod(refreshUrl);
try {
client.executeMethod(hostConfiguration, method);
return method.getResponseBodyAsString();
} finally {
method.releaseConnection();
}
}
private static String getRefreshUrl(String url, HttpMethod method) {
Header refreshHeader = method.getResponseHeader("Refresh"); //$NON-NLS-1$
if (refreshHeader == null) {
return null;
}
String value = refreshHeader.getValue();
int n = value.indexOf(";url="); //$NON-NLS-1$
if (n == -1) {
return null;
}
value = value.substring(n + 5);
int requestPath;
if (value.charAt(0) == '/') {
int colonSlashSlash = url.indexOf("://"); //$NON-NLS-1$
requestPath = url.indexOf('/', colonSlashSlash + 3);
} else {
requestPath = url.lastIndexOf('/');
}
String refreshUrl;
if (requestPath == -1) {
refreshUrl = url + "/" + value; //$NON-NLS-1$
} else {
refreshUrl = url.substring(0, requestPath + 1) + value;
}
return refreshUrl;
}
public static String evaluateParams(String value, Map<String, String> params, TaskRepository repository) {
return evaluateParams(value, getParams(repository, params), true);
}
public static String evaluateParams(String value, TaskRepository repository) {
return evaluateParams(value, getParams(repository, null), true);
}
private static String evaluateParams(String value, Map<String, String> params, boolean encode) {
if (value == null || value.indexOf("${") == -1) { //$NON-NLS-1$
return value;
}
int n = 0;
int n1 = value.indexOf("${"); //$NON-NLS-1$
StringBuilder evaluatedValue = new StringBuilder(value.length());
while (n1 > -1) {
evaluatedValue.append(value.substring(n, n1));
int n2 = value.indexOf("}", n1); //$NON-NLS-1$
if (n2 > -1) {
String key = value.substring(n1 + 2, n2);
if (PARAM_SERVER_URL.equals(key) || PARAM_USER_ID.equals(key) || PARAM_PASSWORD.equals(key)) {
evaluatedValue.append(evaluateParams(params.get(key), params, false));
} else {
String val = evaluateParams(params.get(PARAM_PREFIX + key), params, false);
evaluatedValue.append(encode ? encode(val) : val);
}
}
n = n2 + 1;
n1 = value.indexOf("${", n2); //$NON-NLS-1$
}
if (n > -1) {
evaluatedValue.append(value.substring(n));
}
return evaluatedValue.toString();
}
private static Map<String, String> getParams(TaskRepository repository, Map<String, String> params) {
Map<String, String> mergedParams = new LinkedHashMap<String, String>(repository.getProperties());
mergedParams.put(PARAM_SERVER_URL, repository.getRepositoryUrl());
AuthenticationCredentials credentials = repository.getCredentials(AuthenticationType.REPOSITORY);
if (credentials != null) {
mergedParams.put(PARAM_USER_ID, credentials.getUserName());
mergedParams.put(PARAM_PASSWORD, credentials.getPassword());
}
if (params != null) {
mergedParams.putAll(params);
}
return mergedParams;
}
private static String encode(String value) {
try {
return new URLCodec().encode(value);
} catch (EncoderException ex) {
return value;
}
}
public static List<String> getTemplateVariables(String value) {
if (value == null) {
return Collections.emptyList();
}
List<String> vars = new ArrayList<String>();
Matcher m = Pattern.compile("\\$\\{(.+?)\\}").matcher(value); //$NON-NLS-1$
while (m.find()) {
vars.add(m.group(1));
}
return vars;
}
@Override
public boolean hasLocalCompletionState(TaskRepository taskRepository, ITask task) {
return true;
}
@Override
public boolean hasTaskChanged(TaskRepository taskRepository, ITask task, TaskData taskData) {
preProcessTaskData(task, taskData);
return new TaskMapper(taskData).hasChanges(task);
}
}