Attachment 53438 Details for Bug 139312 – Updated patch and added roundtrip test

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

[patch] Updated patch and added roundtrip test

Clipboard-attachment (text/plain), 38.90 KB, created by Eugene Kuleshov

on 2006-11-08 02:22:21 EST

(hide)

Description:

Filename:

MIME Type:

Creator: Eugene Kuleshov

Created: 2006-11-08 02:22:21 EST

Size: 38.90 KB

patch

obsolete

>### Eclipse Workspace Patch 1.0
>#P org.eclipse.mylar.jira
>Index: src/org/eclipse/mylar/internal/jira/JiraRepositoryUi.java
>===================================================================
>RCS file: /home/technology/org.eclipse.mylar/org.eclipse.mylar.jira/src/org/eclipse/mylar/internal/jira/JiraRepositoryUi.java,v
>retrieving revision 1.8
>diff -u -r1.8 JiraRepositoryUi.java
>--- src/org/eclipse/mylar/internal/jira/JiraRepositoryUi.java	8 Nov 2006 06:47:57 -0000	1.8
>+++ src/org/eclipse/mylar/internal/jira/JiraRepositoryUi.java	8 Nov 2006 07:25:44 -0000
>@@ -39,9 +39,8 @@
> 	public IWizard getQueryWizard(TaskRepository repository, AbstractRepositoryQuery query) {
> 		if (query instanceof JiraRepositoryQuery || query instanceof JiraCustomQuery) {
> 			return new EditJiraQueryWizard(repository, query);
>-		} else {
>-			return new NewJiraQueryWizard(repository);
> 		}
>+		return new NewJiraQueryWizard(repository);
> 	}
> 	
> 	@Override
>Index: src/org/eclipse/mylar/internal/jira/JiraRepositoryQuery.java
>===================================================================
>RCS file: /home/technology/org.eclipse.mylar/org.eclipse.mylar.jira/src/org/eclipse/mylar/internal/jira/JiraRepositoryQuery.java,v
>retrieving revision 1.7
>diff -u -r1.7 JiraRepositoryQuery.java
>--- src/org/eclipse/mylar/internal/jira/JiraRepositoryQuery.java	20 Jul 2006 10:24:19 -0000	1.7
>+++ src/org/eclipse/mylar/internal/jira/JiraRepositoryQuery.java	8 Nov 2006 07:25:44 -0000
>@@ -16,7 +16,7 @@
> import org.tigris.jira.core.model.NamedFilter;
> 
> /**
>- * A JiraFilter represents a query for issues from a Jira repository.
>+ * A JiraRepositoryQuery represents a server-side query for Jira repository.
>  * 
>  * @author Mik Kersten
>  */
>@@ -31,7 +31,7 @@
> 		setMaxHits(MAX_HITS);
> 		this.filter = filter;
> 		super.repositoryUrl = repositoryUrl;
>-		setUrl(repositoryUrl + MylarJiraPlugin.FILTER_URL_PREFIX + filter.getId());
>+		setUrl(repositoryUrl + MylarJiraPlugin.FILTER_URL_PREFIX + "&requestId=" + filter.getId());
> //		super.setDescription(filter.getName());
> 	}
> 
>Index: src/org/eclipse/mylar/internal/jira/JiraCustomQuery.java
>===================================================================
>RCS file: /home/technology/org.eclipse.mylar/org.eclipse.mylar.jira/src/org/eclipse/mylar/internal/jira/JiraCustomQuery.java,v
>retrieving revision 1.4
>diff -u -r1.4 JiraCustomQuery.java
>--- src/org/eclipse/mylar/internal/jira/JiraCustomQuery.java	28 Oct 2006 00:55:48 -0000	1.4
>+++ src/org/eclipse/mylar/internal/jira/JiraCustomQuery.java	8 Nov 2006 07:25:44 -0000
>@@ -11,36 +11,430 @@
> 
> package org.eclipse.mylar.internal.jira;
> 
>+import java.io.UnsupportedEncodingException;
>+import java.net.URLDecoder;
>+import java.net.URLEncoder;
>+import java.text.SimpleDateFormat;
>+import java.util.ArrayList;
>+import java.util.Collections;
>+import java.util.Date;
>+import java.util.HashMap;
>+import java.util.List;
>+import java.util.Map;
>+
> import org.eclipse.mylar.tasks.core.AbstractRepositoryQuery;
> import org.eclipse.mylar.tasks.core.TaskList;
>+import org.eclipse.mylar.tasks.core.TaskRepository;
>+import org.tigris.jira.core.model.Component;
>+import org.tigris.jira.core.model.IssueType;
>+import org.tigris.jira.core.model.Priority;
>+import org.tigris.jira.core.model.Project;
>+import org.tigris.jira.core.model.Resolution;
>+import org.tigris.jira.core.model.Status;
>+import org.tigris.jira.core.model.Version;
>+import org.tigris.jira.core.model.filter.ComponentFilter;
>+import org.tigris.jira.core.model.filter.ContentFilter;
>+import org.tigris.jira.core.model.filter.CurrentUserFilter;
>+import org.tigris.jira.core.model.filter.DateFilter;
>+import org.tigris.jira.core.model.filter.DateRangeFilter;
> import org.tigris.jira.core.model.filter.FilterDefinition;
>+import org.tigris.jira.core.model.filter.IssueTypeFilter;
>+import org.tigris.jira.core.model.filter.NobodyFilter;
>+import org.tigris.jira.core.model.filter.PriorityFilter;
>+import org.tigris.jira.core.model.filter.ProjectFilter;
>+import org.tigris.jira.core.model.filter.ResolutionFilter;
>+import org.tigris.jira.core.model.filter.SpecificUserFilter;
>+import org.tigris.jira.core.model.filter.StatusFilter;
>+import org.tigris.jira.core.model.filter.UserFilter;
>+import org.tigris.jira.core.model.filter.UserInGroupFilter;
>+import org.tigris.jira.core.model.filter.VersionFilter;
>+import org.tigris.jira.core.service.JiraServer;
> 
> /**
>- * A JiraFilter represents a query for issues from a Jira repository.
>- * 
>+ * A JiraCustomQuery represents a custom query for issues from a Jira repository.
>+ *
>  * @author Mik Kersten
>+ * @author Eugene Kuleshov
>  */
> public class JiraCustomQuery extends AbstractRepositoryQuery {
> 
>+	private static final String PROJECT_KEY = "pid";
>+	private static final String COMPONENT_KEY = "component";
>+	private static final String TYPE_KEY = "type";
>+	private static final String PRIORITY_KEY = "priority";
>+	private static final String STATUS_KEY = "status";
>+	private static final String RESOLUTION_KEY = "resolution";
>+
>+	private static final String FIXFOR_KEY = "fixfor";
>+	private static final String VERSION_KEY = "version";
>+
>+	private static final String QUERY_KEY = "query";
>+	private static final String ENVIRONMENT_KEY = "environment";
>+	private static final String BODY_KEY = "body";
>+	private static final String DESCRIPTION_KEY = "description";
>+	private static final String SUMMARY_KEY = "summary";
>+
>+	private static final String ASSIGNEE_KEY = "assignee";
>+	private static final String REPORTER_KEY = "reporter";
>+
>+	private static final String CREATED_KEY = "created";
>+	private static final String UPDATED_KEY = "updated";
>+	private static final String DUEDATE_KEY = "duedate";
>+
>+	private static final String ISSUE_SPECIFIC_GROUP = "specificgroup";
>+	private static final String ISSUE_SPECIFIC_USER = "specificuser";
>+	private static final String ISSUE_CURRENT_USER = "issue_current_user";
>+	private static final String ISSUE_NO_REPORTER = "issue_no_reporter";
>+
> 	private static final int MAX_HITS = 200;
> 
>-	protected FilterDefinition filter = null;
> 
>-	public JiraCustomQuery(String repositoryUrl, FilterDefinition filter, TaskList taskList) {
>+	private final FilterDefinition filter;
>+	private String encoding;
>+
>+
>+	public JiraCustomQuery(String repositoryUrl, FilterDefinition filter, TaskList taskList, TaskRepository taskRepository) {
> 		super(filter.getName(), taskList);
>-		setMaxHits(MAX_HITS);
> 		this.filter = filter;
>-		super.repositoryUrl = repositoryUrl;
>-		setUrl(repositoryUrl + MylarJiraPlugin.FILTER_URL_PREFIX + filter.getName());
>+		this.repositoryUrl = repositoryUrl;
>+		this.encoding = taskRepository.getCharacterEncoding();
>+		this.url = repositoryUrl + MylarJiraPlugin.FILTER_URL_PREFIX + "&reset=true" + getQueryParams(filter);
>+		this.maxHits = MAX_HITS;
>+	}
>+
>+	public JiraCustomQuery(String name, String queryUrl, String repositoryUrl,
>+			JiraServer jiraServer, TaskList taskList, TaskRepository taskRepository) {
>+		super(name, taskList);
>+		this.repositoryUrl = repositoryUrl;
>+		this.url = queryUrl;
>+		this.encoding = taskRepository.getCharacterEncoding();
>+		this.filter = createFilter(jiraServer, queryUrl);
>+		this.filter.setName(name);
>+		this.maxHits = MAX_HITS;
> 	}
> 
> 	public String getRepositoryKind() {
> 		return MylarJiraPlugin.REPOSITORY_KIND;
> 	}
>-	
>+
> 	public FilterDefinition getFilterDefinition() {
> 		return filter;
> 	}
>+
>+
>+	private FilterDefinition createFilter(JiraServer jiraServer, String url) {
>+		FilterDefinition filter = new FilterDefinition();
>+
>+		int n = url.indexOf('?');
>+		if(n==-1) {
>+			return filter;
>+		}
>+
>+		HashMap<String, List<String>> params = new HashMap<String, List<String>>();
>+		for (String pair : url.substring(n+1).split("&")) {
>+			String[] tokens = pair.split("=");
>+			if (tokens.length > 1) {
>+				try {
>+					String key = tokens[0];
>+					String value = tokens.length==1 ? "" : URLDecoder.decode(tokens[1], encoding);
>+					List<String> values = params.get(key);
>+					if(values==null) {
>+						values = new ArrayList<String>();
>+						params.put(key, values);
>+					}
>+					values.add(value);
>+				} catch (UnsupportedEncodingException ex) {
>+					// ignore
>+				}
>+			}
>+		}
>+
>+		List<String> projectIds = getIds(params, PROJECT_KEY);
>+		for (String projectId : projectIds) {
>+			Project project = jiraServer.getProjectById(projectId);
>+			filter.setProjectFilter(new ProjectFilter(project));
>+
>+			List<String> componentIds = getIds(params, COMPONENT_KEY);
>+			List<Component> components = new ArrayList<Component>();
>+			for (String componentId : componentIds) {
>+				Component[] projectComponents = project.getComponents();
>+				for(Component component : projectComponents) {
>+					if(component.getId().equals(componentId)) {
>+						components.add(component);
>+					}
>+				}
>+			}
>+			if(!components.isEmpty()) {
>+				filter.setComponentFilter(new ComponentFilter(components.toArray(new Component[components.size()])));
>+			}
>+
>+			Version[] projectVersions = project.getVersions();
>+
>+			List<String> fixForIds = getIds(params, FIXFOR_KEY);
>+			List<Version> fixForversions = new ArrayList<Version>();
>+			for (String fixForId : fixForIds) {
>+				for (Version projectVersion : projectVersions) {
>+					if(projectVersion.getId().equals(fixForId)) {
>+						fixForversions.add(projectVersion);
>+					}
>+				}
>+			}
>+			if(!fixForversions.isEmpty()) {
>+				filter.setFixForVersionFilter(new VersionFilter(fixForversions.toArray(new Version[fixForversions.size()])));
>+			}
>+
>+			List<String> versionIds = getIds(params, VERSION_KEY);
>+			List<Version> versions = new ArrayList<Version>();
>+			for (String versionId : versionIds) {
>+				for (Version projectVersion : projectVersions) {
>+					if(projectVersion.getId().equals(versionId)) {
>+						versions.add(projectVersion);
>+					}
>+				}
>+			}
>+			if(!versions.isEmpty()) {
>+				filter.setReportedInVersionFilter(new VersionFilter(versions.toArray(new Version[versions.size()])));
>+			}
>+		}
>+
>+		List<String> typeIds = getIds(params, TYPE_KEY);
>+		List<IssueType> issueTypes = new ArrayList<IssueType>();
>+		for (String typeId : typeIds) {
>+			IssueType issueType = jiraServer.getIssueTypeById(typeId);
>+			if(!IssueType.MISSING_ISSUE_TYPE.equals(issueType)) {
>+				issueTypes.add(issueType);
>+			}
>+		}
>+		if(!issueTypes.isEmpty()) {
>+			filter.setIssueTypeFilter(new IssueTypeFilter(issueTypes.toArray(new IssueType[issueTypes.size()])));
>+		}
>+
>+		List<String> statusIds = getIds(params, STATUS_KEY);
>+		List<Status> statuses = new ArrayList<Status>();
>+		for (String statusId : statusIds) {
>+			Status status = jiraServer.getStatusById(statusId);
>+			if(!Status.MISSING_STATUS.equals(status)) {
>+				statuses.add(status);
>+			}
>+		}
>+		if(!statuses.isEmpty()) {
>+			filter.setStatusFilter(new StatusFilter(statuses.toArray(new Status[statuses.size()])));
>+		}
>+
>+		List<String> resolutionIds = getIds(params, RESOLUTION_KEY);
>+		List<Resolution> resolutions = new ArrayList<Resolution>();
>+		for (String resolutionId : resolutionIds) {
>+			Resolution resolution = jiraServer.getResolutionById(resolutionId);
>+			if(!Resolution.UNKNOWN_RESOLUTION.equals(resolution)) {
>+				resolutions.add(resolution);
>+			}
>+		}
>+		if(!resolutions.isEmpty()) {
>+			filter.setResolutionFilter(new ResolutionFilter(resolutions.toArray(new Resolution[resolutions.size()])));
>+		}
>+
>+		List<String> queries = getIds(params, QUERY_KEY);
>+		for (String query : queries) {
>+			boolean searchSummary = getIds(params, SUMMARY_KEY).contains("true");
>+			boolean searchDescription = getIds(params, DESCRIPTION_KEY).contains("true");
>+			boolean searchEnvironment = getIds(params, ENVIRONMENT_KEY).contains("true");
>+			boolean searchComments = getIds(params, BODY_KEY).contains("true");
>+			filter.setContentFilter(new ContentFilter(query, searchSummary, searchDescription, searchEnvironment, searchComments));
>+		}
>+
>+		filter.setReportedByFilter(createUserFilter(params, REPORTER_KEY));
>+		filter.setAssignedToFilter(createUserFilter(params, ASSIGNEE_KEY));
>+
>+		filter.setCreatedDateFilter(createDateFilter(params, CREATED_KEY));
>+		filter.setUpdatedDateFilter(createDateFilter(params, UPDATED_KEY));
>+		filter.setDueDateFilter(createDateFilter(params, DUEDATE_KEY));
>+
>+		return filter;
>+	}
>+
>+	private DateFilter createDateFilter(Map<String, List<String>> params, String key) {
>+		String after = getId(params, key + ":after");
>+		String before = getId(params, key + ":before");
>+
>+		SimpleDateFormat df = new SimpleDateFormat("d/MMM/yy");
>+		Date fromDate;
>+		try {
>+			fromDate = df.parse(after);
>+		} catch (Exception ex) {
>+			fromDate = null;
>+		}
>+		Date toDate;
>+		try {
>+			toDate = df.parse(before);
>+		} catch (Exception ex) {
>+			toDate = null;
>+		}
>+
>+		return fromDate==null && toDate==null ? null : new DateRangeFilter(fromDate, toDate);
>+	}
>+
>+	private UserFilter createUserFilter(Map<String, List<String>> params, String key) {
>+		String type = getId(params, key + "Select");
>+		if(ISSUE_NO_REPORTER.equals(type)) {
>+			return new NobodyFilter();
>+		} else if(ISSUE_CURRENT_USER.equals(type)) {
>+			return new CurrentUserFilter();
>+		} else {
>+			String reporter = getId(params, key);
>+			if(reporter!=null) {
>+				if(ISSUE_SPECIFIC_USER.equals(type)) {
>+					return new SpecificUserFilter(reporter);
>+				} else if(ISSUE_SPECIFIC_GROUP.equals(type)) {
>+					return new UserInGroupFilter(reporter);
>+				}
>+			}
>+		}
>+		return null;
>+	}
>+
>+	private String getId(Map<String, List<String>> params, String key) {
>+		List<String> ids = getIds(params, key);
>+		return ids.isEmpty() ? null : ids.get(0);
>+	}
>+
>+	private List<String> getIds(Map<String, List<String>> params, String key) {
>+		List<String> ids = params.get(key);
>+		if (ids==null) {
>+			return Collections.emptyList();
>+		}
>+		return ids;
>+	}
>+
>+
>+	private String getQueryParams(FilterDefinition filter) {
>+		StringBuffer sb = new StringBuffer();
>+
>+		ProjectFilter projectFilter = filter.getProjectFilter();
>+		if(projectFilter!=null) {
>+			Project project = projectFilter.getProject();
>+			// TODO all projects
>+			addParameter(sb, PROJECT_KEY, project.getId());
>+		}
>+
>+		ComponentFilter componentFilter = filter.getComponentFilter();
>+		// TODO all components
>+		if(componentFilter!=null) {
>+			if(componentFilter.hasNoComponent()) {
>+				addParameter(sb, COMPONENT_KEY, "-1");
>+			} else {
>+				for (Component component : componentFilter.getComponents()) {
>+					addParameter(sb, COMPONENT_KEY, component.getId());
>+				}
>+			}
>+		}
>+
>+		// TODO
>+		VersionFilter fixForVersionFilter = filter.getFixForVersionFilter();
>+		if (fixForVersionFilter != null) {
>+			for ( Version fixVersion : fixForVersionFilter.getVersions()) {
>+				addParameter(sb, FIXFOR_KEY, fixVersion.getId());
>+			}
>+		}
>+
>+		// TODO
>+		VersionFilter reportedInVersionFilter = filter.getReportedInVersionFilter();
>+		if (reportedInVersionFilter != null) {
>+			for (Version reportedVersion : reportedInVersionFilter.getVersions()) {
>+				addParameter(sb, VERSION_KEY, reportedVersion.getId());
>+			}
>+		}
>+
>+		// TODO
>+		IssueTypeFilter issueTypeFilter = filter.getIssueTypeFilter();
>+		if (issueTypeFilter != null) {
>+			for (IssueType issueType : issueTypeFilter.getIsueTypes()) {
>+				addParameter(sb, TYPE_KEY, issueType.getId());
>+			}
>+		}
>+
>+		// TODO
>+		StatusFilter statusFilter = filter.getStatusFilter();
>+		if(statusFilter!=null) {
>+			for ( Status status : statusFilter.getStatuses()) {
>+				addParameter(sb, STATUS_KEY, status.getId());
>+			}
>+		}
>+
>+		ResolutionFilter resolutionFilter = filter.getResolutionFilter();
>+		if(resolutionFilter!=null) {
>+			for (Resolution resolution : resolutionFilter.getResolutions()) {
>+				addParameter(sb, RESOLUTION_KEY, resolution.getId());
>+			}
>+		}
>+
>+		PriorityFilter priorityFilter = filter.getPriorityFilter();
>+		if(priorityFilter!=null) {
>+			for ( Priority priority : priorityFilter.getPriorities()) {
>+				addParameter(sb, PRIORITY_KEY, priority.getId());
>+			}
>+		}
>+
>+		ContentFilter contentFilter = filter.getContentFilter();
>+		if(contentFilter!=null) {
>+			String queryString = contentFilter.getQueryString();
>+			if(queryString!=null) {
>+				addParameter(sb, QUERY_KEY, queryString);
>+			}
>+			if(contentFilter.isSearchingSummary()) {
>+				addParameter(sb, SUMMARY_KEY, "true");
>+			}
>+			if(contentFilter.isSearchingDescription()) {
>+				addParameter(sb, DESCRIPTION_KEY, "true");
>+			}
>+			if(contentFilter.isSearchingComments()) {
>+				addParameter(sb, BODY_KEY, "true");
>+			}
>+			if(contentFilter.isSearchingEnvironment()) {
>+				addParameter(sb, ENVIRONMENT_KEY, "true");
>+			}
>+		}
>+
>+		addUserFilter(sb, filter.getReportedByFilter(), REPORTER_KEY);
>+		addUserFilter(sb, filter.getAssignedToFilter(), ASSIGNEE_KEY);
>+
>+		addDateFilter(sb, filter.getCreatedDateFilter(), CREATED_KEY);
>+		addDateFilter(sb, filter.getUpdatedDateFilter(), UPDATED_KEY);
>+		addDateFilter(sb, filter.getDueDateFilter(), DUEDATE_KEY);
>+
>+		return sb.toString();
>+	}
>+
>+	private void addDateFilter(StringBuffer sb, DateFilter filter, String type) {
>+		if(filter instanceof DateRangeFilter) {
>+			SimpleDateFormat df = new SimpleDateFormat("d/MMM/yy");
>+			DateRangeFilter rangeFilter = (DateRangeFilter) filter;
>+			addParameter(sb, type + ":after", df.format(rangeFilter.getFromDate()));
>+			addParameter(sb, type + ":before", df.format(rangeFilter.getToDate()));
>+		}
>+	}
>+
>+	private void addUserFilter(StringBuffer sb, UserFilter filter, String type) {
>+		if(filter instanceof NobodyFilter) {
>+			addParameter(sb, type + "Select", ISSUE_NO_REPORTER);
>+		} else if(filter instanceof CurrentUserFilter) {
>+			addParameter(sb, type + "Select", ISSUE_CURRENT_USER);
>+		} else if(filter instanceof SpecificUserFilter) {
>+			addParameter(sb, type + "Select", ISSUE_SPECIFIC_USER);
>+			addParameter(sb, type, ((SpecificUserFilter) filter).getUser());
>+		} else if(filter instanceof UserInGroupFilter) {
>+			addParameter(sb, type + "Select", ISSUE_SPECIFIC_GROUP);
>+			addParameter(sb, type, ((UserInGroupFilter) filter).getGroup());
>+		}
>+	}
>+
>+	private void addParameter(StringBuffer sb, String name, String value) {
>+		try {
>+			sb.append('&').append(name).append('=').append(URLEncoder.encode(value, encoding));
>+		} catch (UnsupportedEncodingException ex) {
>+			// ignore
>+		}
>+	}
>+
> }
> 
> //public void refreshHits() {
>Index: src/org/eclipse/mylar/internal/jira/JiraTaskExternalizer.java
>===================================================================
>RCS file: /home/technology/org.eclipse.mylar/org.eclipse.mylar.jira/src/org/eclipse/mylar/internal/jira/JiraTaskExternalizer.java,v
>retrieving revision 1.38
>diff -u -r1.38 JiraTaskExternalizer.java
>--- src/org/eclipse/mylar/internal/jira/JiraTaskExternalizer.java	4 Nov 2006 02:53:17 -0000	1.38
>+++ src/org/eclipse/mylar/internal/jira/JiraTaskExternalizer.java	8 Nov 2006 07:25:44 -0000
>@@ -12,11 +12,7 @@
> package org.eclipse.mylar.internal.jira;
> 
> import java.io.ByteArrayInputStream;
>-import java.io.ByteArrayOutputStream;
>-import java.io.IOException;
> import java.io.ObjectInputStream;
>-import java.io.ObjectOutputStream;
>-import java.io.StringWriter;
> 
> import org.eclipse.mylar.context.core.MylarStatusHandler;
> import org.eclipse.mylar.tasks.core.AbstractQueryHit;
>@@ -28,9 +24,11 @@
> import org.eclipse.mylar.tasks.core.ITaskListExternalizer;
> import org.eclipse.mylar.tasks.core.TaskExternalizationException;
> import org.eclipse.mylar.tasks.core.TaskList;
>+import org.eclipse.mylar.tasks.core.TaskRepository;
> import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
> import org.tigris.jira.core.model.NamedFilter;
> import org.tigris.jira.core.model.filter.FilterDefinition;
>+import org.tigris.jira.core.service.JiraServer;
> import org.w3c.dom.Document;
> import org.w3c.dom.Element;
> import org.w3c.dom.Node;
>@@ -60,10 +58,12 @@
> 
> 	private static final String KEY_FILTER_ID = "FilterID";
> 
>-	private static final String KEY_FILTER_DESCRIPTION = "FilterDesc";
>+//	private static final String KEY_FILTER_DESCRIPTION = "FilterDesc";
> 
> 	private static final String KEY_FILTER_CUSTOM = "FilterCustom";
> 
>+	private static final String KEY_FILTER_CUSTOM_URL = "FilterCustomUrl";
>+
> 	private static final String KEY_KEY = "Key";
> 
> 	public boolean canReadQuery(Node node) {
>@@ -81,7 +81,7 @@
> 		node.setAttribute(KEY_KEY, ((JiraQueryHit) queryHit).getKey());
> 		return node;
> 	}
>-		
>+
> 	public boolean canCreateElementFor(AbstractRepositoryQuery category) {
> 		return category instanceof JiraRepositoryQuery || category instanceof JiraCustomQuery;
> 	}
>@@ -94,27 +94,37 @@
> 		boolean hasCaughtException = false;
> 		Element element = (Element) node;
> 
>-		AbstractRepositoryQuery query;
>+		String repositoryUrl = element.getAttribute(KEY_REPOSITORY_URL);
> 		String custom = element.getAttribute(KEY_FILTER_CUSTOM);
>+		String customUrl = element.getAttribute(KEY_FILTER_CUSTOM_URL);
>+		AbstractRepositoryQuery query;
> 		if (custom != null && custom.length() > 0) {
>+			// TODO remove this at some point
> 			FilterDefinition filter = decodeFilter(custom);
> 			if (filter == null) {
> 				throw new TaskExternalizationException("Failed to restore custom query "
> 						+ element.getAttribute(KEY_FILTER_ID));
> 			}
> 			filter.setName(element.getAttribute(KEY_FILTER_ID));
>-			filter.setDescription(element.getAttribute(KEY_FILTER_DESCRIPTION));
>+			// filter.setDescription(element.getAttribute(KEY_FILTER_DESCRIPTION));
>+
>+			query = new JiraCustomQuery(repositoryUrl, filter,
>+					TasksUiPlugin.getTaskListManager().getTaskList(),
>+					TasksUiPlugin.getRepositoryManager().getRepository(MylarJiraPlugin.REPOSITORY_KIND, repositoryUrl));
>+		} else if (customUrl != null && customUrl.length() > 0) {
>+			TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(MylarJiraPlugin.REPOSITORY_KIND, repositoryUrl);
>+			JiraServer jiraServer = JiraServerFacade.getDefault().getJiraServer(repository);
>+			query = new JiraCustomQuery(element.getAttribute(KEY_FILTER_ID),
>+					customUrl, repositoryUrl, jiraServer, TasksUiPlugin.getTaskListManager().getTaskList(), repository);
> 
>-			query = new JiraCustomQuery(element.getAttribute(KEY_REPOSITORY_URL), filter, TasksUiPlugin
>-					.getTaskListManager().getTaskList());
> 		} else {
> 			NamedFilter namedFilter = new NamedFilter();
> 			namedFilter.setId(element.getAttribute(KEY_FILTER_ID));
> 			namedFilter.setName(element.getAttribute(KEY_FILTER_NAME));
>-			namedFilter.setDescription(element.getAttribute(KEY_FILTER_DESCRIPTION));
>+			// namedFilter.setDescription(element.getAttribute(KEY_FILTER_DESCRIPTION));
> 
>-			query = new JiraRepositoryQuery(element.getAttribute(KEY_REPOSITORY_URL), namedFilter, TasksUiPlugin
>-					.getTaskListManager().getTaskList());
>+			query = new JiraRepositoryQuery(repositoryUrl, namedFilter,
>+					TasksUiPlugin.getTaskListManager().getTaskList());
> 		}
> 
> 		NodeList list = node.getChildNodes();
>@@ -145,15 +155,14 @@
> 			NamedFilter filter = ((JiraRepositoryQuery) query).getNamedFilter();
> 			node.setAttribute(KEY_FILTER_ID, filter.getId());
> 			node.setAttribute(KEY_FILTER_NAME, filter.getName());
>-			node.setAttribute(KEY_FILTER_DESCRIPTION, filter.getDescription());
>-		} else {
>-			FilterDefinition filter = ((JiraCustomQuery) query).getFilterDefinition();
>+			// node.setAttribute(KEY_FILTER_DESCRIPTION, filter.getDescription());
>+		} else if(query instanceof JiraCustomQuery) {
>+			JiraCustomQuery customQuery = (JiraCustomQuery) query;
>+			FilterDefinition filter = customQuery.getFilterDefinition();
> 			node.setAttribute(KEY_FILTER_ID, filter.getName());
> 			node.setAttribute(KEY_FILTER_NAME, filter.getName());
>-			node.setAttribute(KEY_FILTER_DESCRIPTION, filter.getDescription());
>-
>-			// XXX implement actual export
>-			node.setAttribute(KEY_FILTER_CUSTOM, encodeFilter(filter));
>+			// node.setAttribute(KEY_FILTER_DESCRIPTION, filter.getDescription());
>+			node.setAttribute(KEY_FILTER_CUSTOM_URL, customQuery.getUrl());
> 		}
> 
> 		for (AbstractQueryHit hit : query.getHits()) {
>@@ -162,7 +171,7 @@
> 				for (ITaskListExternalizer externalizer : super.getDelegateExternalizers()) {
> 					if (externalizer.canCreateElementFor(hit)) {
> 						element = externalizer.createQueryHitElement(hit, doc, node);
>-					}
>+				    }
> 				}
> 				if (element == null) {
> 					createQueryHitElement(hit, doc, node);
>@@ -176,26 +185,6 @@
> 		return node;
> 	}
> 
>-	private String encodeFilter(FilterDefinition filter) {
>-		ByteArrayOutputStream bos = new ByteArrayOutputStream();
>-		ObjectOutputStream oos;
>-		try {
>-			oos = new ObjectOutputStream(bos);
>-			oos.writeObject(filter);
>-			oos.flush();
>-		} catch (IOException ex) {
>-			return null;
>-		}
>-
>-		StringWriter sw = new StringWriter();
>-		byte[] bytes = bos.toByteArray();
>-		for (int i = 0; i < bytes.length; i++) {
>-			byte b = bytes[i];
>-			sw.append((char) ('A' + (b >> 4))).append((char) ('A' + (b & 0xf)));
>-		}
>-		return sw.toString();
>-	}
>-
> 	private FilterDefinition decodeFilter(String filter) {
> 		byte[] buff = new byte[filter.length() / 2];
> 		char[] chars = filter.toCharArray();
>@@ -222,7 +211,7 @@
> 		Element node = super.createTaskElement(task, doc, parent);
> 		node.setAttribute(KEY_KEY, ((JiraTask) task).getKey());
> 		return node;
>-	} 
>+	}
> 
> 	@Override
> 	public ITask readTask(Node node, TaskList taskList, AbstractTaskContainer category, ITask parent)
>@@ -275,12 +264,12 @@
> 			key = element.getAttribute(KEY_KEY);
> 		}
> 
>-		String issueId = AbstractRepositoryTask.getTaskId(handle);
>+			String issueId = AbstractRepositoryTask.getTaskId(handle);
> 
> 		// TODO: implement completion
> 		JiraQueryHit hit = new JiraQueryHit(taskList, "<description>", query.getRepositoryUrl(), issueId, key, false);
> 		readQueryHitInfo(hit, taskList, query, element);
>-	}
>+		}
> 
> 	public String getQueryTagNameForElement(AbstractRepositoryQuery query) {
> 		if (query instanceof JiraRepositoryQuery) {
>Index: src/org/eclipse/mylar/internal/jira/MylarJiraPlugin.java
>===================================================================
>RCS file: /home/technology/org.eclipse.mylar/org.eclipse.mylar.jira/src/org/eclipse/mylar/internal/jira/MylarJiraPlugin.java,v
>retrieving revision 1.11
>diff -u -r1.11 MylarJiraPlugin.java
>--- src/org/eclipse/mylar/internal/jira/MylarJiraPlugin.java	24 Jul 2006 23:44:21 -0000	1.11
>+++ src/org/eclipse/mylar/internal/jira/MylarJiraPlugin.java	8 Nov 2006 07:25:44 -0000
>@@ -34,7 +34,7 @@
> 	public final static String ISSUE_URL_PREFIX = "/browse/";
> 
> 	/** Repository address + Filter Prefix + Issue key = the filter's web address */
>-	public final static String FILTER_URL_PREFIX = "/secure/IssueNavigator.jspa?mode=hide&requestId=";
>+	public final static String FILTER_URL_PREFIX = "/secure/IssueNavigator.jspa?mode=hide";
> 
> 	public MylarJiraPlugin() {
> 		INSTANCE = this;
>Index: src/org/eclipse/mylar/internal/jira/ui/wizards/JiraQueryPage.java
>===================================================================
>RCS file: /home/technology/org.eclipse.mylar/org.eclipse.mylar.jira/src/org/eclipse/mylar/internal/jira/ui/wizards/JiraQueryPage.java,v
>retrieving revision 1.4
>diff -u -r1.4 JiraQueryPage.java
>--- src/org/eclipse/mylar/internal/jira/ui/wizards/JiraQueryPage.java	8 Nov 2006 07:14:42 -0000	1.4
>+++ src/org/eclipse/mylar/internal/jira/ui/wizards/JiraQueryPage.java	8 Nov 2006 07:25:47 -0000
>@@ -30,6 +30,7 @@
> import org.eclipse.jface.viewers.Viewer;
> import org.eclipse.mylar.internal.jira.JiraCustomQuery;
> import org.eclipse.mylar.internal.jira.JiraServerFacade;
>+import org.eclipse.mylar.internal.jira.MylarJiraPlugin;
> import org.eclipse.mylar.internal.tasks.ui.search.AbstractRepositoryQueryPage;
> import org.eclipse.mylar.internal.tasks.ui.views.DatePicker;
> import org.eclipse.mylar.tasks.core.AbstractRepositoryQuery;
>@@ -138,7 +139,7 @@
> 
> 	private final JiraServer server;
> 
>-//	private Text name;
>+	private Text name;
> 
> 	private ListViewer project;
> 
>@@ -199,7 +200,7 @@
> 		this.workingCopy = workingCopy;
> 		this.isNew = isNew;
> 		this.namedQuery = namedQuery;
>-		
>+
> 		setDescription("Add search filters to define query.");
> 		setPageComplete(false);
> 	}
>@@ -213,15 +214,15 @@
> 			final GridData gridData = new GridData();
> 			lblName.setLayoutData(gridData);
> 			lblName.setText("Name:");
>-	
>+
> 			title = new Text(c, SWT.BORDER);
> 			title.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false, 2, 1));
> 			title.addModifyListener(new ModifyListener() {
>-	
>+
> 				public void modifyText(ModifyEvent e) {
> 					validatePage();
> 				}
>-	
>+
> 			});
> 		}
> 
>@@ -865,7 +866,7 @@
> 
> 	}
> 
>-	
>+
> //	public boolean isPageComplete() {
> //		if (namedQuery && name != null && name.getText().length() == 0) {
> //			return false;
>@@ -873,13 +874,13 @@
> //			return true;
> //		}
> //	}
>-	
>+
> 	void validatePage() {
> 		if (namedQuery && super.isPageComplete()) {
>-			setErrorMessage("Name is mandatory"); 
>+			setErrorMessage("Name is mandatory");
> 			setPageComplete(false);
> 			return;
>-		} else { 
>+		} else {
> 			setPageComplete(true);
> 			setErrorMessage(null);
> 		}
>@@ -1417,7 +1418,7 @@
> 
> 		/*
> 		 * (non-Javadoc)
>-		 * 
>+		 *
> 		 * @see java.lang.Object#equals(java.lang.Object)
> 		 */
> 		public boolean equals(Object obj) {
>@@ -1441,6 +1442,8 @@
> 			server.addLocalFilter(workingCopy);
> 		}
> 
>-		return new JiraCustomQuery(repository.getUrl(), workingCopy, TasksUiPlugin.getTaskListManager().getTaskList());
>+		String url = repository.getUrl();
>+		return new JiraCustomQuery(url, workingCopy, TasksUiPlugin.getTaskListManager().getTaskList(),
>+				TasksUiPlugin.getRepositoryManager().getRepository(MylarJiraPlugin.REPOSITORY_KIND, url));
> 	}
> }
>#P org.eclipse.mylar.jira.tests
>Index: src/org/eclipse/mylar/internal/jira/JiraCustomQueryTest.java
>===================================================================
>RCS file: src/org/eclipse/mylar/internal/jira/JiraCustomQueryTest.java
>diff -N src/org/eclipse/mylar/internal/jira/JiraCustomQueryTest.java
>--- /dev/null	1 Jan 1970 00:00:00 -0000
>+++ src/org/eclipse/mylar/internal/jira/JiraCustomQueryTest.java	1 Jan 1970 00:00:00 -0000
>@@ -0,0 +1,221 @@
>+package org.eclipse.mylar.internal.jira;
>+
>+import java.lang.reflect.InvocationHandler;
>+import java.lang.reflect.Method;
>+import java.lang.reflect.Proxy;
>+import java.util.Date;
>+
>+import org.eclipse.mylar.tasks.core.TaskList;
>+import org.eclipse.mylar.tasks.core.TaskRepository;
>+import org.tigris.jira.core.model.Component;
>+import org.tigris.jira.core.model.IssueType;
>+import org.tigris.jira.core.model.Project;
>+import org.tigris.jira.core.model.Resolution;
>+import org.tigris.jira.core.model.Status;
>+import org.tigris.jira.core.model.Version;
>+import org.tigris.jira.core.model.filter.ComponentFilter;
>+import org.tigris.jira.core.model.filter.ContentFilter;
>+import org.tigris.jira.core.model.filter.DateFilter;
>+import org.tigris.jira.core.model.filter.DateRangeFilter;
>+import org.tigris.jira.core.model.filter.FilterDefinition;
>+import org.tigris.jira.core.model.filter.IssueTypeFilter;
>+import org.tigris.jira.core.model.filter.ProjectFilter;
>+import org.tigris.jira.core.model.filter.ResolutionFilter;
>+import org.tigris.jira.core.model.filter.SpecificUserFilter;
>+import org.tigris.jira.core.model.filter.StatusFilter;
>+import org.tigris.jira.core.model.filter.UserFilter;
>+import org.tigris.jira.core.model.filter.VersionFilter;
>+import org.tigris.jira.core.service.JiraServer;
>+
>+import junit.framework.TestCase;
>+
>+
>+public class JiraCustomQueryTest extends TestCase {
>+
>+	private Project project;
>+
>+	protected void setUp() throws Exception {
>+		super.setUp();
>+
>+		Component[] comps = new Component[3];
>+		comps[0] = new Component();
>+		comps[0].setId("comp0");
>+		comps[1] = new Component();
>+		comps[1].setId("comp1");
>+		comps[2] = new Component();
>+		comps[2].setId("comp2");
>+
>+		Version[] vers = new Version[3];
>+		vers[0] = new Version();
>+		vers[0].setId("ver0");
>+		vers[1] = new Version();
>+		vers[1].setId("ver1");
>+		vers[2] = new Version();
>+		vers[2].setId("ver2");
>+
>+		project = new Project();
>+		project.setId("000");
>+		project.setComponents(comps);
>+		project.setVersions(vers);
>+	}
>+
>+	public void testJiraCustomQuery() {
>+		String repositoryUrl = "http://host.net/";
>+
>+		Component[] components = new Component[2];
>+		components[0] = new Component();
>+		components[0].setId("comp0");
>+		components[1] = new Component();
>+		components[1].setId("comp1");
>+
>+		Version[] fixVersions = new Version[2];
>+		fixVersions[0] = new Version();
>+		fixVersions[0].setId("ver0");
>+		fixVersions[1] = new Version();
>+		fixVersions[1].setId("ver1");
>+
>+		Version[] repoVersions = new Version[2];
>+		repoVersions[0] = new Version();
>+		repoVersions[0].setId("ver1");
>+		repoVersions[1] = new Version();
>+		repoVersions[1].setId("ver2");
>+
>+		IssueType[] issueTypes = new IssueType[2];
>+		issueTypes[0] = new IssueType();
>+		issueTypes[0].setId("issue0");
>+		issueTypes[1] = new IssueType();
>+		issueTypes[1].setId("issue1");
>+
>+		Status[] statuses = new Status[2];
>+		statuses[0] = new Status();
>+		statuses[0].setId("status0");
>+		statuses[1] = new Status();
>+		statuses[1].setId("status1");
>+
>+		Resolution[] resolutions = new Resolution[2];
>+		resolutions[0] = new Resolution();
>+		resolutions[0].setId("resolution0");
>+		resolutions[1] = new Resolution();
>+		resolutions[1].setId("resolution1");
>+
>+		FilterDefinition filter = new FilterDefinition();
>+		filter.setName("filter");
>+	    filter.setProjectFilter(new ProjectFilter(project));
>+		filter.setComponentFilter(new ComponentFilter(components));
>+		filter.setFixForVersionFilter(new VersionFilter(fixVersions));
>+		filter.setReportedInVersionFilter(new VersionFilter(repoVersions));
>+		filter.setIssueTypeFilter(new IssueTypeFilter(issueTypes));
>+		filter.setStatusFilter(new StatusFilter(statuses));
>+		filter.setResolutionFilter(new ResolutionFilter(resolutions));
>+
>+		filter.setContentFilter(new ContentFilter("query", true, true, true, true));
>+
>+		filter.setReportedByFilter(new SpecificUserFilter("reporter"));
>+		filter.setAssignedToFilter(new SpecificUserFilter("assignee"));
>+
>+		filter.setCreatedDateFilter(new DateRangeFilter(new Date(10), new Date(12)));
>+		filter.setUpdatedDateFilter(new DateRangeFilter(new Date(20), new Date(22)));
>+		filter.setDueDateFilter(new DateRangeFilter(new Date(30), new Date(32)));
>+
>+		TaskList taskList = new TaskList();
>+
>+		TaskRepository taskRepository = new TaskRepository(MylarJiraPlugin.REPOSITORY_KIND, repositoryUrl);
>+		taskRepository.setCharacterEncoding("ASCII");
>+
>+		JiraCustomQuery customQuery = new JiraCustomQuery(repositoryUrl, filter, taskList, taskRepository);
>+
>+		String queryUrl = customQuery.getUrl();
>+
>+		JiraServer jiraServer = (JiraServer) Proxy.newProxyInstance(getClass().getClassLoader(),
>+				new Class[] {JiraServer.class},
>+				new InvocationHandler() {
>+					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
>+						String name = method.getName();
>+						if("getProjectById".equals(name)) {
>+							return project;
>+						} else if("getIssueTypeById".equals(name)) {
>+							IssueType issueType = new IssueType();
>+							issueType.setId((String) args[0]);
>+							return issueType;
>+						} else if("getStatusById".equals(name)) {
>+							Status status = new Status();
>+							status.setId((String) args[0]);
>+							return status;
>+						} else if("getResolutionById".equals(name)) {
>+							Resolution resolution = new Resolution();
>+							resolution.setId((String) args[0]);
>+							return resolution;
>+						}
>+						return null;
>+					}
>+				});
>+
>+		JiraCustomQuery customQuery2 = new JiraCustomQuery("test", queryUrl, repositoryUrl, jiraServer, taskList, taskRepository);
>+
>+		FilterDefinition filter2 = customQuery2.getFilterDefinition();
>+
>+		ProjectFilter projectFilter2 = filter2.getProjectFilter();
>+		assertEquals(project.getId(), projectFilter2.getProject().getId());
>+
>+		Component[] components2 = filter2.getComponentFilter().getComponents();
>+		assertEquals(2, components2.length);
>+		assertEquals(components[0].getId(), components2[0].getId());
>+		assertEquals(components[1].getId(), components2[1].getId());
>+
>+		Version[] repoVersions2 = filter2.getReportedInVersionFilter().getVersions();
>+		assertEquals(2, repoVersions2.length);
>+		assertEquals(repoVersions[0].getId(), repoVersions2[0].getId());
>+		assertEquals(repoVersions[1].getId(), repoVersions2[1].getId());
>+
>+		Version[] fixVersions2 = filter2.getFixForVersionFilter().getVersions();
>+		assertEquals(2, fixVersions2.length);
>+		assertEquals(fixVersions[0].getId(), fixVersions2[0].getId());
>+		assertEquals(fixVersions[1].getId(), fixVersions2[1].getId());
>+
>+		IssueType[] issueTypes2 = filter2.getIssueTypeFilter().getIsueTypes();
>+		assertEquals(2, issueTypes2.length);
>+		assertEquals(issueTypes[0].getId(), issueTypes2[0].getId());
>+		assertEquals(issueTypes[1].getId(), issueTypes2[1].getId());
>+
>+		Status[] statuses2 = filter2.getStatusFilter().getStatuses();
>+		assertEquals(2, statuses2.length);
>+		assertEquals(statuses[0].getId(), statuses2[0].getId());
>+		assertEquals(statuses[1].getId(), statuses2[1].getId());
>+
>+		Resolution[] resolutions2 = filter2.getResolutionFilter().getResolutions();
>+		assertEquals(2, resolutions2.length);
>+		assertEquals(resolutions[0].getId(), resolutions2[0].getId());
>+		assertEquals(resolutions[1].getId(), resolutions2[1].getId());
>+
>+		ContentFilter contentFilter2 = filter2.getContentFilter();
>+		assertEquals("query", contentFilter2.getQueryString());
>+		assertEquals(true, contentFilter2.isSearchingComments());
>+		assertEquals(true, contentFilter2.isSearchingDescription());
>+		assertEquals(true, contentFilter2.isSearchingEnvironment());
>+		assertEquals(true, contentFilter2.isSearchingSummary());
>+
>+		UserFilter reportedByFilter2 = filter2.getReportedByFilter();
>+		assertTrue(reportedByFilter2 instanceof SpecificUserFilter);
>+		assertEquals("reporter", ((SpecificUserFilter) reportedByFilter2).getUser());
>+
>+		UserFilter assigneeFilter2 = filter2.getAssignedToFilter();
>+		assertTrue(assigneeFilter2 instanceof SpecificUserFilter);
>+		assertEquals("assignee", ((SpecificUserFilter) assigneeFilter2).getUser());
>+
>+		DateFilter createdDateFilter2 = filter.getCreatedDateFilter();
>+		assertTrue(createdDateFilter2 instanceof DateRangeFilter);
>+		assertEquals(10, ((DateRangeFilter) createdDateFilter2).getFromDate().getTime());
>+		assertEquals(12, ((DateRangeFilter) createdDateFilter2).getToDate().getTime());
>+
>+		DateFilter updatedDateFilter2 = filter.getUpdatedDateFilter();
>+		assertTrue(updatedDateFilter2 instanceof DateRangeFilter);
>+		assertEquals(20, ((DateRangeFilter) updatedDateFilter2).getFromDate().getTime());
>+		assertEquals(22, ((DateRangeFilter) updatedDateFilter2).getToDate().getTime());
>+
>+		DateFilter dueDateFilter2 = filter.getDueDateFilter();
>+		assertTrue(dueDateFilter2 instanceof DateRangeFilter);
>+		assertEquals(30, ((DateRangeFilter) dueDateFilter2).getFromDate().getTime());
>+		assertEquals(32, ((DateRangeFilter) dueDateFilter2).getToDate().getTime());
>+	}
>+
>+}

Actions: View | Diff

Attachments on bug 139312: 53123 | 53124 | 53151 | 53161 | 53438