Attachment #122193 for bug #260619

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 260619
Collapse All | Expand All

Lines 26-33 Link Here

(-)src/org/eclipse/mylyn/internal/web/tasks/WebRepositoryConnector.java (-126 / +65 lines)
26	import java.util.regex.Matcher;	26	import java.util.regex.Matcher;
27	import java.util.regex.Pattern;	27	import java.util.regex.Pattern;
28		28
29	import org.apache.commons.codec.EncoderException;
30	import org.apache.commons.codec.net.URLCodec;
31	import org.apache.commons.httpclient.Header;	29	import org.apache.commons.httpclient.Header;
32	import org.apache.commons.httpclient.HostConfiguration;	30	import org.apache.commons.httpclient.HostConfiguration;
33	import org.apache.commons.httpclient.HttpClient;	31	import org.apache.commons.httpclient.HttpClient;
Lines 37-47 Link Here
37	import org.apache.commons.httpclient.methods.PostMethod;	35	import org.apache.commons.httpclient.methods.PostMethod;
38	import org.apache.commons.lang.StringEscapeUtils;	36	import org.apache.commons.lang.StringEscapeUtils;
39	import org.eclipse.core.runtime.CoreException;	37	import org.eclipse.core.runtime.CoreException;
		38	import org.eclipse.core.runtime.IConfigurationElement;
		39	import org.eclipse.core.runtime.IExtension;
		40	import org.eclipse.core.runtime.IExtensionRegistry;
40	import org.eclipse.core.runtime.IProgressMonitor;	41	import org.eclipse.core.runtime.IProgressMonitor;
41	import org.eclipse.core.runtime.IStatus;	42	import org.eclipse.core.runtime.IStatus;
		43	import org.eclipse.core.runtime.Platform;
42	import org.eclipse.core.runtime.Status;	44	import org.eclipse.core.runtime.Status;
43	import org.eclipse.mylyn.commons.net.AbstractWebLocation;	45	import org.eclipse.mylyn.commons.net.AbstractWebLocation;
44	import org.eclipse.mylyn.commons.net.AuthenticationCredentials;
45	import org.eclipse.mylyn.commons.net.AuthenticationType;	46	import org.eclipse.mylyn.commons.net.AuthenticationType;
46	import org.eclipse.mylyn.commons.net.WebLocation;	47	import org.eclipse.mylyn.commons.net.WebLocation;
47	import org.eclipse.mylyn.commons.net.WebUtil;	48	import org.eclipse.mylyn.commons.net.WebUtil;
Lines 57-62 Link Here
57	import org.eclipse.mylyn.tasks.core.sync.ISynchronizationSession;	58	import org.eclipse.mylyn.tasks.core.sync.ISynchronizationSession;
58	import org.eclipse.mylyn.tasks.ui.TaskRepositoryLocationUiFactory;	59	import org.eclipse.mylyn.tasks.ui.TaskRepositoryLocationUiFactory;
59	import org.eclipse.mylyn.tasks.ui.TasksUi;	60	import org.eclipse.mylyn.tasks.ui.TasksUi;
		61	import org.eclipse.mylyn.web.tasks.ITaskMapperUpdator;
		62	import org.eclipse.mylyn.web.tasks.WebRepositoryConstant;
		63	import org.eclipse.mylyn.web.tasks.WebRepositoryUtil;
60		64
61	import com.sun.syndication.feed.module.DCModule;	65	import com.sun.syndication.feed.module.DCModule;
62	import com.sun.syndication.feed.synd.SyndEntry;	66	import com.sun.syndication.feed.synd.SyndEntry;
Lines 69-122 Link Here
69	*	73	*
70	* @author Eugene Kuleshov	74	* @author Eugene Kuleshov
71	*/	75	*/
72	public class WebRepositoryConnector extends AbstractRepositoryConnector {	76	public class WebRepositoryConnector extends AbstractRepositoryConnector implements WebRepositoryConstant {
73
74	public static final String REPOSITORY_TYPE = "web";
75
76	public static final String PROPERTY_TASK_CREATION_URL = "taskCreationUrl";
77
78	public static final String PROPERTY_TASK_URL = "taskUrl";
79
80	public static final String PROPERTY_QUERY_URL = "queryUrl";
81
82	public static final String PROPERTY_QUERY_METHOD = "queryMethod";
83
84	public static final String PROPERTY_QUERY_REGEXP = "queryPattern";
85
86	public static final String PROPERTY_LOGIN_FORM_URL = "loginFormUrl";
87
88	public static final String PROPERTY_LOGIN_TOKEN_REGEXP = "loginTokenPattern";
89
90	public static final String PROPERTY_LOGIN_REQUEST_METHOD = "loginRequestMethod";
91
92	public static final String PROPERTY_LOGIN_REQUEST_URL = "loginRequestUrl";
93
94	public static final String PARAM_PREFIX = "param_";
95
96	public static final String PARAM_SERVER_URL = "serverUrl";
97
98	public static final String PARAM_USER_ID = "userId";
99
100	public static final String PARAM_PASSWORD = "password";
101
102	public static final String PARAM_LOGIN_TOKEN = "loginToken";
103
104	public static final String REQUEST_POST = "POST";
105
106	public static final String REQUEST_GET = "GET";
107		77
108	private static final String COMPLETED_STATUSES = "completed\|fixed\|resolved\|invalid\|verified\|deleted\|closed\|done";	78	private static final String COMPLETED_STATUSES = "completed\|fixed\|resolved\|invalid\|verified\|deleted\|closed\|done";
109		79
110	public static final String KEY_TASK_PREFIX = "taskPrefix";
111
112	public static final String KEY_QUERY_TEMPLATE = "UrlTemplate";
113
114	public static final String KEY_QUERY_PATTERN = "Regexp";
115
116	private static final String USER_AGENT = "WebTemplatesConnector";	80	private static final String USER_AGENT = "WebTemplatesConnector";
117		81
118	private final static Date DEFAULT_DATE = new Date(0);
119
120	@Override	82	@Override
121	public String getConnectorKind() {	83	public String getConnectorKind() {
122	return REPOSITORY_TYPE;	84	return REPOSITORY_TYPE;
Lines 168-177 Link Here
168	@Override	130	@Override
169	public TaskData getTaskData(TaskRepository repository, String taskId, IProgressMonitor monitor)	131	public TaskData getTaskData(TaskRepository repository, String taskId, IProgressMonitor monitor)
170	throws CoreException {	132	throws CoreException {
171	String taskPrefix = evaluateParams(repository.getProperty(PROPERTY_TASK_URL), repository);	133	String taskPrefix = WebRepositoryUtil.evaluateParams(repository.getProperty(PROPERTY_TASK_URL), repository);
172	TaskData taskData = createTaskData(repository, taskId);	134	TaskData taskData = createTaskData(repository, taskId);
173	TaskMapper mapper = new TaskMapper(taskData, true);	135	TaskMapper mapper = new TaskMapper(taskData, true);
174	mapper.setCreationDate(DEFAULT_DATE);	136	mapper.setCreationDate(WebRepositoryUtil.DEFAULT_DATE);
175	mapper.setSummary(taskId);	137	mapper.setSummary(taskId);
176	mapper.setTaskUrl(taskPrefix + taskId);	138	mapper.setTaskUrl(taskPrefix + taskId);
177	mapper.setValue(KEY_TASK_PREFIX, taskPrefix);	139	mapper.setValue(KEY_TASK_PREFIX, taskPrefix);
Lines 194-200 Link Here
194	// lookup repository using task prefix url	156	// lookup repository using task prefix url
195	IRepositoryManager repositoryManager = TasksUi.getRepositoryManager();	157	IRepositoryManager repositoryManager = TasksUi.getRepositoryManager();
196	for (TaskRepository repository : repositoryManager.getRepositories(getConnectorKind())) {	158	for (TaskRepository repository : repositoryManager.getRepositories(getConnectorKind())) {
197	String taskUrl = evaluateParams(repository.getProperty(PROPERTY_TASK_URL), repository);	159	String taskUrl = WebRepositoryUtil.evaluateParams(repository.getProperty(PROPERTY_TASK_URL), repository);
198	if (taskUrl != null && !taskUrl.equals("") && url.startsWith(taskUrl)) {	160	if (taskUrl != null && !taskUrl.equals("") && url.startsWith(taskUrl)) {
199	return repository.getRepositoryUrl();	161	return repository.getRepositoryUrl();
200	}	162	}
Lines 205-211 Link Here
205	TaskRepository repository = repositoryManager.getRepository(query.getConnectorKind(),	167	TaskRepository repository = repositoryManager.getRepository(query.getConnectorKind(),
206	query.getRepositoryUrl());	168	query.getRepositoryUrl());
207	if (repository != null) {	169	if (repository != null) {
208	String queryUrl = evaluateParams(query.getAttribute(KEY_TASK_PREFIX), //	170	String queryUrl = WebRepositoryUtil.evaluateParams(query.getAttribute(KEY_TASK_PREFIX), //
209	getQueryParams(query), repository);	171	getQueryParams(query), repository);
210	if (queryUrl != null && !queryUrl.equals("") && url.startsWith(queryUrl)) {	172	if (queryUrl != null && !queryUrl.equals("") && url.startsWith(queryUrl)) {
211	return query.getRepositoryUrl();	173	return query.getRepositoryUrl();
Lines 219-225 Link Here
219	Map<String, String> params = new LinkedHashMap<String, String>();	181	Map<String, String> params = new LinkedHashMap<String, String>();
220	Map<String, String> attributes = query.getAttributes();	182	Map<String, String> attributes = query.getAttributes();
221	for (String name : attributes.keySet()) {	183	for (String name : attributes.keySet()) {
222	if (name.startsWith(WebRepositoryConnector.PARAM_PREFIX)) {	184	if (name.startsWith(WebRepositoryConstant.PARAM_PREFIX)) {
223	params.put(name, attributes.get(name));	185	params.put(name, attributes.get(name));
224	}	186	}
225	}	187	}
Lines 234-240 Link Here
234		196
235	IRepositoryManager repositoryManager = TasksUi.getRepositoryManager();	197	IRepositoryManager repositoryManager = TasksUi.getRepositoryManager();
236	for (TaskRepository repository : repositoryManager.getRepositories(getConnectorKind())) {	198	for (TaskRepository repository : repositoryManager.getRepositories(getConnectorKind())) {
237	String start = evaluateParams(repository.getProperty(PROPERTY_TASK_URL), repository);	199	String start = WebRepositoryUtil.evaluateParams(repository.getProperty(PROPERTY_TASK_URL), repository);
238	if (start != null && url.startsWith(start)) {	200	if (start != null && url.startsWith(start)) {
239	return url.substring(start.length());	201	return url.substring(start.length());
240	}	202	}
Lines 247-253 Link Here
247	IRepositoryManager repositoryManager = TasksUi.getRepositoryManager();	209	IRepositoryManager repositoryManager = TasksUi.getRepositoryManager();
248	TaskRepository repository = repositoryManager.getRepository(getConnectorKind(), repositoryUrl);	210	TaskRepository repository = repositoryManager.getRepository(getConnectorKind(), repositoryUrl);
249	if (repository != null) {	211	if (repository != null) {
250	String prefix = evaluateParams(repository.getProperty(PROPERTY_TASK_URL), repository);	212	String prefix = WebRepositoryUtil.evaluateParams(repository.getProperty(PROPERTY_TASK_URL), repository);
251	return prefix + taskId;	213	return prefix + taskId;
252	}	214	}
253	return null;	215	return null;
Lines 257-272 Link Here
257	public IStatus performQuery(TaskRepository repository, IRepositoryQuery query, TaskDataCollector resultCollector,	219	public IStatus performQuery(TaskRepository repository, IRepositoryQuery query, TaskDataCollector resultCollector,
258	ISynchronizationSession session, IProgressMonitor monitor) {	220	ISynchronizationSession session, IProgressMonitor monitor) {
259	Map<String, String> queryParameters = getQueryParams(query);	221	Map<String, String> queryParameters = getQueryParams(query);
260	String queryUrl = evaluateParams(query.getUrl(), queryParameters, repository);	222	String queryUrl = WebRepositoryUtil.evaluateParams(query.getUrl(), queryParameters, repository);
261	try {	223	try {
262	String content = fetchResource(queryUrl, queryParameters, repository);	224	String content = fetchResource(queryUrl, queryParameters, repository);
263		225
264	String taskPrefixAttribute = query.getAttribute(KEY_TASK_PREFIX);	226	String taskPrefixAttribute = query.getAttribute(KEY_TASK_PREFIX);
265	if (!Util.isPresent(taskPrefixAttribute)) {	227	if (!isPresent(taskPrefixAttribute)) {
266	return performRssQuery(content, monitor, resultCollector, repository);	228	return performRssQuery(content, monitor, resultCollector, repository);
267	} else {	229	} else {
268	String taskPrefix = evaluateParams(taskPrefixAttribute, queryParameters, repository);	230	String taskPrefix = WebRepositoryUtil.evaluateParams(taskPrefixAttribute, queryParameters, repository);
269	String queryPattern = evaluateParams(query.getAttribute(KEY_QUERY_PATTERN), queryParameters, repository);	231	String queryPattern = WebRepositoryUtil.evaluateParams(query.getAttribute(KEY_QUERY_PATTERN),
		232	queryParameters, repository);
270	return performQuery(content, queryPattern, taskPrefix, monitor, resultCollector, repository);	233	return performQuery(content, queryPattern, taskPrefix, monitor, resultCollector, repository);
271	}	234	}
272	} catch (IOException e) {	235	} catch (IOException e) {
Lines 290-296 Link Here
290	@Override	253	@Override
291	public void updateTaskFromTaskData(TaskRepository repository, ITask task, TaskData taskData) {	254	public void updateTaskFromTaskData(TaskRepository repository, ITask task, TaskData taskData) {
292	TaskMapper mapper = new TaskMapper(taskData);	255	TaskMapper mapper = new TaskMapper(taskData);
293	if (Util.isPresent(mapper.getValue(KEY_TASK_PREFIX))) {	256	if (isPresent(mapper.getValue(KEY_TASK_PREFIX))) {
294	task.setAttribute(KEY_TASK_PREFIX, mapper.getValue(KEY_TASK_PREFIX));	257	task.setAttribute(KEY_TASK_PREFIX, mapper.getValue(KEY_TASK_PREFIX));
295	task.setTaskKey(task.getTaskId());	258	task.setTaskKey(task.getTaskId());
296	} else {	259	} else {
Lines 300-307 Link Here
300	mapper.applyTo(task);	263	mapper.applyTo(task);
301	}	264	}
302		265
		266	private static ITaskMapperUpdator getTaskMapperUpdator(TaskRepository repository) {
		267	String updatorID = repository.getProperty(PROPERTY_TASKMAPPER_UPDATOR);
		268	if (updatorID != null && updatorID.length() > 0) {
		269	IExtensionRegistry registry = Platform.getExtensionRegistry();
		270	IExtension[] extensions = registry.getExtensionPoint(EXTENSION_TASKMAPPER_UPDATOR).getExtensions();
		271	for (IExtension extension : extensions) {
		272	IConfigurationElement[] elements = extension.getConfigurationElements();
		273	for (IConfigurationElement element : elements) {
		274	if (element.getAttribute("id").equals(updatorID)) {
		275	try {
		276	Object obj = element.createExecutableExtension("class");
		277	if (obj instanceof ITaskMapperUpdator) {
		278	return (ITaskMapperUpdator) obj;
		279	}
		280	} catch (CoreException e) {
		281	String ee = e.toString();
		282	}
		283	}
		284	}
		285	}
		286	}
		287	return null;
		288	}
		289
303	public static IStatus performQuery(String resource, String regexp, String taskPrefix, IProgressMonitor monitor,	290	public static IStatus performQuery(String resource, String regexp, String taskPrefix, IProgressMonitor monitor,
304	TaskDataCollector resultCollector, TaskRepository repository) {	291	TaskDataCollector resultCollector, TaskRepository repository) {
		292
		293	ITaskMapperUpdator updator = getTaskMapperUpdator(repository);
		294
305	NamedPattern p = new NamedPattern(regexp, Pattern.CASE_INSENSITIVE \| Pattern.MULTILINE \| Pattern.DOTALL	295	NamedPattern p = new NamedPattern(regexp, Pattern.CASE_INSENSITIVE \| Pattern.MULTILINE \| Pattern.DOTALL
306	\| Pattern.UNICODE_CASE \| Pattern.CANON_EQ);	296	\| Pattern.UNICODE_CASE \| Pattern.CANON_EQ);
307		297
Lines 324-330 Link Here
324		314
325	TaskData data = createTaskData(repository, id);	315	TaskData data = createTaskData(repository, id);
326	TaskMapper mapper = new TaskMapper(data, true);	316	TaskMapper mapper = new TaskMapper(data, true);
327	mapper.setCreationDate(DEFAULT_DATE);	317	mapper.setCreationDate(WebRepositoryUtil.DEFAULT_DATE);
328	mapper.setTaskUrl(taskPrefix + id);	318	mapper.setTaskUrl(taskPrefix + id);
329	mapper.setSummary(description);	319	mapper.setSummary(description);
330	mapper.setValue(KEY_TASK_PREFIX, taskPrefix);	320	mapper.setValue(KEY_TASK_PREFIX, taskPrefix);
Lines 344-350 Link Here
344		334
345	TaskData data = createTaskData(repository, id);	335	TaskData data = createTaskData(repository, id);
346	TaskMapper mapper = new TaskMapper(data, true);	336	TaskMapper mapper = new TaskMapper(data, true);
347	mapper.setCreationDate(DEFAULT_DATE);	337	mapper.setCreationDate(WebRepositoryUtil.DEFAULT_DATE);
348	mapper.setTaskUrl(taskPrefix + id);	338	mapper.setTaskUrl(taskPrefix + id);
349	mapper.setSummary(description);	339	mapper.setSummary(description);
350	mapper.setValue(KEY_TASK_PREFIX, taskPrefix);	340	mapper.setValue(KEY_TASK_PREFIX, taskPrefix);
Lines 355-364 Link Here
355	if (status != null) {	345	if (status != null) {
356	if (COMPLETED_STATUSES.contains(status.toLowerCase())) {	346	if (COMPLETED_STATUSES.contains(status.toLowerCase())) {
357	// TODO set actual completion date here	347	// TODO set actual completion date here
358	mapper.setCompletionDate(DEFAULT_DATE);	348	mapper.setCompletionDate(WebRepositoryUtil.DEFAULT_DATE);
359	}	349	}
360	}	350	}
361		351
		352	if (updator != null) {
		353	updator.update(mapper, repository, p, matcher);
		354	}
		355
362	resultCollector.accept(data);	356	resultCollector.accept(data);
363	}	357	}
364	}	358	}
Lines 374-380 Link Here
374	}	368	}
375		369
376	private static TaskData createTaskData(TaskRepository taskRepository, String id) {	370	private static TaskData createTaskData(TaskRepository taskRepository, String id) {
377	TaskData data = new TaskData(new TaskAttributeMapper(taskRepository), WebRepositoryConnector.REPOSITORY_TYPE,	371	TaskData data = new TaskData(new TaskAttributeMapper(taskRepository), WebRepositoryConstant.REPOSITORY_TYPE,
378	taskRepository.getRepositoryUrl(), id);	372	taskRepository.getRepositoryUrl(), id);
379	data.setPartial(true);	373	data.setPartial(true);
380	return data;	374	return data;
Lines 486-493 Link Here
486	return;	480	return;
487	}	481	}
488		482
489	String loginFormUrl = evaluateParams(repository.getProperty(PROPERTY_LOGIN_FORM_URL), params, repository);	483	String loginFormUrl = WebRepositoryUtil.evaluateParams(repository.getProperty(PROPERTY_LOGIN_FORM_URL), params,
490	String loginToken = evaluateParams(repository.getProperty(PROPERTY_LOGIN_TOKEN_REGEXP), params, repository);	484	repository);
		485	String loginToken = WebRepositoryUtil.evaluateParams(repository.getProperty(PROPERTY_LOGIN_TOKEN_REGEXP),
		486	params, repository);
491	if (isPresent(loginFormUrl) \|\| isPresent(loginToken)) {	487	if (isPresent(loginFormUrl) \|\| isPresent(loginToken)) {
492	GetMethod method = new GetMethod(loginFormUrl);	488	GetMethod method = new GetMethod(loginFormUrl);
493	// method.setFollowRedirects(false);	489	// method.setFollowRedirects(false);
Lines 501-514 Link Here
501	}	497	}
502	}	498	}
503		499
504	String loginRequestUrl = evaluateParams(repository.getProperty(PROPERTY_LOGIN_REQUEST_URL), params, repository);	500	String loginRequestUrl = WebRepositoryUtil.evaluateParams(repository.getProperty(PROPERTY_LOGIN_REQUEST_URL),
		501	params, repository);
505	requestResource(loginRequestUrl, client, hostConfiguration, getLoginMethod(params, repository));	502	requestResource(loginRequestUrl, client, hostConfiguration, getLoginMethod(params, repository));
506	}	503	}
507		504
508	public static HttpMethod getLoginMethod(Map<String, String> params, TaskRepository repository) {	505	public static HttpMethod getLoginMethod(Map<String, String> params, TaskRepository repository) {
509	String requestMethod = repository.getProperty(PROPERTY_LOGIN_REQUEST_METHOD);	506	String requestMethod = repository.getProperty(PROPERTY_LOGIN_REQUEST_METHOD);
510	String requestTemplate = repository.getProperty(PROPERTY_LOGIN_REQUEST_URL);	507	String requestTemplate = repository.getProperty(PROPERTY_LOGIN_REQUEST_URL);
511	String requestUrl = evaluateParams(requestTemplate, params, repository);	508	String requestUrl = WebRepositoryUtil.evaluateParams(requestTemplate, params, repository);
512		509
513	if (REQUEST_GET.equals(requestMethod)) {	510	if (REQUEST_GET.equals(requestMethod)) {
514	return new GetMethod(requestUrl);	511	return new GetMethod(requestUrl);
Lines 529-535 Link Here
529	if (nv.length == 1) {	526	if (nv.length == 1) {
530	postMethod.addParameter(nv[0], "");	527	postMethod.addParameter(nv[0], "");
531	} else {	528	} else {
532	String value = evaluateParams(nv[1], getParams(repository, params), false);	529	String value = WebRepositoryUtil.evaluateParams(nv[1], WebRepositoryUtil.getParams(repository, params),
		530	false);
533	postMethod.addParameter(nv[0], value);	531	postMethod.addParameter(nv[0], value);
534	}	532	}
535	}	533	}
Lines 597-661 Link Here
597	return refreshUrl;	595	return refreshUrl;
598	}	596	}
599		597
600	public static String evaluateParams(String value, Map<String, String> params, TaskRepository repository) {
601	return evaluateParams(value, getParams(repository, params), true);
602	}
603
604	public static String evaluateParams(String value, TaskRepository repository) {
605	return evaluateParams(value, getParams(repository, null), true);
606	}
607
608	private static String evaluateParams(String value, Map<String, String> params, boolean encode) {
609	if (value == null \|\| value.indexOf("${") == -1) {
610	return value;
611	}
612
613	int n = 0;
614	int n1 = value.indexOf("${");
615	StringBuilder evaluatedValue = new StringBuilder(value.length());
616	while (n1 > -1) {
617	evaluatedValue.append(value.substring(n, n1));
618	int n2 = value.indexOf("}", n1);
619	if (n2 > -1) {
620	String key = value.substring(n1 + 2, n2);
621	if (PARAM_SERVER_URL.equals(key) \|\| PARAM_USER_ID.equals(key) \|\| PARAM_PASSWORD.equals(key)) {
622	evaluatedValue.append(evaluateParams(params.get(key), params, false));
623	} else {
624	String val = evaluateParams(params.get(PARAM_PREFIX + key), params, false);
625	evaluatedValue.append(encode ? encode(val) : val);
626	}
627	}
628	n = n2 + 1;
629	n1 = value.indexOf("${", n2);
630	}
631	if (n > -1) {
632	evaluatedValue.append(value.substring(n));
633	}
634	return evaluatedValue.toString();
635	}
636
637	private static Map<String, String> getParams(TaskRepository repository, Map<String, String> params) {
638	Map<String, String> mergedParams = new LinkedHashMap<String, String>(repository.getProperties());
639	mergedParams.put(PARAM_SERVER_URL, repository.getRepositoryUrl());
640	AuthenticationCredentials credentials = repository.getCredentials(AuthenticationType.REPOSITORY);
641	if (credentials != null) {
642	mergedParams.put(PARAM_USER_ID, credentials.getUserName());
643	mergedParams.put(PARAM_PASSWORD, credentials.getPassword());
644	}
645	if (params != null) {
646	mergedParams.putAll(params);
647	}
648	return mergedParams;
649	}
650
651	private static String encode(String value) {
652	try {
653	return new URLCodec().encode(value);
654	} catch (EncoderException ex) {
655	return value;
656	}
657	}
658
659	public static List<String> getTemplateVariables(String value) {	598	public static List<String> getTemplateVariables(String value) {
660	if (value == null) {	599	if (value == null) {
661	return Collections.emptyList();	600	return Collections.emptyList();

Return to bug 260619