Attachment #53438 for bug #139312

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

Lines 39-47 Link Here

(-)src/org/eclipse/mylar/internal/jira/JiraRepositoryUi.java (-2 / +1 lines)
39	public IWizard getQueryWizard(TaskRepository repository, AbstractRepositoryQuery query) {	39	public IWizard getQueryWizard(TaskRepository repository, AbstractRepositoryQuery query) {
40	if (query instanceof JiraRepositoryQuery \|\| query instanceof JiraCustomQuery) {	40	if (query instanceof JiraRepositoryQuery \|\| query instanceof JiraCustomQuery) {
41	return new EditJiraQueryWizard(repository, query);	41	return new EditJiraQueryWizard(repository, query);
42	} else {
43	return new NewJiraQueryWizard(repository);
44	}	42	}
		43	return new NewJiraQueryWizard(repository);
45	}	44	}
46		45
47	@Override	46	@Override

Lines 16-22 Link Here

(-)src/org/eclipse/mylar/internal/jira/JiraRepositoryQuery.java (-2 / +2 lines)
16	import org.tigris.jira.core.model.NamedFilter;	16	import org.tigris.jira.core.model.NamedFilter;
17		17
18	/**	18	/**
19	* A JiraFilter represents a query for issues from a Jira repository.	19	* A JiraRepositoryQuery represents a server-side query for Jira repository.
20	*	20	*
21	* @author Mik Kersten	21	* @author Mik Kersten
22	*/	22	*/
Lines 31-37 Link Here
31	setMaxHits(MAX_HITS);	31	setMaxHits(MAX_HITS);
32	this.filter = filter;	32	this.filter = filter;
33	super.repositoryUrl = repositoryUrl;	33	super.repositoryUrl = repositoryUrl;
34	setUrl(repositoryUrl + MylarJiraPlugin.FILTER_URL_PREFIX + filter.getId());	34	setUrl(repositoryUrl + MylarJiraPlugin.FILTER_URL_PREFIX + "&requestId=" + filter.getId());
35	// super.setDescription(filter.getName());	35	// super.setDescription(filter.getName());
36	}	36	}
37		37





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 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;

	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;
		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() {




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;

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;


	private static final String KEY_FILTER_ID = "FilterID";

//	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) {

		node.setAttribute(KEY_KEY, ((JiraQueryHit) queryHit).getKey());
		return node;
	}

	public boolean canCreateElementFor(AbstractRepositoryQuery category) {
		return category instanceof JiraRepositoryQuery || category instanceof JiraCustomQuery;
	}

		boolean hasCaughtException = false;
		Element element = (Element) node;

		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));

			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));

			query = new JiraRepositoryQuery(repositoryUrl, namedFilter,
					TasksUiPlugin.getTaskListManager().getTaskList());
		}

		NodeList list = node.getChildNodes();

			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 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());
			node.setAttribute(KEY_FILTER_CUSTOM_URL, customQuery.getUrl());
			// XXX implement actual export
			node.setAttribute(KEY_FILTER_CUSTOM, encodeFilter(filter));
		}

		for (AbstractQueryHit hit : query.getHits()) {

				for (ITaskListExternalizer externalizer : super.getDelegateExternalizers()) {
					if (externalizer.canCreateElementFor(hit)) {
						element = externalizer.createQueryHitElement(hit, doc, node);
				    }
				}
				if (element == null) {
					createQueryHitElement(hit, doc, node);

		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();

		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)

			key = element.getAttribute(KEY_KEY);
		}

			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) {

Lines 34-40 Link Here

(-)src/org/eclipse/mylar/internal/jira/MylarJiraPlugin.java (-1 / +1 lines)
34	public final static String ISSUE_URL_PREFIX = "/browse/";	34	public final static String ISSUE_URL_PREFIX = "/browse/";
35		35
36	/** Repository address + Filter Prefix + Issue key = the filter's web address */	36	/** Repository address + Filter Prefix + Issue key = the filter's web address */
37	public final static String FILTER_URL_PREFIX = "/secure/IssueNavigator.jspa?mode=hide&requestId=";	37	public final static String FILTER_URL_PREFIX = "/secure/IssueNavigator.jspa?mode=hide";
38		38
39	public MylarJiraPlugin() {	39	public MylarJiraPlugin() {
40	INSTANCE = this;	40	INSTANCE = this;




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;


	private final JiraServer server;

	private Text name;

	private ListViewer project;


		this.workingCopy = workingCopy;
		this.isNew = isNew;
		this.namedQuery = namedQuery;

		setDescription("Add search filters to define query.");
		setPageComplete(false);
	}

			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();
				}

			});
		}



	}


//	public boolean isPageComplete() {
//		if (namedQuery && name != null && name.getText().length() == 0) {
//			return false;

//			return true;
//		}
//	}

	void validatePage() {
		if (namedQuery && super.isPageComplete()) {
			setErrorMessage("Name is mandatory");
			setPageComplete(false);
			return;
		} else {
			setPageComplete(true);
			setErrorMessage(null);
		}


		/*
		 * (non-Javadoc)
		 *
		 * @see java.lang.Object#equals(java.lang.Object)
		 */
		public boolean equals(Object obj) {

			server.addLocalFilter(workingCopy);
		}

		String url = repository.getUrl();
		return new JiraCustomQuery(url, workingCopy, TasksUiPlugin.getTaskListManager().getTaskList(),
				TasksUiPlugin.getRepositoryManager().getRepository(MylarJiraPlugin.REPOSITORY_KIND, url));
	}
}




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());
	}

}

Return to bug 139312

Lines 12-22 Link Here

(-)src/org/eclipse/mylar/internal/jira/JiraTaskExternalizer.java (-44 / +33 lines)
12	package org.eclipse.mylar.internal.jira;	12	package org.eclipse.mylar.internal.jira;
13		13
14	import java.io.ByteArrayInputStream;	14	import java.io.ByteArrayInputStream;
15	import java.io.ByteArrayOutputStream;
16	import java.io.IOException;
17	import java.io.ObjectInputStream;	15	import java.io.ObjectInputStream;
18	import java.io.ObjectOutputStream;
19	import java.io.StringWriter;
20		16
21	import org.eclipse.mylar.context.core.MylarStatusHandler;	17	import org.eclipse.mylar.context.core.MylarStatusHandler;
22	import org.eclipse.mylar.tasks.core.AbstractQueryHit;	18	import org.eclipse.mylar.tasks.core.AbstractQueryHit;
Lines 28-36 Link Here
28	import org.eclipse.mylar.tasks.core.ITaskListExternalizer;	24	import org.eclipse.mylar.tasks.core.ITaskListExternalizer;
29	import org.eclipse.mylar.tasks.core.TaskExternalizationException;	25	import org.eclipse.mylar.tasks.core.TaskExternalizationException;
30	import org.eclipse.mylar.tasks.core.TaskList;	26	import org.eclipse.mylar.tasks.core.TaskList;
		27	import org.eclipse.mylar.tasks.core.TaskRepository;
31	import org.eclipse.mylar.tasks.ui.TasksUiPlugin;	28	import org.eclipse.mylar.tasks.ui.TasksUiPlugin;
32	import org.tigris.jira.core.model.NamedFilter;	29	import org.tigris.jira.core.model.NamedFilter;
33	import org.tigris.jira.core.model.filter.FilterDefinition;	30	import org.tigris.jira.core.model.filter.FilterDefinition;
		31	import org.tigris.jira.core.service.JiraServer;
34	import org.w3c.dom.Document;	32	import org.w3c.dom.Document;
35	import org.w3c.dom.Element;	33	import org.w3c.dom.Element;
36	import org.w3c.dom.Node;	34	import org.w3c.dom.Node;
Lines 60-69 Link Here
60		58
61	private static final String KEY_FILTER_ID = "FilterID";	59	private static final String KEY_FILTER_ID = "FilterID";
62		60
63	private static final String KEY_FILTER_DESCRIPTION = "FilterDesc";	61	// private static final String KEY_FILTER_DESCRIPTION = "FilterDesc";
64		62
65	private static final String KEY_FILTER_CUSTOM = "FilterCustom";	63	private static final String KEY_FILTER_CUSTOM = "FilterCustom";
66		64
		65	private static final String KEY_FILTER_CUSTOM_URL = "FilterCustomUrl";
		66
67	private static final String KEY_KEY = "Key";	67	private static final String KEY_KEY = "Key";
68		68
69	public boolean canReadQuery(Node node) {	69	public boolean canReadQuery(Node node) {
Lines 81-87 Link Here
81	node.setAttribute(KEY_KEY, ((JiraQueryHit) queryHit).getKey());	81	node.setAttribute(KEY_KEY, ((JiraQueryHit) queryHit).getKey());
82	return node;	82	return node;
83	}	83	}
84		84
85	public boolean canCreateElementFor(AbstractRepositoryQuery category) {	85	public boolean canCreateElementFor(AbstractRepositoryQuery category) {
86	return category instanceof JiraRepositoryQuery \|\| category instanceof JiraCustomQuery;	86	return category instanceof JiraRepositoryQuery \|\| category instanceof JiraCustomQuery;
87	}	87	}
Lines 94-120 Link Here
94	boolean hasCaughtException = false;	94	boolean hasCaughtException = false;
95	Element element = (Element) node;	95	Element element = (Element) node;
96		96
97	AbstractRepositoryQuery query;	97	String repositoryUrl = element.getAttribute(KEY_REPOSITORY_URL);
98	String custom = element.getAttribute(KEY_FILTER_CUSTOM);	98	String custom = element.getAttribute(KEY_FILTER_CUSTOM);
		99	String customUrl = element.getAttribute(KEY_FILTER_CUSTOM_URL);
		100	AbstractRepositoryQuery query;
99	if (custom != null && custom.length() > 0) {	101	if (custom != null && custom.length() > 0) {
		102	// TODO remove this at some point
100	FilterDefinition filter = decodeFilter(custom);	103	FilterDefinition filter = decodeFilter(custom);
101	if (filter == null) {	104	if (filter == null) {
102	throw new TaskExternalizationException("Failed to restore custom query "	105	throw new TaskExternalizationException("Failed to restore custom query "
103	+ element.getAttribute(KEY_FILTER_ID));	106	+ element.getAttribute(KEY_FILTER_ID));
104	}	107	}
105	filter.setName(element.getAttribute(KEY_FILTER_ID));	108	filter.setName(element.getAttribute(KEY_FILTER_ID));
106	filter.setDescription(element.getAttribute(KEY_FILTER_DESCRIPTION));	109	// filter.setDescription(element.getAttribute(KEY_FILTER_DESCRIPTION));
		110
		111	query = new JiraCustomQuery(repositoryUrl, filter,
		112	TasksUiPlugin.getTaskListManager().getTaskList(),
		113	TasksUiPlugin.getRepositoryManager().getRepository(MylarJiraPlugin.REPOSITORY_KIND, repositoryUrl));
		114	} else if (customUrl != null && customUrl.length() > 0) {
		115	TaskRepository repository = TasksUiPlugin.getRepositoryManager().getRepository(MylarJiraPlugin.REPOSITORY_KIND, repositoryUrl);
		116	JiraServer jiraServer = JiraServerFacade.getDefault().getJiraServer(repository);
		117	query = new JiraCustomQuery(element.getAttribute(KEY_FILTER_ID),
		118	customUrl, repositoryUrl, jiraServer, TasksUiPlugin.getTaskListManager().getTaskList(), repository);
107		119
108	query = new JiraCustomQuery(element.getAttribute(KEY_REPOSITORY_URL), filter, TasksUiPlugin
109	.getTaskListManager().getTaskList());
110	} else {	120	} else {
111	NamedFilter namedFilter = new NamedFilter();	121	NamedFilter namedFilter = new NamedFilter();
112	namedFilter.setId(element.getAttribute(KEY_FILTER_ID));	122	namedFilter.setId(element.getAttribute(KEY_FILTER_ID));
113	namedFilter.setName(element.getAttribute(KEY_FILTER_NAME));	123	namedFilter.setName(element.getAttribute(KEY_FILTER_NAME));
114	namedFilter.setDescription(element.getAttribute(KEY_FILTER_DESCRIPTION));	124	// namedFilter.setDescription(element.getAttribute(KEY_FILTER_DESCRIPTION));
115		125
116	query = new JiraRepositoryQuery(element.getAttribute(KEY_REPOSITORY_URL), namedFilter, TasksUiPlugin	126	query = new JiraRepositoryQuery(repositoryUrl, namedFilter,
117	.getTaskListManager().getTaskList());	127	TasksUiPlugin.getTaskListManager().getTaskList());
118	}	128	}
119		129
120	NodeList list = node.getChildNodes();	130	NodeList list = node.getChildNodes();
Lines 145-159 Link Here
145	NamedFilter filter = ((JiraRepositoryQuery) query).getNamedFilter();	155	NamedFilter filter = ((JiraRepositoryQuery) query).getNamedFilter();
146	node.setAttribute(KEY_FILTER_ID, filter.getId());	156	node.setAttribute(KEY_FILTER_ID, filter.getId());
147	node.setAttribute(KEY_FILTER_NAME, filter.getName());	157	node.setAttribute(KEY_FILTER_NAME, filter.getName());
148	node.setAttribute(KEY_FILTER_DESCRIPTION, filter.getDescription());	158	// node.setAttribute(KEY_FILTER_DESCRIPTION, filter.getDescription());
149	} else {	159	} else if(query instanceof JiraCustomQuery) {
150	FilterDefinition filter = ((JiraCustomQuery) query).getFilterDefinition();	160	JiraCustomQuery customQuery = (JiraCustomQuery) query;
		161	FilterDefinition filter = customQuery.getFilterDefinition();
151	node.setAttribute(KEY_FILTER_ID, filter.getName());	162	node.setAttribute(KEY_FILTER_ID, filter.getName());
152	node.setAttribute(KEY_FILTER_NAME, filter.getName());	163	node.setAttribute(KEY_FILTER_NAME, filter.getName());
153	node.setAttribute(KEY_FILTER_DESCRIPTION, filter.getDescription());	164	// node.setAttribute(KEY_FILTER_DESCRIPTION, filter.getDescription());
154		165	node.setAttribute(KEY_FILTER_CUSTOM_URL, customQuery.getUrl());
155	// XXX implement actual export
156	node.setAttribute(KEY_FILTER_CUSTOM, encodeFilter(filter));
157	}	166	}
158		167
159	for (AbstractQueryHit hit : query.getHits()) {	168	for (AbstractQueryHit hit : query.getHits()) {
Lines 162-168 Link Here
162	for (ITaskListExternalizer externalizer : super.getDelegateExternalizers()) {	171	for (ITaskListExternalizer externalizer : super.getDelegateExternalizers()) {
163	if (externalizer.canCreateElementFor(hit)) {	172	if (externalizer.canCreateElementFor(hit)) {
164	element = externalizer.createQueryHitElement(hit, doc, node);	173	element = externalizer.createQueryHitElement(hit, doc, node);
165	}	174	}
166	}	175	}
167	if (element == null) {	176	if (element == null) {
168	createQueryHitElement(hit, doc, node);	177	createQueryHitElement(hit, doc, node);
Lines 176-201 Link Here
176	return node;	185	return node;
177	}	186	}
178		187
179	private String encodeFilter(FilterDefinition filter) {
180	ByteArrayOutputStream bos = new ByteArrayOutputStream();
181	ObjectOutputStream oos;
182	try {
183	oos = new ObjectOutputStream(bos);
184	oos.writeObject(filter);
185	oos.flush();
186	} catch (IOException ex) {
187	return null;
188	}
189
190	StringWriter sw = new StringWriter();
191	byte[] bytes = bos.toByteArray();
192	for (int i = 0; i < bytes.length; i++) {
193	byte b = bytes[i];
194	sw.append((char) ('A' + (b >> 4))).append((char) ('A' + (b & 0xf)));
195	}
196	return sw.toString();
197	}
198
199	private FilterDefinition decodeFilter(String filter) {	188	private FilterDefinition decodeFilter(String filter) {
200	byte[] buff = new byte[filter.length() / 2];	189	byte[] buff = new byte[filter.length() / 2];
201	char[] chars = filter.toCharArray();	190	char[] chars = filter.toCharArray();
Lines 222-228 Link Here
222	Element node = super.createTaskElement(task, doc, parent);	211	Element node = super.createTaskElement(task, doc, parent);
223	node.setAttribute(KEY_KEY, ((JiraTask) task).getKey());	212	node.setAttribute(KEY_KEY, ((JiraTask) task).getKey());
224	return node;	213	return node;
225	}	214	}
226		215
227	@Override	216	@Override
228	public ITask readTask(Node node, TaskList taskList, AbstractTaskContainer category, ITask parent)	217	public ITask readTask(Node node, TaskList taskList, AbstractTaskContainer category, ITask parent)
Lines 275-286 Link Here
275	key = element.getAttribute(KEY_KEY);	264	key = element.getAttribute(KEY_KEY);
276	}	265	}
277		266
278	String issueId = AbstractRepositoryTask.getTaskId(handle);	267	String issueId = AbstractRepositoryTask.getTaskId(handle);
279		268
280	// TODO: implement completion	269	// TODO: implement completion
281	JiraQueryHit hit = new JiraQueryHit(taskList, "<description>", query.getRepositoryUrl(), issueId, key, false);	270	JiraQueryHit hit = new JiraQueryHit(taskList, "<description>", query.getRepositoryUrl(), issueId, key, false);
282	readQueryHitInfo(hit, taskList, query, element);	271	readQueryHitInfo(hit, taskList, query, element);
283	}	272	}
284		273
285	public String getQueryTagNameForElement(AbstractRepositoryQuery query) {	274	public String getQueryTagNameForElement(AbstractRepositoryQuery query) {
286	if (query instanceof JiraRepositoryQuery) {	275	if (query instanceof JiraRepositoryQuery) {

Lines 30-35 Link Here

(-)src/org/eclipse/mylar/internal/jira/ui/wizards/JiraQueryPage.java (-11 / +14 lines)
30	import org.eclipse.jface.viewers.Viewer;	30	import org.eclipse.jface.viewers.Viewer;
31	import org.eclipse.mylar.internal.jira.JiraCustomQuery;	31	import org.eclipse.mylar.internal.jira.JiraCustomQuery;
32	import org.eclipse.mylar.internal.jira.JiraServerFacade;	32	import org.eclipse.mylar.internal.jira.JiraServerFacade;
		33	import org.eclipse.mylar.internal.jira.MylarJiraPlugin;
33	import org.eclipse.mylar.internal.tasks.ui.search.AbstractRepositoryQueryPage;	34	import org.eclipse.mylar.internal.tasks.ui.search.AbstractRepositoryQueryPage;
34	import org.eclipse.mylar.internal.tasks.ui.views.DatePicker;	35	import org.eclipse.mylar.internal.tasks.ui.views.DatePicker;
35	import org.eclipse.mylar.tasks.core.AbstractRepositoryQuery;	36	import org.eclipse.mylar.tasks.core.AbstractRepositoryQuery;
Lines 138-144 Link Here
138		139
139	private final JiraServer server;	140	private final JiraServer server;
140		141
141	// private Text name;	142	private Text name;
142		143
143	private ListViewer project;	144	private ListViewer project;
144		145
Lines 199-205 Link Here
199	this.workingCopy = workingCopy;	200	this.workingCopy = workingCopy;
200	this.isNew = isNew;	201	this.isNew = isNew;
201	this.namedQuery = namedQuery;	202	this.namedQuery = namedQuery;
202		203
203	setDescription("Add search filters to define query.");	204	setDescription("Add search filters to define query.");
204	setPageComplete(false);	205	setPageComplete(false);
205	}	206	}
Lines 213-227 Link Here
213	final GridData gridData = new GridData();	214	final GridData gridData = new GridData();
214	lblName.setLayoutData(gridData);	215	lblName.setLayoutData(gridData);
215	lblName.setText("Name:");	216	lblName.setText("Name:");
216		217
217	title = new Text(c, SWT.BORDER);	218	title = new Text(c, SWT.BORDER);
218	title.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false, 2, 1));	219	title.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false, 2, 1));
219	title.addModifyListener(new ModifyListener() {	220	title.addModifyListener(new ModifyListener() {
220		221
221	public void modifyText(ModifyEvent e) {	222	public void modifyText(ModifyEvent e) {
222	validatePage();	223	validatePage();
223	}	224	}
224		225
225	});	226	});
226	}	227	}
227		228
Lines 865-871 Link Here
865		866
866	}	867	}
867		868
868		869
869	// public boolean isPageComplete() {	870	// public boolean isPageComplete() {
870	// if (namedQuery && name != null && name.getText().length() == 0) {	871	// if (namedQuery && name != null && name.getText().length() == 0) {
871	// return false;	872	// return false;
Lines 873-885 Link Here
873	// return true;	874	// return true;
874	// }	875	// }
875	// }	876	// }
876		877
877	void validatePage() {	878	void validatePage() {
878	if (namedQuery && super.isPageComplete()) {	879	if (namedQuery && super.isPageComplete()) {
879	setErrorMessage("Name is mandatory");	880	setErrorMessage("Name is mandatory");
880	setPageComplete(false);	881	setPageComplete(false);
881	return;	882	return;
882	} else {	883	} else {
883	setPageComplete(true);	884	setPageComplete(true);
884	setErrorMessage(null);	885	setErrorMessage(null);
885	}	886	}
Lines 1417-1423 Link Here
1417		1418
1418	/*	1419	/*
1419	* (non-Javadoc)	1420	* (non-Javadoc)
1420	*	1421	*
1421	* @see java.lang.Object#equals(java.lang.Object)	1422	* @see java.lang.Object#equals(java.lang.Object)
1422	*/	1423	*/
1423	public boolean equals(Object obj) {	1424	public boolean equals(Object obj) {
Lines 1441-1446 Link Here
1441	server.addLocalFilter(workingCopy);	1442	server.addLocalFilter(workingCopy);
1442	}	1443	}
1443		1444
1444	return new JiraCustomQuery(repository.getUrl(), workingCopy, TasksUiPlugin.getTaskListManager().getTaskList());	1445	String url = repository.getUrl();
		1446	return new JiraCustomQuery(url, workingCopy, TasksUiPlugin.getTaskListManager().getTaskList(),
		1447	TasksUiPlugin.getRepositoryManager().getRepository(MylarJiraPlugin.REPOSITORY_KIND, url));
1445	}	1448	}
1446	}	1449	}

Added Link Here

(-)src/org/eclipse/mylar/internal/jira/JiraCustomQueryTest.java (+221 lines)
1	package org.eclipse.mylar.internal.jira;
2
3	import java.lang.reflect.InvocationHandler;
4	import java.lang.reflect.Method;
5	import java.lang.reflect.Proxy;
6	import java.util.Date;
7
8	import org.eclipse.mylar.tasks.core.TaskList;
9	import org.eclipse.mylar.tasks.core.TaskRepository;
10	import org.tigris.jira.core.model.Component;
11	import org.tigris.jira.core.model.IssueType;
12	import org.tigris.jira.core.model.Project;
13	import org.tigris.jira.core.model.Resolution;
14	import org.tigris.jira.core.model.Status;
15	import org.tigris.jira.core.model.Version;
16	import org.tigris.jira.core.model.filter.ComponentFilter;
17	import org.tigris.jira.core.model.filter.ContentFilter;
18	import org.tigris.jira.core.model.filter.DateFilter;
19	import org.tigris.jira.core.model.filter.DateRangeFilter;
20	import org.tigris.jira.core.model.filter.FilterDefinition;
21	import org.tigris.jira.core.model.filter.IssueTypeFilter;
22	import org.tigris.jira.core.model.filter.ProjectFilter;
23	import org.tigris.jira.core.model.filter.ResolutionFilter;
24	import org.tigris.jira.core.model.filter.SpecificUserFilter;
25	import org.tigris.jira.core.model.filter.StatusFilter;
26	import org.tigris.jira.core.model.filter.UserFilter;
27	import org.tigris.jira.core.model.filter.VersionFilter;
28	import org.tigris.jira.core.service.JiraServer;
29
30	import junit.framework.TestCase;
31
32
33	public class JiraCustomQueryTest extends TestCase {
34
35	private Project project;
36
37	protected void setUp() throws Exception {
38	super.setUp();
39
40	Component[] comps = new Component[3];
41	comps[0] = new Component();
42	comps[0].setId("comp0");
43	comps[1] = new Component();
44	comps[1].setId("comp1");
45	comps[2] = new Component();
46	comps[2].setId("comp2");
47
48	Version[] vers = new Version[3];
49	vers[0] = new Version();
50	vers[0].setId("ver0");
51	vers[1] = new Version();
52	vers[1].setId("ver1");
53	vers[2] = new Version();
54	vers[2].setId("ver2");
55
56	project = new Project();
57	project.setId("000");
58	project.setComponents(comps);
59	project.setVersions(vers);
60	}
61
62	public void testJiraCustomQuery() {
63	String repositoryUrl = "http://host.net/";
64
65	Component[] components = new Component[2];
66	components[0] = new Component();
67	components[0].setId("comp0");
68	components[1] = new Component();
69	components[1].setId("comp1");
70
71	Version[] fixVersions = new Version[2];
72	fixVersions[0] = new Version();
73	fixVersions[0].setId("ver0");
74	fixVersions[1] = new Version();
75	fixVersions[1].setId("ver1");
76
77	Version[] repoVersions = new Version[2];
78	repoVersions[0] = new Version();
79	repoVersions[0].setId("ver1");
80	repoVersions[1] = new Version();
81	repoVersions[1].setId("ver2");
82
83	IssueType[] issueTypes = new IssueType[2];
84	issueTypes[0] = new IssueType();
85	issueTypes[0].setId("issue0");
86	issueTypes[1] = new IssueType();
87	issueTypes[1].setId("issue1");
88
89	Status[] statuses = new Status[2];
90	statuses[0] = new Status();
91	statuses[0].setId("status0");
92	statuses[1] = new Status();
93	statuses[1].setId("status1");
94
95	Resolution[] resolutions = new Resolution[2];
96	resolutions[0] = new Resolution();
97	resolutions[0].setId("resolution0");
98	resolutions[1] = new Resolution();
99	resolutions[1].setId("resolution1");
100
101	FilterDefinition filter = new FilterDefinition();
102	filter.setName("filter");
103	filter.setProjectFilter(new ProjectFilter(project));
104	filter.setComponentFilter(new ComponentFilter(components));
105	filter.setFixForVersionFilter(new VersionFilter(fixVersions));
106	filter.setReportedInVersionFilter(new VersionFilter(repoVersions));
107	filter.setIssueTypeFilter(new IssueTypeFilter(issueTypes));
108	filter.setStatusFilter(new StatusFilter(statuses));
109	filter.setResolutionFilter(new ResolutionFilter(resolutions));
110
111	filter.setContentFilter(new ContentFilter("query", true, true, true, true));
112
113	filter.setReportedByFilter(new SpecificUserFilter("reporter"));
114	filter.setAssignedToFilter(new SpecificUserFilter("assignee"));
115
116	filter.setCreatedDateFilter(new DateRangeFilter(new Date(10), new Date(12)));
117	filter.setUpdatedDateFilter(new DateRangeFilter(new Date(20), new Date(22)));
118	filter.setDueDateFilter(new DateRangeFilter(new Date(30), new Date(32)));
119
120	TaskList taskList = new TaskList();
121
122	TaskRepository taskRepository = new TaskRepository(MylarJiraPlugin.REPOSITORY_KIND, repositoryUrl);
123	taskRepository.setCharacterEncoding("ASCII");
124
125	JiraCustomQuery customQuery = new JiraCustomQuery(repositoryUrl, filter, taskList, taskRepository);
126
127	String queryUrl = customQuery.getUrl();
128
129	JiraServer jiraServer = (JiraServer) Proxy.newProxyInstance(getClass().getClassLoader(),
130	new Class[] {JiraServer.class},
131	new InvocationHandler() {
132	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
133	String name = method.getName();
134	if("getProjectById".equals(name)) {
135	return project;
136	} else if("getIssueTypeById".equals(name)) {
137	IssueType issueType = new IssueType();
138	issueType.setId((String) args[0]);
139	return issueType;
140	} else if("getStatusById".equals(name)) {
141	Status status = new Status();
142	status.setId((String) args[0]);
143	return status;
144	} else if("getResolutionById".equals(name)) {
145	Resolution resolution = new Resolution();
146	resolution.setId((String) args[0]);
147	return resolution;
148	}
149	return null;
150	}
151	});
152
153	JiraCustomQuery customQuery2 = new JiraCustomQuery("test", queryUrl, repositoryUrl, jiraServer, taskList, taskRepository);
154
155	FilterDefinition filter2 = customQuery2.getFilterDefinition();
156
157	ProjectFilter projectFilter2 = filter2.getProjectFilter();
158	assertEquals(project.getId(), projectFilter2.getProject().getId());
159
160	Component[] components2 = filter2.getComponentFilter().getComponents();
161	assertEquals(2, components2.length);
162	assertEquals(components[0].getId(), components2[0].getId());
163	assertEquals(components[1].getId(), components2[1].getId());
164
165	Version[] repoVersions2 = filter2.getReportedInVersionFilter().getVersions();
166	assertEquals(2, repoVersions2.length);
167	assertEquals(repoVersions[0].getId(), repoVersions2[0].getId());
168	assertEquals(repoVersions[1].getId(), repoVersions2[1].getId());
169
170	Version[] fixVersions2 = filter2.getFixForVersionFilter().getVersions();
171	assertEquals(2, fixVersions2.length);
172	assertEquals(fixVersions[0].getId(), fixVersions2[0].getId());
173	assertEquals(fixVersions[1].getId(), fixVersions2[1].getId());
174
175	IssueType[] issueTypes2 = filter2.getIssueTypeFilter().getIsueTypes();
176	assertEquals(2, issueTypes2.length);
177	assertEquals(issueTypes[0].getId(), issueTypes2[0].getId());
178	assertEquals(issueTypes[1].getId(), issueTypes2[1].getId());
179
180	Status[] statuses2 = filter2.getStatusFilter().getStatuses();
181	assertEquals(2, statuses2.length);
182	assertEquals(statuses[0].getId(), statuses2[0].getId());
183	assertEquals(statuses[1].getId(), statuses2[1].getId());
184
185	Resolution[] resolutions2 = filter2.getResolutionFilter().getResolutions();
186	assertEquals(2, resolutions2.length);
187	assertEquals(resolutions[0].getId(), resolutions2[0].getId());
188	assertEquals(resolutions[1].getId(), resolutions2[1].getId());
189
190	ContentFilter contentFilter2 = filter2.getContentFilter();
191	assertEquals("query", contentFilter2.getQueryString());
192	assertEquals(true, contentFilter2.isSearchingComments());
193	assertEquals(true, contentFilter2.isSearchingDescription());
194	assertEquals(true, contentFilter2.isSearchingEnvironment());
195	assertEquals(true, contentFilter2.isSearchingSummary());
196
197	UserFilter reportedByFilter2 = filter2.getReportedByFilter();
198	assertTrue(reportedByFilter2 instanceof SpecificUserFilter);
199	assertEquals("reporter", ((SpecificUserFilter) reportedByFilter2).getUser());
200
201	UserFilter assigneeFilter2 = filter2.getAssignedToFilter();
202	assertTrue(assigneeFilter2 instanceof SpecificUserFilter);
203	assertEquals("assignee", ((SpecificUserFilter) assigneeFilter2).getUser());
204
205	DateFilter createdDateFilter2 = filter.getCreatedDateFilter();
206	assertTrue(createdDateFilter2 instanceof DateRangeFilter);
207	assertEquals(10, ((DateRangeFilter) createdDateFilter2).getFromDate().getTime());
208	assertEquals(12, ((DateRangeFilter) createdDateFilter2).getToDate().getTime());
209
210	DateFilter updatedDateFilter2 = filter.getUpdatedDateFilter();
211	assertTrue(updatedDateFilter2 instanceof DateRangeFilter);
212	assertEquals(20, ((DateRangeFilter) updatedDateFilter2).getFromDate().getTime());
213	assertEquals(22, ((DateRangeFilter) updatedDateFilter2).getToDate().getTime());
214
215	DateFilter dueDateFilter2 = filter.getDueDateFilter();
216	assertTrue(dueDateFilter2 instanceof DateRangeFilter);
217	assertEquals(30, ((DateRangeFilter) dueDateFilter2).getFromDate().getTime());
218	assertEquals(32, ((DateRangeFilter) dueDateFilter2).getToDate().getTime());
219	}
220
221	}