Attachment #35968 for bug #129086

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




/*******************************************************************************
 * Copyright (c) 2006 - 2006 Mylar eclipse.org project and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Mylar project committers - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.internal.jira;

import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryQuery;
import org.tigris.jira.core.model.NamedFilter;

/**
 * A JiraFilter represents a query for issues from a Jira repository.
 * 
 * @author Mik Kersten
 * @author Wesley Coelho (initial integration patch)
 */
public class JiraFilter extends AbstractRepositoryQuery {

//	private static final String LABEL_REFRESH_JOB = "Refreshing Jira Filter(s)";

	private static final int MAX_HITS = 75;

	protected NamedFilter filter = null;

//	private boolean isRefreshing = false;

	public JiraFilter(String repositoryUrl, NamedFilter filter) {
		setMaxHits(MAX_HITS);
		this.filter = filter;
		super.repositoryUrl = repositoryUrl;
		setQueryUrl(repositoryUrl + MylarJiraPlugin.FILTER_URL_PREFIX + filter.getId());

		super.setDescription(filter.getName());
	}

	public NamedFilter getNamedFilter() {
		return filter;
	}

//	/**
//	 * TODO: refactor into common refresh mechanism.
//	 */
//	public void refreshHits() {
//		isRefreshing = true;
//		Job j = new Job(LABEL_REFRESH_JOB) {
//
//			@Override
//			protected IStatus run(final IProgressMonitor monitor) {
//				clearHits();
//				try {
//					TaskRepository repository = MylarTaskListPlugin.getRepositoryManager().getRepository(MylarJiraPlugin.JIRA_REPOSITORY_KIND, repositoryUrl);
//					JiraServerFacade.getDefault().getJiraServer(repository).executeNamedFilter(filter, new IssueCollector() {
//
//						public void done() {
//							isRefreshing = false;
//							Display.getDefault().asyncExec(new Runnable() {
//								public void run() {
//									if (TaskListView.getDefault() != null)
//										TaskListView.getDefault().refreshAndFocus();
//								}
//							});
//						}
//
//						public boolean isCancelled() {
//							return monitor.isCanceled();
//						}
//
//						public void collectIssue(Issue issue) {
//							int issueId = new Integer(issue.getId());
//							JiraFilterHit hit = new JiraFilterHit(issue, JiraFilter.this.getRepositoryUrl(), issueId);
//							addHit(hit);
//						}
//
//						public void start() {
//
//						}
//					});
//
//				} catch (Exception e) {
//					isRefreshing = false;
//					JiraServerFacade.handleConnectionException(e);
//					return Status.CANCEL_STATUS;
//				}
//
//				return Status.OK_STATUS;
//			}
//
//		};
//
//		j.schedule();
//
//	}

	public String getQueryUrl() {
		return super.getQueryUrl();
	}

	public String getPriority() {
		return "";
	}

	public String getDescription() {
		if (filter.getName() != null) {
			return filter.getName();
		} else {
			return super.getDescription();
		}
	}

	public void setDescription(String description) {
		filter.setDescription(description);
	}

	public boolean isLocal() {
		return false;
	}

//	/** True if the filter is currently downloading hits */
//	public boolean isRefreshing() {
//		return isRefreshing;
//	}

	public String getRepositoryKind() {
		return MylarJiraPlugin.JIRA_REPOSITORY_KIND;
	}

	public NamedFilter getFilter() {
		return filter;
	}

//	public void setRefreshing(boolean refreshing) {
//		this.isRefreshing = refreshing;
//	}

}

Lines 22-27 Link Here

(-)src/org/eclipse/mylar/internal/jira/JiraRepositoryConnector.java (-47 / +100 lines)
22	import org.eclipse.jface.wizard.IWizard;	22	import org.eclipse.jface.wizard.IWizard;
23	import org.eclipse.mylar.internal.core.util.MylarStatusHandler;	23	import org.eclipse.mylar.internal.core.util.MylarStatusHandler;
24	import org.eclipse.mylar.internal.jira.ui.wizards.AddExistingJiraTaskWizard;	24	import org.eclipse.mylar.internal.jira.ui.wizards.AddExistingJiraTaskWizard;
		25	import org.eclipse.mylar.internal.jira.ui.wizards.IssueFilterWizard;
25	import org.eclipse.mylar.internal.jira.ui.wizards.JiraRepositorySettingsPage;	26	import org.eclipse.mylar.internal.jira.ui.wizards.JiraRepositorySettingsPage;
26	import org.eclipse.mylar.internal.jira.ui.wizards.NewJiraQueryWizard;	27	import org.eclipse.mylar.internal.jira.ui.wizards.NewJiraQueryWizard;
27	import org.eclipse.mylar.internal.tasklist.ui.TaskListUiUtil;	28	import org.eclipse.mylar.internal.tasklist.ui.TaskListUiUtil;
Lines 84-90 Link Here
84	}	85	}
85		86
86	public IWizard getQueryWizard(TaskRepository repository) {	87	public IWizard getQueryWizard(TaskRepository repository) {
87	return new NewJiraQueryWizard(repository);	88	// return new NewJiraQueryWizard(repository);
		89	return new IssueFilterWizard(repository);
88	}	90	}
89		91
90	public IWizard getAddExistingTaskWizard(TaskRepository repository) {	92	public IWizard getAddExistingTaskWizard(TaskRepository repository) {
Lines 118-126 Link Here
118		120
119	@Override	121	@Override
120	public void openEditQueryDialog(AbstractRepositoryQuery query) {	122	public void openEditQueryDialog(AbstractRepositoryQuery query) {
121	JiraFilter filter = (JiraFilter) query;	123	if (query instanceof JiraNamedFilter) {
122	String title = "Filter: " + filter.getDescription();	124	JiraNamedFilter filter = (JiraNamedFilter) query;
123	TaskListUiUtil.openUrl(title, title, filter.getQueryUrl());	125	String title = "Filter: " + filter.getDescription();
		126	TaskListUiUtil.openUrl(title, title, filter.getQueryUrl());
		127	}
		128	// TODO support custom filters
124	}	129	}
125		130
126	// public void refreshFilters() {	131	// public void refreshFilters() {
Lines 162-212 Link Here
162		167
163	@Override	168	@Override
164	protected List<AbstractQueryHit> performQuery(AbstractRepositoryQuery repositoryQuery, final IProgressMonitor monitor, MultiStatus queryStatus) {	169	protected List<AbstractQueryHit> performQuery(AbstractRepositoryQuery repositoryQuery, final IProgressMonitor monitor, MultiStatus queryStatus) {
165	if (!(repositoryQuery instanceof JiraFilter)) {	170	// if (!(repositoryQuery instanceof JiraNamedFilter)) {
166	return Collections.emptyList();	171	// return Collections.emptyList();
167	}	172	// }
168	final JiraFilter jiraFilter = (JiraFilter)repositoryQuery;
169	final List<AbstractQueryHit> hits = new ArrayList<AbstractQueryHit>();	173	final List<AbstractQueryHit> hits = new ArrayList<AbstractQueryHit>();
170	// jiraFilter.setRefreshing(true);	174
171	try {	175	if (repositoryQuery instanceof JiraNamedFilter) {
172	TaskRepository repository = MylarTaskListPlugin.getRepositoryManager().getRepository(MylarJiraPlugin.JIRA_REPOSITORY_KIND, repositoryQuery.getRepositoryUrl());
173	JiraServerFacade.getDefault().getJiraServer(repository).executeNamedFilter(jiraFilter.getNamedFilter(), new IssueCollector() {
174
175	public void done() {
176	// jiraFilter.setRefreshing(false);
177	// Display.getDefault().asyncExec(new Runnable() {
178	// public void run() {
179	// if (TaskListView.getDefault() != null)
180	// TaskListView.getDefault().refreshAndFocus();
181	// }
182	// });
183	}
184
185	public boolean isCancelled() {
186	return monitor.isCanceled();
187	}
188
189	public void collectIssue(Issue issue) {
190	int issueId = new Integer(issue.getId());
191	JiraFilterHit hit = new JiraFilterHit(issue, jiraFilter.getRepositoryUrl(), issueId);
192	hits.add(hit);
193	// addHit(hit);
194	}
195
196	public void start() {
197
198	}
199	});
200
201	} catch (Exception e) {
202	// isRefreshing = false;
203	// jiraFilter.setRefreshing(false);
204	// JiraServerFacade.handleConnectionException(e);
205	queryStatus.add(new Status(IStatus.OK, MylarTaskListPlugin.PLUGIN_ID, IStatus.OK,
206	"Could not log in to server: " + repositoryQuery.getRepositoryUrl()
207	+ "\n\nCheck network connection.", e));
208	// queryStatus.add(Status.CANCEL_STATUS);
209		176
		177	final JiraNamedFilter jiraNamedFilter = (JiraNamedFilter)repositoryQuery;
		178	// jiraFilter.setRefreshing(true);
		179	try {
		180	TaskRepository repository = MylarTaskListPlugin.getRepositoryManager().getRepository(MylarJiraPlugin.JIRA_REPOSITORY_KIND, repositoryQuery.getRepositoryUrl());
		181	JiraServerFacade.getDefault().getJiraServer(repository).executeNamedFilter(jiraNamedFilter.getNamedFilter(), new IssueCollector() {
		182
		183	public void done() {
		184	// jiraFilter.setRefreshing(false);
		185	// Display.getDefault().asyncExec(new Runnable() {
		186	// public void run() {
		187	// if (TaskListView.getDefault() != null)
		188	// TaskListView.getDefault().refreshAndFocus();
		189	// }
		190	// });
		191	}
		192
		193	public boolean isCancelled() {
		194	return monitor.isCanceled();
		195	}
		196
		197	public void collectIssue(Issue issue) {
		198	int issueId = new Integer(issue.getId());
		199	JiraFilterHit hit = new JiraFilterHit(issue, jiraNamedFilter.getRepositoryUrl(), issueId);
		200	hits.add(hit);
		201	// addHit(hit);
		202	}
		203
		204	public void start() {
		205
		206	}
		207	});
		208
		209	} catch (Exception e) {
		210	// isRefreshing = false;
		211	// jiraFilter.setRefreshing(false);
		212	// JiraServerFacade.handleConnectionException(e);
		213	queryStatus.add(new Status(IStatus.OK, MylarTaskListPlugin.PLUGIN_ID, IStatus.OK,
		214	"Could not log in to server: " + repositoryQuery.getRepositoryUrl()
		215	+ "\n\nCheck network connection.", e));
		216	// queryStatus.add(Status.CANCEL_STATUS);
		217
		218	}
		219	} else if (repositoryQuery instanceof JiraCustomFilter) {
		220	final JiraCustomFilter jiraCustomFilter = (JiraCustomFilter)repositoryQuery;
		221
		222	// jiraFilter.setRefreshing(true);
		223	try {
		224	TaskRepository repository = MylarTaskListPlugin.getRepositoryManager().getRepository(MylarJiraPlugin.JIRA_REPOSITORY_KIND, repositoryQuery.getRepositoryUrl());
		225	JiraServerFacade.getDefault().getJiraServer(repository).findIssues(jiraCustomFilter.getFilter(), new IssueCollector() {
		226
		227	public void done() {
		228	// jiraFilter.setRefreshing(false);
		229	// Display.getDefault().asyncExec(new Runnable() {
		230	// public void run() {
		231	// if (TaskListView.getDefault() != null)
		232	// TaskListView.getDefault().refreshAndFocus();
		233	// }
		234	// });
		235	}
		236
		237	public boolean isCancelled() {
		238	return monitor.isCanceled();
		239	}
		240
241	public void collectIssue(Issue issue) {
242	int issueId = new Integer(issue.getId());
243	JiraFilterHit hit = new JiraFilterHit(issue, jiraCustomFilter.getRepositoryUrl(), issueId);
244	hits.add(hit);
245	// addHit(hit);
246	}
247
248	public void start() {
249
250	}
251	});
252
253	} catch (Exception e) {
254	// isRefreshing = false;
255	// jiraFilter.setRefreshing(false);
256	// JiraServerFacade.handleConnectionException(e);
257	queryStatus.add(new Status(IStatus.OK, MylarTaskListPlugin.PLUGIN_ID, IStatus.OK,
258	"Could not log in to server: " + repositoryQuery.getRepositoryUrl()
259	+ "\n\nCheck network connection.", e));
260	// queryStatus.add(Status.CANCEL_STATUS);
261
262	}
210	}	263	}
211	queryStatus.add(Status.OK_STATUS);	264	queryStatus.add(Status.OK_STATUS);
212	return hits;	265	return hits;




	private static final String KEY_FILTER_ID = "FilterID";

	private static final String KEY_FILTER_DESCRIPTION = "FilterDesc";
	
	private static final String KEY_QUERY_TYPE = "QueryType";

	public boolean canReadQuery(Node node) {
		return node.getNodeName().equals(KEY_JIRA_QUERY);
	}

	public boolean canCreateElementFor(AbstractRepositoryQuery category) {
		return category instanceof JiraNamedFilter || category instanceof JiraCustomFilter;
	}

	public boolean canCreateElementFor(ITask task) {
		return task instanceof JiraTask;
	}

	@Override
	public AbstractRepositoryQuery readQuery(Node node, TaskList taskList) throws TaskExternalizationException {
		boolean hasCaughtException = false;
		Element element = (Element) node;

		String queryType = element.getAttribute(KEY_QUERY_TYPE);
		if ("Custom".equals(queryType)) {
			return null;
		} 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));
	
			AbstractRepositoryQuery query = new JiraNamedFilter(element.getAttribute(KEY_REPOSITORY_URL), namedFilter);
		
			NodeList list = node.getChildNodes();
			for (int i = 0; i < list.getLength(); i++) {
				Node child = list.item(i);
				try {
					readQueryHit(child, taskList, query);
				} catch (TaskExternalizationException e) {
					hasCaughtException = true;
				}
			}
			if (hasCaughtException) {
				throw new TaskExternalizationException("Failed to load all hits");
			} else {
				return query;
			}
		}
		
			throw new TaskExternalizationException("Failed to load all hits");
		} else {
			return query;
		}
	}

	public Element createQueryElement(AbstractRepositoryQuery query, Document doc, Element parent) {
		String queryTagName = getQueryTagNameForElement(query);
		Element node = doc.createElement(queryTagName);

		if (query instanceof JiraNamedFilter) {
			NamedFilter filter = ((JiraNamedFilter) query).getNamedFilter();
			node.setAttribute(KEY_NAME, query.getDescription());
			node.setAttribute(KEY_QUERY_MAX_HITS, query.getMaxHits() + "");
			node.setAttribute(KEY_QUERY_STRING, query.getQueryUrl());
			node.setAttribute(KEY_REPOSITORY_URL, query.getRepositoryUrl());
	
			node.setAttribute(KEY_FILTER_ID, filter.getId());
			node.setAttribute(KEY_FILTER_NAME, filter.getName());
			node.setAttribute(KEY_FILTER_DESCRIPTION, filter.getDescription());
	
			for (AbstractQueryHit hit : query.getHits()) {
				try {
					Element element = null;
					for (ITaskListExternalizer externalizer : super.getDelegateExternalizers()) {
						if (externalizer.canCreateElementFor(hit))
							element = externalizer.createQueryHitElement(hit, doc, node);
					}
					if (element == null)
						createQueryHitElement(hit, doc, node);
				} catch (Exception e) {
					MylarStatusHandler.log(e, e.getMessage());
				}
				if (element == null)
					createQueryHitElement(hit, doc, node);
			} catch (Exception e) {
				MylarStatusHandler.log(e, e.getMessage());
			}
			parent.appendChild(node);
			return node;
		} else {
			return node;
		}
		parent.appendChild(node);
		return node;
	}
		
	@Override

	}

	public String getQueryTagNameForElement(AbstractRepositoryQuery query) {
		if (query instanceof JiraNamedFilter || query instanceof JiraCustomFilter) {
			return KEY_JIRA_QUERY;
		}
		return "";

Lines 1-5 Link Here

(-).settings/org.eclipse.jdt.ui.prefs (-2 / +2 lines)
1	#Thu Feb 09 16:45:35 PST 2006	1	#Sat Feb 18 09:21:28 EST 2006
2	eclipse.preferences.version=1	2	eclipse.preferences.version=1
3	formatter_profile=_Mylar based on Eclipse [built-in]	3	formatter_profile=_Mylar based on Eclipse [built-in]
4	formatter_settings_version=9	4	formatter_settings_version=10
5	internal.default.compliance=default	5	internal.default.compliance=default

Lines 12-18 Link Here

(-)src/org/eclipse/mylar/internal/jira/ui/wizards/NewJiraQueryWizard.java (-2 / +2 lines)
12	package org.eclipse.mylar.internal.jira.ui.wizards;	12	package org.eclipse.mylar.internal.jira.ui.wizards;
13		13
14	import org.eclipse.jface.wizard.Wizard;	14	import org.eclipse.jface.wizard.Wizard;
15	import org.eclipse.mylar.internal.jira.JiraFilter;	15	import org.eclipse.mylar.internal.jira.JiraNamedFilter;
16	import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryConnector;	16	import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryConnector;
17	import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;	17	import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;
18	import org.eclipse.mylar.provisional.tasklist.TaskRepository;	18	import org.eclipse.mylar.provisional.tasklist.TaskRepository;
Lines 48-54 Link Here
48	NamedFilter namedFilter = queryPage.getSelectedFilter();	48	NamedFilter namedFilter = queryPage.getSelectedFilter();
49		49
50	if (namedFilter != null) {	50	if (namedFilter != null) {
51	JiraFilter filter = new JiraFilter(repository.getUrl().toExternalForm(), namedFilter);	51	JiraNamedFilter filter = new JiraNamedFilter(repository.getUrl().toExternalForm(), namedFilter);
52	MylarTaskListPlugin.getTaskListManager().addQuery(filter);	52	MylarTaskListPlugin.getTaskListManager().addQuery(filter);
53	AbstractRepositoryConnector connector = MylarTaskListPlugin.getRepositoryManager().getRepositoryConnector(repository.getKind());	53	AbstractRepositoryConnector connector = MylarTaskListPlugin.getRepositoryManager().getRepositoryConnector(repository.getKind());
54	if (connector != null) {	54	if (connector != null) {




/*******************************************************************************
 * Copyright (c) 2006 - 2006 Mylar eclipse.org project and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Mylar project committers - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.internal.jira;

import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryQuery;
import org.tigris.jira.core.model.NamedFilter;
import org.tigris.jira.core.model.filter.FilterDefinition;

/**
 * A JiraFilter represents a query for issues from a Jira repository.
 * 
 * @author Mik Kersten
 * @author Wesley Coelho (initial integration patch)
 */
public class JiraCustomFilter extends AbstractRepositoryQuery {

//	private static final String LABEL_REFRESH_JOB = "Refreshing Jira Filter(s)";

	private static final int MAX_HITS = 75;

	protected FilterDefinition filter = null;

//	private boolean isRefreshing = false;

	public JiraCustomFilter(String repositoryUrl, FilterDefinition filter) {
		setMaxHits(MAX_HITS);
		this.filter = filter;
		super.repositoryUrl = repositoryUrl;
		setQueryUrl(repositoryUrl + MylarJiraPlugin.FILTER_URL_PREFIX + filter.getName());

		super.setDescription(filter.getName());
	}

	public FilterDefinition getFilter() {
		return filter;
	}

//	/**
//	 * TODO: refactor into common refresh mechanism.
//	 */
//	public void refreshHits() {
//		isRefreshing = true;
//		Job j = new Job(LABEL_REFRESH_JOB) {
//
//			@Override
//			protected IStatus run(final IProgressMonitor monitor) {
//				clearHits();
//				try {
//					TaskRepository repository = MylarTaskListPlugin.getRepositoryManager().getRepository(MylarJiraPlugin.JIRA_REPOSITORY_KIND, repositoryUrl);
//					JiraServerFacade.getDefault().getJiraServer(repository).executeNamedFilter(filter, new IssueCollector() {
//
//						public void done() {
//							isRefreshing = false;
//							Display.getDefault().asyncExec(new Runnable() {
//								public void run() {
//									if (TaskListView.getDefault() != null)
//										TaskListView.getDefault().refreshAndFocus();
//								}
//							});
//						}
//
//						public boolean isCancelled() {
//							return monitor.isCanceled();
//						}
//
//						public void collectIssue(Issue issue) {
//							int issueId = new Integer(issue.getId());
//							JiraFilterHit hit = new JiraFilterHit(issue, JiraFilter.this.getRepositoryUrl(), issueId);
//							addHit(hit);
//						}
//
//						public void start() {
//
//						}
//					});
//
//				} catch (Exception e) {
//					isRefreshing = false;
//					JiraServerFacade.handleConnectionException(e);
//					return Status.CANCEL_STATUS;
//				}
//
//				return Status.OK_STATUS;
//			}
//
//		};
//
//		j.schedule();
//
//	}

	public String getQueryUrl() {
		return super.getQueryUrl();
	}

	public String getPriority() {
		return "";
	}

	public String getDescription() {
		if (filter.getName() != null) {
			return filter.getName();
		} else {
			return super.getDescription();
		}
	}

	public void setDescription(String description) {
		filter.setDescription(description);
	}

	public boolean isLocal() {
		return false;
	}

//	/** True if the filter is currently downloading hits */
//	public boolean isRefreshing() {
//		return isRefreshing;
//	}

	public String getRepositoryKind() {
		return MylarJiraPlugin.JIRA_REPOSITORY_KIND;
	}

//	public void setRefreshing(boolean refreshing) {
//		this.isRefreshing = refreshing;
//	}

}




/*******************************************************************************
 * Copyright (c) 2005 Jira Dashboard project.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Brock Janiczak - initial API and implementation
 *******************************************************************************/
package org.eclipse.mylar.internal.jira.ui.wizards;

import org.eclipse.jface.wizard.Wizard;
import org.eclipse.mylar.internal.jira.JiraCustomFilter;
import org.eclipse.mylar.internal.jira.JiraNamedFilter;
import org.eclipse.mylar.internal.jira.JiraServerFacade;
import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryConnector;
import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;
import org.eclipse.mylar.provisional.tasklist.TaskRepository;
import org.tigris.jira.core.model.filter.FilterDefinition;
import org.tigris.jira.core.service.JiraServer;


// TODO this should be two different wizards (create and update)
public class IssueFilterWizard extends Wizard {

	private FilterSummaryPage filterSummaryPage;
	private final JiraServer server;
	private FilterDefinition workingCopy;
	private final boolean isAdd;
	private FilterDefinition filter;
	private IssueAttributesPage issueAttributesPage;
	private final TaskRepository repository;
	
	public IssueFilterWizard(TaskRepository repository) {
		this.repository = repository;
		// TODO this is most likely not a cool thing to be doing
		this.server = JiraServerFacade.getDefault().getJiraServer(repository);
		workingCopy = new FilterDefinition();
		this.setWindowTitle("Create Issue Filter");
		isAdd = true;
	}
	
	public IssueFilterWizard(TaskRepository repository, FilterDefinition filter) {
		this.repository = repository;
		// TODO this is most likely not a cool thing to be doing
		this.server = JiraServerFacade.getDefault().getJiraServer(repository);
		this.filter = filter;
		workingCopy = new FilterDefinition(filter);
		this.setWindowTitle("Create Issue Filter");
		isAdd = false;
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.jface.wizard.Wizard#addPages()
	 */
	public void addPages() {
		filterSummaryPage = new FilterSummaryPage("summaryPage", "Filter Summary", null, server, workingCopy, isAdd);
		issueAttributesPage = new IssueAttributesPage("issueAttributes", "Issue Attributes", null, server, workingCopy, isAdd);
		
		addPage(filterSummaryPage);
		addPage(issueAttributesPage);
		
	}
	
	public boolean performFinish() {
		if (isAdd) {
			filterSummaryPage.applyChanges();
			issueAttributesPage.applyChanges();
			server.addLocalFilter(workingCopy);
			
			JiraCustomFilter customFilter = new JiraCustomFilter(repository.getUrl().toExternalForm(), workingCopy);
			MylarTaskListPlugin.getTaskListManager().addQuery(customFilter);
			AbstractRepositoryConnector connector = MylarTaskListPlugin.getRepositoryManager().getRepositoryConnector(repository.getKind());
			if (connector != null) {
				connector.synchronize(customFilter, null);
			}
//				filter.refreshHits();
		} else {
			filterSummaryPage.applyChanges();
			issueAttributesPage.applyChanges();
			filter.copyAttributes(workingCopy);
			
			JiraCustomFilter customFilter = new JiraCustomFilter(repository.getUrl().toExternalForm(), workingCopy);
			MylarTaskListPlugin.getTaskListManager().addQuery(customFilter);
			AbstractRepositoryConnector connector = MylarTaskListPlugin.getRepositoryManager().getRepositoryConnector(repository.getKind());
			if (connector != null) {
				connector.synchronize(customFilter, null);
			}
//				filter.refreshHits();
		}
		return true;
	}

}




/*******************************************************************************
 * Copyright (c) 2005 Jira Dashboard project.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Brock Janiczak - initial API and implementation
 *******************************************************************************/
package org.eclipse.mylar.internal.jira.ui.wizards;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.ComboViewer;
import org.eclipse.jface.viewers.IColorProvider;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.ListViewer;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;
import org.tigris.jira.core.model.Component;
import org.tigris.jira.core.model.Project;
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.FilterDefinition;
import org.tigris.jira.core.model.filter.ProjectFilter;
import org.tigris.jira.core.model.filter.VersionFilter;
import org.tigris.jira.core.service.JiraServer;

public class FilterSummaryPage extends WizardPage {
	private final Placeholder ANY_FIX_VERSION = new Placeholder("Any");
	private final Placeholder NO_FIX_VERSION = new Placeholder("No Fix Version");
	
	private final Placeholder ANY_REPORTED_VERSION = new Placeholder("Any");
	private final Placeholder NO_REPORTED_VERSION = new Placeholder("No Version");
	private final Placeholder UNRELEASED_VERSION = new Placeholder("Unreleased Versions");
	private final Placeholder RELEASED_VERSION = new Placeholder("Released Versions");
	
	private final Placeholder ANY_COMPONENT = new Placeholder("Any");
	private final Placeholder NO_COMPONENT = new Placeholder("No Component");
	
	private final JiraServer server;
	private ListViewer reportedIn;
	private ListViewer components;
	private ListViewer fixFor;
	
	private final FilterDefinition workingCopy;
	private Text name;
	private Text description;
	private ComboViewer project;
	private Text queryString;
	private Button searchSummary;
	private Button searchDescription;
	private Button searchComments;
	private Button searchEnvironment;
	private final boolean isNew;
	
	/**
	 * @param pageName
	 * @param title
	 * @param titleImage
	 */
	protected FilterSummaryPage(String pageName, String title, ImageDescriptor titleImage, JiraServer server, FilterDefinition workingCopy, boolean isNew) {
		super(pageName, title, titleImage);
		this.server = server;
		this.workingCopy = workingCopy;
		this.isNew = isNew;
	}

	public void createControl(Composite parent) {
		GridData gd;
		Composite c = new Composite(parent, SWT.NONE);
		c.setLayout(new GridLayout(3, false));
		
		Label lblName = new Label(c, SWT.NONE);
		lblName.setText("Name:");
		
		name = new Text(c, SWT.BORDER);
		name.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false, 2, 1));
		name.addFocusListener(new FocusAdapter() {
			
			public void focusLost(FocusEvent e) {
				validatePage();
			}
		
		});
		
		if (!isNew) {
			name.setEnabled(false);
		}
		
		Label lblDescription = new Label(c, SWT.NONE);
		lblDescription.setText("Description:");
		lblDescription.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false));
		
		description = new Text(c, SWT.BORDER | SWT.MULTI | SWT.WRAP | SWT.V_SCROLL);
		gd = new GridData(SWT.FILL, SWT.FILL, true, false, 2, 1);
		gd.heightHint = 40;
		description.setLayoutData(gd);
		description.addFocusListener(new FocusAdapter() {
			
			public void focusLost(FocusEvent e) {
				validatePage();
			}
		
		});
		
		Label lblProject = new Label(c, SWT.NONE);
		lblProject.setText("Project:");
		
		project = new ComboViewer(c, SWT.READ_ONLY);
		project.getCombo().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false, 2, 1));
		project.setContentProvider(new IStructuredContentProvider() {
		
			public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
			}
		
			public void dispose() {
			}
		
			public Object[] getElements(Object inputElement) {
				JiraServer server = (JiraServer) inputElement;
				Object[] elements = new Object[server.getProjects().length + 1];
				elements[0] = new Placeholder("All Projects");
				System.arraycopy(server.getProjects(), 0, elements, 1, server.getProjects().length);
				
				return elements;
			}
		
		});
		
		project.setLabelProvider(new LabelProvider() {
		
			public String getText(Object element) {
				if (element instanceof Placeholder) {
					return ((Placeholder)element).getText();
				}
				
				return ((Project)element).getName();
			}
		
		});
		
		project.setInput(server);
		project.addSelectionChangedListener(new ISelectionChangedListener() {
		
			public void selectionChanged(SelectionChangedEvent event) {
				IStructuredSelection selection = ((IStructuredSelection)event.getSelection());
				Project selectedProject = null;
				if (!selection.isEmpty() && !(selection.getFirstElement() instanceof Placeholder)) {
					selectedProject = (Project)selection.getFirstElement();
				}
				
				updateCurrentProject(selectedProject);
				validatePage();
			}
		
		});
		
		Label lblFixFor = new Label(c, SWT.NONE);
		lblFixFor.setText("Fix For:");
		lblFixFor.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false));
		
		fixFor = new ListViewer(c, SWT.MULTI | SWT.BORDER | SWT.V_SCROLL);
		gd = new GridData(SWT.FILL, SWT.FILL, true, true, 2, 1);
		gd.heightHint = 40;
		fixFor.getControl().setLayoutData(gd);
		
		fixFor.setContentProvider(new IStructuredContentProvider() {
			private Project project;
			public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
				project = (Project)newInput;
			}
		
			public void dispose() {
			}
		
			public Object[] getElements(Object inputElement) {
				if (project != null) {
					Version[] versions = project.getVersions();
					Version[] releasedVersions = project.getReleasedVersions();
					Version[] unreleasedVersions = project.getUnreleasedVersions();
					
					Object[] elements = new Object[versions.length + 4];
					elements[0] = ANY_FIX_VERSION;
					elements[1] = NO_FIX_VERSION;
					elements[2] = RELEASED_VERSION;
					System.arraycopy(releasedVersions, 0, elements, 3, releasedVersions.length);
					
					elements[releasedVersions.length + 3] = UNRELEASED_VERSION;
					
					System.arraycopy(unreleasedVersions, 0, elements, releasedVersions.length + 4, unreleasedVersions.length);
					return elements;
				} else {
					return new Object[] {ANY_REPORTED_VERSION};
				}
			}
		
		});
		fixFor.setLabelProvider(new VersionLabelProvider());
		fixFor.setInput(null);

		Label lblComponent = new Label(c, SWT.NONE);
		lblComponent.setText("In Components:");
		lblComponent.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false));

		components = new ListViewer(c, SWT.MULTI | SWT.BORDER | SWT.V_SCROLL);
		gd = new GridData(SWT.FILL, SWT.FILL, true, true, 2, 1);
		gd.heightHint = 40;
		components.getControl().setLayoutData(gd);
		
		components.setContentProvider(new IStructuredContentProvider() {
			private Project project;
			public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
				project = (Project)newInput;
			}
		
			public void dispose() {
			}
		
			public Object[] getElements(Object inputElement) {
				if (project != null) {
					Component[] components = project.getComponents();
					
					Object[] elements = new Object[components.length + 2];
					elements[0] = ANY_COMPONENT;
					elements[1] = NO_COMPONENT;
					System.arraycopy(components, 0, elements, 2, components.length);
					return elements;
				} else {
					return new Object[] {ANY_COMPONENT};
				}
				
			}
		
		});
		components.setLabelProvider(new ComponentLabelProvider());
		components.setInput(null);
		
		Label lblReportedIn = new Label(c, SWT.NONE);
		lblReportedIn.setText("Reported In:");
		lblReportedIn.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false));
		
		reportedIn = new ListViewer(c, SWT.MULTI | SWT.BORDER | SWT.V_SCROLL);
		gd = new GridData(SWT.FILL, SWT.FILL, true, true, 2, 1);
		gd.heightHint = 40;
		reportedIn.getControl().setLayoutData(gd);
		
		reportedIn.setContentProvider(new IStructuredContentProvider() {
			private Project project;
			public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
				project = (Project)newInput;
			}
		
			public void dispose() {
			}
		
			public Object[] getElements(Object inputElement) {
				if (project != null) {
					Version[] versions = project.getVersions();
					Version[] releasedVersions = project.getReleasedVersions();
					Version[] unreleasedVersions = project.getUnreleasedVersions();
					
					Object[] elements = new Object[versions.length + 4];
					elements[0] = ANY_REPORTED_VERSION;
					elements[1] = NO_REPORTED_VERSION;
					elements[2] = RELEASED_VERSION;
					System.arraycopy(releasedVersions, 0, elements, 3, releasedVersions.length);
					
					elements[releasedVersions.length + 3] = UNRELEASED_VERSION;
					
					System.arraycopy(unreleasedVersions, 0, elements, releasedVersions.length + 4, unreleasedVersions.length);
					return elements;
				} else {
					return new Object[] {ANY_REPORTED_VERSION};
				}
				
			}
		
		});
		reportedIn.setLabelProvider(new VersionLabelProvider());
		reportedIn.setInput(null);
		
		Label lblQuery = new Label(c, SWT.NONE);
		lblQuery.setText("Query:");
		queryString = new Text(c, SWT.BORDER);
		queryString.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false, 2, 1));
		// TODO put content assist here and a label describing what is available
		
		queryString.addFocusListener(new FocusAdapter() {
			
			public void focusLost(FocusEvent e) {
				validatePage();
			}
		
		});
		
		Label lblFields = new Label(c, SWT.NONE);
		lblFields.setText("Fields:");
		lblFields.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false, 1, 2));
		
		searchSummary = new Button(c, SWT.CHECK);
		searchSummary.setText("Summary");
		searchSummary.addSelectionListener(new SelectionAdapter() {
		
			public void widgetSelected(SelectionEvent e) {
				validatePage();
			}
		
		});
		
		searchDescription = new Button(c, SWT.CHECK);
		searchDescription.setText("Description");
		searchDescription.addSelectionListener(new SelectionAdapter() {
		
			public void widgetSelected(SelectionEvent e) {
				validatePage();
			}
		
		});
	
		searchComments = new Button(c, SWT.CHECK);
		searchComments.setText("Comments");
		searchComments.addSelectionListener(new SelectionAdapter() {
		
			public void widgetSelected(SelectionEvent e) {
				validatePage();
			}
		
		});
		
		searchEnvironment = new Button(c, SWT.CHECK);
		searchEnvironment.setText("Environment");
		searchEnvironment.addSelectionListener(new SelectionAdapter() {
		
			public void widgetSelected(SelectionEvent e) {
				validatePage();
			}
		
		});

		// Need to turn off validation here
		if (isNew) {
			loadFromDefaults();
		} else {
			loadFromWorkingCopy();
		}
		
		setControl(c);
	}
	
	private void updateCurrentProject(Project project) {
		this.fixFor.setInput(project);
		this.components.setInput(project);
		this.reportedIn.setInput(project);
		
	}
	
	private void validatePage() {
		if (name.getText().length() == 0) {
			setErrorMessage("Name is mandatory");
			setPageComplete(false);
			return;
		}
		
		setErrorMessage(null);
		setPageComplete(true);
	}
	
	private void loadFromDefaults() {
		project.setSelection(new StructuredSelection(new Placeholder("All Projects")));
		searchSummary.setSelection(true);
		searchDescription.setSelection(true);
	}
	
	private void loadFromWorkingCopy() {
		if (workingCopy.getName() != null) {
			name.setText(workingCopy.getName());
		}
		
		if (workingCopy.getDescription() != null) {
			description.setText(workingCopy.getDescription());
		}
		
		if (workingCopy.getProjectFilter() != null) {
			project.setSelection(new StructuredSelection(workingCopy.getProjectFilter().getProject()));
		} else {
			project.setSelection(new StructuredSelection(new Placeholder("All Projects")));
		}
		
		if (workingCopy.getFixForVersionFilter() != null) {
			if (workingCopy.getFixForVersionFilter().hasNoVersion()) {
				fixFor.setSelection(new StructuredSelection(new Object[] {NO_FIX_VERSION}));
			} else if (workingCopy.getFixForVersionFilter().isReleasedVersions() && workingCopy.getFixForVersionFilter().isUnreleasedVersions()) {
				fixFor.setSelection(new StructuredSelection(new Object[] {RELEASED_VERSION, UNRELEASED_VERSION}));
			} else if (workingCopy.getFixForVersionFilter().isReleasedVersions()) {
				fixFor.setSelection(new StructuredSelection(RELEASED_VERSION));
			} else if (workingCopy.getFixForVersionFilter().isUnreleasedVersions()) {
				fixFor.setSelection(new StructuredSelection(UNRELEASED_VERSION));
			} else {
				fixFor.setSelection(new StructuredSelection(workingCopy.getFixForVersionFilter().getVersions()));
			}
		} else {
			fixFor.setSelection(new StructuredSelection(ANY_FIX_VERSION));
		}
		
		if (workingCopy.getReportedInVersionFilter() != null) {
			if (workingCopy.getReportedInVersionFilter().hasNoVersion()) {
				reportedIn.setSelection(new StructuredSelection(new Object[] {NO_REPORTED_VERSION}));
			} else if (workingCopy.getReportedInVersionFilter().isReleasedVersions() && workingCopy.getReportedInVersionFilter().isUnreleasedVersions()) {
				reportedIn.setSelection(new StructuredSelection(new Object[] {RELEASED_VERSION, UNRELEASED_VERSION}));
			} else if (workingCopy.getReportedInVersionFilter().isReleasedVersions()) {
				reportedIn.setSelection(new StructuredSelection(RELEASED_VERSION));
			} else if (workingCopy.getReportedInVersionFilter().isUnreleasedVersions()) {
				reportedIn.setSelection(new StructuredSelection(UNRELEASED_VERSION));
			} else {
				reportedIn.setSelection(new StructuredSelection(workingCopy.getReportedInVersionFilter().getVersions()));
			}
		} else {
			reportedIn.setSelection(new StructuredSelection(ANY_REPORTED_VERSION));
		}
		
		if (workingCopy.getContentFilter() != null) {
			this.queryString.setText(workingCopy.getContentFilter().getQueryString());
			this.searchComments.setSelection(workingCopy.getContentFilter().isSearchingComments());
			this.searchDescription.setSelection(workingCopy.getContentFilter().isSearchingDescription());
			this.searchEnvironment.setSelection(workingCopy.getContentFilter().isSearchingEnvironment());
			this.searchSummary.setSelection(workingCopy.getContentFilter().isSearchingSummary());
		}
		
		if (workingCopy.getComponentFilter() != null) {
			if (workingCopy.getComponentFilter().hasNoComponent()) {
				components.setSelection(new StructuredSelection(NO_COMPONENT));
			} else {
				components.setSelection(new StructuredSelection(workingCopy.getComponentFilter().getComponents()));
			}
		} else {
			components.setSelection(new StructuredSelection(ANY_COMPONENT));
		}
	}
	
	/* default */ void applyChanges() {
		workingCopy.setName(this.name.getText());
		workingCopy.setDescription(this.description.getText());
		if (this.queryString.getText().length() > 0 || this.searchSummary.getSelection() || this.searchDescription.getSelection() || this.searchEnvironment.getSelection() || this.searchComments.getSelection()) { 
			workingCopy.setContentFilter(new ContentFilter(this.queryString.getText(), this.searchSummary.getSelection(), this.searchDescription.getSelection(), this.searchEnvironment.getSelection(), this.searchComments.getSelection()));
		} else {
			workingCopy.setContentFilter(null);
		}
		
		IStructuredSelection projectSelection = (IStructuredSelection)this.project.getSelection();
		if (!projectSelection.isEmpty() && projectSelection.getFirstElement() instanceof Project) {
			workingCopy.setProjectFilter(new ProjectFilter((Project) projectSelection.getFirstElement()));
		} else {
			workingCopy.setProjectFilter(null);
		}
		
		IStructuredSelection reportedInSelection = (IStructuredSelection)reportedIn.getSelection();
		if (reportedInSelection.isEmpty()) {
			workingCopy.setReportedInVersionFilter(null);
		} else {
			boolean selectionContainsReleased = false;
			boolean selectionContainsUnreleased = false;
			boolean selectionContainsAll = false;
			boolean selectionContainsNone = false;
			
			List selectedVersions = new ArrayList();
			
			for (Iterator i = reportedInSelection.iterator(); i.hasNext(); ) {
				Object selection = i.next();
				if (ANY_REPORTED_VERSION.equals(selection)) {
					selectionContainsAll = true;
				} else if (NO_REPORTED_VERSION.equals(selection)) {
					selectionContainsNone = true;
				} else if (RELEASED_VERSION.equals(selection)) {
					selectionContainsReleased = true;
				} else if (UNRELEASED_VERSION.equals(selection)) {
					selectionContainsUnreleased = true;
				} else if (selection instanceof Version) {
					selectedVersions.add(selection);
				}
			}
			
			if (selectionContainsAll) {
				workingCopy.setReportedInVersionFilter(null);
			} else if (selectionContainsNone) {
				workingCopy.setReportedInVersionFilter(new VersionFilter(new Version[0]));
			} else if (selectionContainsReleased || selectionContainsUnreleased) {
				workingCopy.setReportedInVersionFilter(new VersionFilter(selectionContainsReleased, selectionContainsUnreleased));
			} else if (selectedVersions.size() > 0) {
				workingCopy.setReportedInVersionFilter(new VersionFilter((Version[]) selectedVersions.toArray(new Version[selectedVersions.size()])));
			} else {
				workingCopy.setReportedInVersionFilter(null);
			}
		}
		
		IStructuredSelection fixForSelection = (IStructuredSelection)fixFor.getSelection();
		if (fixForSelection.isEmpty()) {
			workingCopy.setFixForVersionFilter(null);
		} else {
			boolean selectionContainsReleased = false;
			boolean selectionContainsUnreleased = false;
			boolean selectionContainsAll = false;
			boolean selectionContainsNone = false;
			
			List selectedVersions = new ArrayList();
			
			for (Iterator i = fixForSelection.iterator(); i.hasNext(); ) {
				Object selection = i.next();
				if (ANY_FIX_VERSION.equals(selection)) {
					selectionContainsAll = true;
				} else if (NO_FIX_VERSION.equals(selection)) {
					selectionContainsNone = true;
				} else if (RELEASED_VERSION.equals(selection)) {
					selectionContainsReleased = true;
				} else if (UNRELEASED_VERSION.equals(selection)) {
					selectionContainsUnreleased = true;
				} else if (selection instanceof Version) {
					selectedVersions.add(selection);
				}
			}
			
			if (selectionContainsAll) {
				workingCopy.setFixForVersionFilter(null);
			} else if (selectionContainsNone) {
				workingCopy.setFixForVersionFilter(new VersionFilter(new Version[0]));
			} else if (selectionContainsReleased || selectionContainsUnreleased) {
				workingCopy.setFixForVersionFilter(new VersionFilter(selectionContainsReleased, selectionContainsUnreleased));
			} else if (selectedVersions.size() > 0) {
				workingCopy.setFixForVersionFilter(new VersionFilter((Version[]) selectedVersions.toArray(new Version[selectedVersions.size()])));
			} else {
				workingCopy.setFixForVersionFilter(null);
			}
		}
		
		IStructuredSelection componentsSelection = (IStructuredSelection)components.getSelection();
		if (componentsSelection.isEmpty()) {
			workingCopy.setComponentFilter(null);
		} else {
		
			boolean selectionContainsAll = false;
			boolean selectionContainsNone = false;
			List selectedComponents = new ArrayList();
			
			for (Iterator i = componentsSelection.iterator(); i.hasNext(); ) {
				Object selection = i.next();
				if (ANY_COMPONENT.equals(selection)) {
					selectionContainsAll = true;
				} else if (NO_COMPONENT.equals(selection)) {
					selectionContainsNone = true;
				} else if (selection instanceof Component){
					selectedComponents.add(selection);
				}
			}
			
			if (selectionContainsAll) {
				workingCopy.setComponentFilter(null);
			} else if (selectedComponents.size() > 0) {
				workingCopy.setComponentFilter(new ComponentFilter((Component[]) selectedComponents.toArray(new Component[selectedComponents.size()])));
			} else if (selectionContainsNone){
				workingCopy.setComponentFilter(new ComponentFilter(new Component[0]));
			} else {
				workingCopy.setComponentFilter(null);
			}
		}
	}

	private final class ComponentLabelProvider implements ILabelProvider {

		/* (non-Javadoc)
		 * @see org.eclipse.jface.viewers.ILabelProvider#getImage(java.lang.Object)
		 */
		public Image getImage(Object element) {
			return null;
		}

		/* (non-Javadoc)
		 * @see org.eclipse.jface.viewers.ILabelProvider#getText(java.lang.Object)
		 */
		public String getText(Object element) {
			if (element instanceof Placeholder) {
				return ((Placeholder)element).getText();
			}
			return ((Component)element).getName();
		}

		/* (non-Javadoc)
		 * @see org.eclipse.jface.viewers.IBaseLabelProvider#addListener(org.eclipse.jface.viewers.ILabelProviderListener)
		 */
		public void addListener(ILabelProviderListener listener) {
		}

		/* (non-Javadoc)
		 * @see org.eclipse.jface.viewers.IBaseLabelProvider#dispose()
		 */
		public void dispose() {
		}

		/* (non-Javadoc)
		 * @see org.eclipse.jface.viewers.IBaseLabelProvider#isLabelProperty(java.lang.Object, java.lang.String)
		 */
		public boolean isLabelProperty(Object element, String property) {
			return false;
		}

		/* (non-Javadoc)
		 * @see org.eclipse.jface.viewers.IBaseLabelProvider#removeListener(org.eclipse.jface.viewers.ILabelProviderListener)
		 */
		public void removeListener(ILabelProviderListener listener) {
		}
		
	}
	
	private final class VersionLabelProvider implements ILabelProvider, IColorProvider {

		/* (non-Javadoc)
		 * @see org.eclipse.jface.viewers.ILabelProvider#getImage(java.lang.Object)
		 */
		public Image getImage(Object element) {
			return null;
		}

		/* (non-Javadoc)
		 * @see org.eclipse.jface.viewers.ILabelProvider#getText(java.lang.Object)
		 */
		public String getText(Object element) {
			if (element instanceof Placeholder) {
				return ((Placeholder)element).getText();
			}
			return ((Version)element).getName();
		}

		/* (non-Javadoc)
		 * @see org.eclipse.jface.viewers.IBaseLabelProvider#addListener(org.eclipse.jface.viewers.ILabelProviderListener)
		 */
		public void addListener(ILabelProviderListener listener) {
			
		}

		/* (non-Javadoc)
		 * @see org.eclipse.jface.viewers.IBaseLabelProvider#dispose()
		 */
		public void dispose() {
		}

		/* (non-Javadoc)
		 * @see org.eclipse.jface.viewers.IBaseLabelProvider#isLabelProperty(java.lang.Object, java.lang.String)
		 */
		public boolean isLabelProperty(Object element, String property) {
			return false;
		}

		/* (non-Javadoc)
		 * @see org.eclipse.jface.viewers.IBaseLabelProvider#removeListener(org.eclipse.jface.viewers.ILabelProviderListener)
		 */
		public void removeListener(ILabelProviderListener listener) {
		}

		/* (non-Javadoc)
		 * @see org.eclipse.jface.viewers.IColorProvider#getForeground(java.lang.Object)
		 */
		public Color getForeground(Object element) {
			return null;
		}

		/* (non-Javadoc)
		 * @see org.eclipse.jface.viewers.IColorProvider#getBackground(java.lang.Object)
		 */
		public Color getBackground(Object element) {
			if (element instanceof Placeholder) {
				return Display.getCurrent().getSystemColor(SWT.COLOR_INFO_BACKGROUND);
			}
			return null;
		}
		
	}
	
	private final class Placeholder {
		private final String text;
		
		public Placeholder(String text) {
			this.text = text;
		}
		/* (non-Javadoc)
		 * @see java.lang.Object#equals(java.lang.Object)
		 */
		public boolean equals(Object obj) {
			if (obj == null) return false;
			if (!(obj instanceof Placeholder)) return false;
			
			Placeholder that = (Placeholder) obj;
			return this.text.equals(that.text);
		}
		public String getText() {
			return this.text;
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2006 - 2006 Mylar eclipse.org project and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Mylar project committers - initial API and implementation
 *******************************************************************************/

package org.eclipse.mylar.internal.jira;

import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryQuery;
import org.tigris.jira.core.model.NamedFilter;

/**
 * A JiraFilter represents a query for issues from a Jira repository.
 * 
 * @author Mik Kersten
 * @author Wesley Coelho (initial integration patch)
 */
public class JiraNamedFilter extends AbstractRepositoryQuery {

//	private static final String LABEL_REFRESH_JOB = "Refreshing Jira Filter(s)";

	private static final int MAX_HITS = 75;

	protected NamedFilter filter = null;

//	private boolean isRefreshing = false;

	public JiraNamedFilter(String repositoryUrl, NamedFilter filter) {
		setMaxHits(MAX_HITS);
		this.filter = filter;
		super.repositoryUrl = repositoryUrl;
		setQueryUrl(repositoryUrl + MylarJiraPlugin.FILTER_URL_PREFIX + filter.getId());

		super.setDescription(filter.getName());
	}

	public NamedFilter getNamedFilter() {
		return filter;
	}

//	/**
//	 * TODO: refactor into common refresh mechanism.
//	 */
//	public void refreshHits() {
//		isRefreshing = true;
//		Job j = new Job(LABEL_REFRESH_JOB) {
//
//			@Override
//			protected IStatus run(final IProgressMonitor monitor) {
//				clearHits();
//				try {
//					TaskRepository repository = MylarTaskListPlugin.getRepositoryManager().getRepository(MylarJiraPlugin.JIRA_REPOSITORY_KIND, repositoryUrl);
//					JiraServerFacade.getDefault().getJiraServer(repository).executeNamedFilter(filter, new IssueCollector() {
//
//						public void done() {
//							isRefreshing = false;
//							Display.getDefault().asyncExec(new Runnable() {
//								public void run() {
//									if (TaskListView.getDefault() != null)
//										TaskListView.getDefault().refreshAndFocus();
//								}
//							});
//						}
//
//						public boolean isCancelled() {
//							return monitor.isCanceled();
//						}
//
//						public void collectIssue(Issue issue) {
//							int issueId = new Integer(issue.getId());
//							JiraFilterHit hit = new JiraFilterHit(issue, JiraFilter.this.getRepositoryUrl(), issueId);
//							addHit(hit);
//						}
//
//						public void start() {
//
//						}
//					});
//
//				} catch (Exception e) {
//					isRefreshing = false;
//					JiraServerFacade.handleConnectionException(e);
//					return Status.CANCEL_STATUS;
//				}
//
//				return Status.OK_STATUS;
//			}
//
//		};
//
//		j.schedule();
//
//	}

	public String getQueryUrl() {
		return super.getQueryUrl();
	}

	public String getPriority() {
		return "";
	}

	public String getDescription() {
		if (filter.getName() != null) {
			return filter.getName();
		} else {
			return super.getDescription();
		}
	}

	public void setDescription(String description) {
		filter.setDescription(description);
	}

	public boolean isLocal() {
		return false;
	}

//	/** True if the filter is currently downloading hits */
//	public boolean isRefreshing() {
//		return isRefreshing;
//	}

	public String getRepositoryKind() {
		return MylarJiraPlugin.JIRA_REPOSITORY_KIND;
	}

	public NamedFilter getFilter() {
		return filter;
	}

//	public void setRefreshing(boolean refreshing) {
//		this.isRefreshing = refreshing;
//	}

}




/*******************************************************************************
 * Copyright (c) 2005 Jira Dashboard project.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Brock Janiczak - initial API and implementation
 *******************************************************************************/
package org.eclipse.mylar.internal.jira.ui.wizards;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.ComboViewer;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.ListViewer;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ModifyEvent;
import org.eclipse.swt.events.ModifyListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;
import org.tigris.jira.core.model.IssueType;
import org.tigris.jira.core.model.Priority;
import org.tigris.jira.core.model.Resolution;
import org.tigris.jira.core.model.Status;
import org.tigris.jira.core.model.filter.CurrentUserFilter;
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.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.service.JiraServer;

public class IssueAttributesPage extends WizardPage {
	private final Placeholder ANY_ISSUE_TYPE = new Placeholder("Any");
	private final Placeholder ANY_RESOLUTION = new Placeholder("Any");
	private final Placeholder UNRESOLVED = new Placeholder("Unresolved");
	private final Placeholder UNASSIGNED = new Placeholder("Unassigned");
	
	private final Placeholder ANY_REPORTER = new Placeholder("Any");
	private final Placeholder NO_REPORTER = new Placeholder("No Reporter");
	private final Placeholder CURRENT_USER_REPORTER = new Placeholder("Current User");
	private final Placeholder SPECIFIC_USER_REPORTER = new Placeholder("Specified User");
	private final Placeholder SPECIFIC_GROUP_REPORTER = new Placeholder("Specified Group");

	private final Placeholder ANY_ASSIGNEE = new Placeholder("Any");
	private final Placeholder CURRENT_USER_ASSIGNEE = new Placeholder("Current User");
	private final Placeholder SPECIFIC_USER_ASSIGNEE = new Placeholder("Specified User");
	private final Placeholder SPECIFIC_GROUP_ASSIGNEE = new Placeholder("Specified Group");
	
	private final Placeholder ANY_STATUS = new Placeholder("Any");
	private final Placeholder ANY_PRIORITY = new Placeholder("Any");
	
	private final JiraServer jiraServer;
	private final FilterDefinition workingCopy;
	private final boolean isNew;
	private ListViewer issueType;
	private ComboViewer reporterType;
	private ComboViewer assigneeType;
	private ListViewer status;
	private ListViewer resolution;
	private ListViewer priority;
	private Text assignee;
	private Text reporter;
	
	/**
	 * @param pageName
	 * @param title
	 * @param titleImage
	 */
	protected IssueAttributesPage(String pageName, String title, ImageDescriptor titleImage, JiraServer jiraServer, FilterDefinition workingCopy, boolean isNew) {
		super(pageName, title, titleImage);
		this.jiraServer = jiraServer;
		this.workingCopy = workingCopy;
		this.isNew = isNew;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
	 */
	public void createControl(Composite parent) {
		GridData gd;
		Composite c = new Composite(parent, SWT.NONE);
		c.setLayout(new GridLayout(2, false));
		
		Label lblIssueType = new Label(c, SWT.NONE);
		lblIssueType.setText("Type:");
		lblIssueType.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false));
		issueType = new ListViewer(c, SWT.MULTI | SWT.BORDER | SWT.V_SCROLL);
		gd = new GridData(SWT.FILL, SWT.FILL, true, true);
		gd.heightHint = 40;
		issueType.getControl().setLayoutData(gd);
		
		issueType.setContentProvider(new IStructuredContentProvider() {
			
			public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
			}
		
			public void dispose() {
			}
		
			public Object[] getElements(Object inputElement) {
				JiraServer server = (JiraServer) inputElement;
				Object[] elements = new Object[server.getIssueTypes().length + 1];
				elements[0] = ANY_ISSUE_TYPE;
				System.arraycopy(server.getIssueTypes(), 0, elements, 1, server.getIssueTypes().length);
				
				return elements;
			}
		});
		
		issueType.setLabelProvider(new LabelProvider() {
		
			public String getText(Object element) {
				if (element instanceof Placeholder) {
					return ((Placeholder)element).getText();
				}
				
				return ((IssueType)element).getName();
			}
		
		});
		
		issueType.addSelectionChangedListener(new ISelectionChangedListener() {
			
			public void selectionChanged(SelectionChangedEvent event) {
				validatePage();
			}
		
		});
		issueType.setInput(jiraServer);
		
		Label lblReportedBy = new Label(c, SWT.NONE);
		lblReportedBy.setText("Reported By:");
		lblReportedBy.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false, 1, 2));
		
		reporterType = new ComboViewer(c, SWT.BORDER | SWT.READ_ONLY);
		reporterType.getControl().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));
		
		reporterType.setContentProvider(new IStructuredContentProvider() {
			
			public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
			}
		
			public void dispose() {
			}
		
			public Object[] getElements(Object inputElement) {
				return new Object[] {ANY_REPORTER, NO_REPORTER, CURRENT_USER_REPORTER, SPECIFIC_USER_REPORTER, SPECIFIC_GROUP_REPORTER};
			}
		
		});	

		reporterType.setLabelProvider(new LabelProvider() {
		
			public String getText(Object element) {
				return ((Placeholder)element).getText();
			}
		
		});
		
		reporterType.setInput(jiraServer);
		
		reporter = new Text(c, SWT.BORDER);
		reporter.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));
		reporter.setEnabled(false);

		reporter.addModifyListener(new ModifyListener() {
			
			public void modifyText(ModifyEvent e) {
				validatePage();
			}
		
		});
		
		reporterType.addSelectionChangedListener(new ISelectionChangedListener() {
			
			public void selectionChanged(SelectionChangedEvent event) {
				Object selection = ((IStructuredSelection)event.getSelection()).getFirstElement();
				if (SPECIFIC_USER_REPORTER.equals(selection) ||
					SPECIFIC_GROUP_REPORTER.equals(selection)) {
					reporter.setEnabled(true);
				} else {
					reporter.setEnabled(false);
				}
			}
		
		});
		
		Label lblAssignedTo = new Label(c, SWT.NONE);
		lblAssignedTo.setText("Assigned To:");
		lblAssignedTo.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false, 1, 2));
		
		assigneeType = new ComboViewer(c, SWT.BORDER | SWT.READ_ONLY);
		assigneeType.getControl().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));
		
		
		assigneeType.setContentProvider(new IStructuredContentProvider() {
		
			public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
			}
		
			public void dispose() {
			}
		
			public Object[] getElements(Object inputElement) {
				return new Object[] {ANY_ASSIGNEE, UNASSIGNED, CURRENT_USER_ASSIGNEE, SPECIFIC_USER_ASSIGNEE, SPECIFIC_GROUP_ASSIGNEE};
			}
		
		});	

		assigneeType.setLabelProvider(new LabelProvider() {
		
			public String getText(Object element) {
				return ((Placeholder)element).getText();
			}
		
		});
		
		assigneeType.setInput(jiraServer);
		
		assignee = new Text(c, SWT.BORDER);
		assignee.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));
		assignee.setEnabled(false);

		assignee.addModifyListener(new ModifyListener() {
		
			public void modifyText(ModifyEvent e) {
				validatePage();
			}
		
		});
		assigneeType.addSelectionChangedListener(new ISelectionChangedListener() {
			
			public void selectionChanged(SelectionChangedEvent event) {
				Object selection = ((IStructuredSelection)event.getSelection()).getFirstElement();
				if (SPECIFIC_USER_ASSIGNEE.equals(selection) ||
					SPECIFIC_GROUP_ASSIGNEE.equals(selection)) {
					assignee.setEnabled(true);
				} else {
					assignee.setEnabled(false);
					assignee.setText(""); //$NON-NLS-1$
				}
				validatePage();
			}
		
		});
		
		Label lblStatus = new Label(c, SWT.NONE);
		lblStatus.setText("Status:");
		lblStatus.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false));
		
		status = new ListViewer(c, SWT.MULTI | SWT.BORDER | SWT.V_SCROLL);
		gd = new GridData(SWT.FILL, SWT.FILL, true, true);
		gd.heightHint = 40;
		status.getControl().setLayoutData(gd);

		status.setContentProvider(new IStructuredContentProvider() {
			
			public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
			}
		
			public void dispose() {
			}
		
			public Object[] getElements(Object inputElement) {
				JiraServer server = (JiraServer) inputElement;
				Object[] elements = new Object[server.getStatuses().length + 1];
				elements[0] = ANY_STATUS;
				System.arraycopy(server.getStatuses(), 0, elements, 1, server.getStatuses().length);
				
				return elements;
			}
		});
		
		status.setLabelProvider(new LabelProvider() {
		
			public String getText(Object element) {
				if (element instanceof Placeholder) {
					return ((Placeholder)element).getText();
				}
				
				return ((Status)element).getName();
			}
		
		});
		
		status.addSelectionChangedListener(new ISelectionChangedListener() {
			
			public void selectionChanged(SelectionChangedEvent event) {
				validatePage();
			}
		
		});
		status.setInput(jiraServer);
		
		Label lblResolution = new Label(c, SWT.NONE);
		lblResolution.setText("Resolution:");
		lblResolution.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false));
		
		resolution = new ListViewer(c, SWT.MULTI | SWT.BORDER | SWT.V_SCROLL);
		gd = new GridData(SWT.FILL, SWT.FILL, true, true);
		gd.heightHint = 40;
		resolution.getControl().setLayoutData(gd);
		resolution.setContentProvider(new IStructuredContentProvider() {
		
			public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
			}
		
			public void dispose() {
			}
		
			public Object[] getElements(Object inputElement) {
				JiraServer server = (JiraServer) inputElement;
				Object[] elements = new Object[server.getResolutions().length + 2];
				elements[0] = ANY_RESOLUTION;
				elements[1] = UNRESOLVED;
				System.arraycopy(server.getResolutions(), 0, elements, 2, server.getResolutions().length);
				
				return elements;
			}
		});
		
		resolution.setLabelProvider(new LabelProvider() {
		
			public String getText(Object element) {
				if (element instanceof Placeholder) {
					return ((Placeholder)element).getText();
				}
				
				return ((Resolution)element).getName();
			}
		
		});
		
		resolution.addSelectionChangedListener(new ISelectionChangedListener() {
			
			public void selectionChanged(SelectionChangedEvent event) {
				validatePage();
			}
		
		});
		resolution.setInput(jiraServer);
		
		Label lblPriority = new Label(c, SWT.NONE);
		lblPriority.setText("Priority:");
		lblPriority.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false));
		
		priority = new ListViewer(c, SWT.MULTI | SWT.BORDER | SWT.V_SCROLL);
		gd = new GridData(SWT.FILL, SWT.FILL, true, true);
		gd.heightHint = 40;
		priority.getControl().setLayoutData(gd);
		
		priority.setContentProvider(new IStructuredContentProvider() {
			
			public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
			}
		
			public void dispose() {
			}
		
			public Object[] getElements(Object inputElement) {
				JiraServer server = (JiraServer) inputElement;
				Object[] elements = new Object[server.getPriorities().length + 1];
				elements[0] = ANY_PRIORITY;
				System.arraycopy(server.getPriorities(), 0, elements, 1, server.getPriorities().length);
				
				return elements;
			}
		});
		
		priority.setLabelProvider(new LabelProvider() {
		
			public String getText(Object element) {
				if (element instanceof Placeholder) {
					return ((Placeholder)element).getText();
				}
				
				return ((Priority)element).getName();
			}
		
		});
		priority.addSelectionChangedListener(new ISelectionChangedListener() {
		
			public void selectionChanged(SelectionChangedEvent event) {
				validatePage();
			}
		
		});
		priority.setInput(jiraServer);
		
		if (isNew) {
			loadFromDefaults();
		} else {
			loadFromWorkingCopy();
		}
		
		setControl(c);
	}
	
	private void validatePage() {
		
	}

	/* default */ void applyChanges() {
		
		// TODO support standard and subtask issue types
		IStructuredSelection issueTypeSelection = (IStructuredSelection) issueType.getSelection();
		if (issueTypeSelection.isEmpty()) {
			workingCopy.setIssueTypeFilter(null);
		} else {
			boolean isAnyIssueTypeSelected = false;
			
			List selectedIssueTypes = new ArrayList();
			
			for (Iterator i = issueTypeSelection.iterator(); i.hasNext(); ) {
				Object selection = i.next();
				if (ANY_ISSUE_TYPE.equals(selection)) {
					isAnyIssueTypeSelected = true;
				} else if (selection instanceof IssueType) {
					selectedIssueTypes.add(selection);
				}
			}
			
			if (isAnyIssueTypeSelected) {
				workingCopy.setIssueTypeFilter(null);
			} else {
				workingCopy.setIssueTypeFilter(new IssueTypeFilter((IssueType[]) selectedIssueTypes.toArray(new IssueType[selectedIssueTypes.size()])));
			}
		}
		
		IStructuredSelection reporterSelection = (IStructuredSelection) reporterType.getSelection();
		if (reporterSelection.isEmpty()) {
			workingCopy.setReportedByFilter(null);
		} else {
			if (ANY_REPORTER.equals(reporterSelection.getFirstElement())) {
				workingCopy.setReportedByFilter(null);
			} else if (NO_REPORTER.equals(reporterSelection.getFirstElement())) {
				workingCopy.setReportedByFilter(new NobodyFilter());
			} else if (CURRENT_USER_REPORTER.equals(reporterSelection.getFirstElement())) {
				workingCopy.setReportedByFilter(new CurrentUserFilter());
			} else if (SPECIFIC_GROUP_REPORTER.equals(reporterSelection.getFirstElement())) {
				workingCopy.setReportedByFilter(new UserInGroupFilter(reporter.getText()));
			} else if (SPECIFIC_USER_REPORTER.equals(reporterSelection.getFirstElement())) {
				workingCopy.setReportedByFilter(new SpecificUserFilter(reporter.getText()));
			} else {
				workingCopy.setReportedByFilter(null);
			}
		}
		
		IStructuredSelection assigneeSelection = (IStructuredSelection) assigneeType.getSelection();
		if (assigneeSelection.isEmpty()) {
			workingCopy.setAssignedToFilter(null);
		} else {
			if (ANY_REPORTER.equals(assigneeSelection.getFirstElement())) {
				workingCopy.setAssignedToFilter(null);
			} else if (UNASSIGNED.equals(assigneeSelection.getFirstElement())) {
				workingCopy.setAssignedToFilter(new NobodyFilter());
			} else if (CURRENT_USER_REPORTER.equals(assigneeSelection.getFirstElement())) {
				workingCopy.setAssignedToFilter(new CurrentUserFilter());
			} else if (SPECIFIC_GROUP_REPORTER.equals(assigneeSelection.getFirstElement())) {
				workingCopy.setAssignedToFilter(new UserInGroupFilter(assignee.getText()));
			} else if (SPECIFIC_USER_REPORTER.equals(assigneeSelection.getFirstElement())) {
				workingCopy.setAssignedToFilter(new SpecificUserFilter(assignee.getText()));
			} else {
				workingCopy.setAssignedToFilter(null);
			}
		}
		
		
		IStructuredSelection statusSelection = (IStructuredSelection) status.getSelection();
		if (statusSelection.isEmpty()) {
			workingCopy.setStatusFilter(null);
		} else {
			boolean isAnyStatusSelected = false;
			
			List selectedStatuses = new ArrayList();
			
			for (Iterator i = statusSelection.iterator(); i.hasNext(); ) {
				Object selection = i.next();
				if (ANY_STATUS.equals(selection)) {
					isAnyStatusSelected = true;
				} else if (selection instanceof Status) {
					selectedStatuses.add(selection);
				}
			}
			
			if (isAnyStatusSelected) {
				workingCopy.setStatusFilter(null);
			} else {
				workingCopy.setStatusFilter(new StatusFilter((Status[]) selectedStatuses.toArray(new Status[selectedStatuses.size()])));
			}
		}
		
		IStructuredSelection resolutionSelection = (IStructuredSelection) resolution.getSelection();
		if (resolutionSelection.isEmpty()) {
			workingCopy.setResolutionFilter(null);
		} else {
			boolean isAnyResolutionSelected = false;
			
			List selectedResolutions = new ArrayList();
			
			for (Iterator i = resolutionSelection.iterator(); i.hasNext(); ) {
				Object selection = i.next();
				if (ANY_RESOLUTION.equals(selection)) {
					isAnyResolutionSelected = true;
				} else if (selection instanceof Resolution) {
					selectedResolutions.add(selection);
				}
			}
			
			if (isAnyResolutionSelected) {
				workingCopy.setResolutionFilter(null);
			} else {
				workingCopy.setResolutionFilter(new ResolutionFilter((Resolution[]) selectedResolutions.toArray(new Resolution[selectedResolutions.size()])));
			}
		}
		
		
		IStructuredSelection prioritySelection = (IStructuredSelection) priority.getSelection();
		if (prioritySelection.isEmpty()) {
			workingCopy.setPriorityFilter(null);
		} else {
			boolean isAnyPrioritiesSelected = false;
			
			List selectedPriorities = new ArrayList();
			
			for (Iterator i = prioritySelection.iterator(); i.hasNext(); ) {
				Object selection = i.next();
				if (ANY_PRIORITY.equals(selection)) {
					isAnyPrioritiesSelected = true;
				} else if (selection instanceof Priority) {
					selectedPriorities.add(selection);
				}
			}
			
			if (isAnyPrioritiesSelected) {
				workingCopy.setPriorityFilter(null);
			} else {
				workingCopy.setPriorityFilter(new PriorityFilter((Priority[]) selectedPriorities.toArray(new Priority[selectedPriorities.size()])));
			}
		}
	}
	
	private void loadFromDefaults() {
		issueType.setSelection(new StructuredSelection(ANY_ISSUE_TYPE));
		reporterType.setSelection(new StructuredSelection(ANY_REPORTER));
		assigneeType.setSelection(new StructuredSelection(ANY_ASSIGNEE));
		status.setSelection(new StructuredSelection(ANY_STATUS));
		resolution.setSelection(new StructuredSelection(ANY_RESOLUTION));
		priority.setSelection(new StructuredSelection(ANY_PRIORITY));
	}
	
	private void loadFromWorkingCopy() {
		if (workingCopy.getIssueTypeFilter() != null) {
			issueType.setSelection(new StructuredSelection(workingCopy.getIssueTypeFilter().getIsueTypes()));
		} else {
			issueType.setSelection(new StructuredSelection(ANY_ISSUE_TYPE));
		}
		
		if (workingCopy.getReportedByFilter() != null) {
			UserFilter reportedByFilter = workingCopy.getReportedByFilter();
			if (reportedByFilter instanceof NobodyFilter) {
				reporterType.setSelection(new StructuredSelection(NO_REPORTER));
			} else if (reportedByFilter instanceof CurrentUserFilter) {
				reporterType.setSelection(new StructuredSelection(CURRENT_USER_REPORTER));
			} else if (reportedByFilter instanceof SpecificUserFilter) {
				reporterType.setSelection(new StructuredSelection(SPECIFIC_USER_REPORTER));
				reporter.setText(((SpecificUserFilter)reportedByFilter).getUser());
			} else if (reportedByFilter instanceof UserInGroupFilter) {
				reporterType.setSelection(new StructuredSelection(SPECIFIC_GROUP_REPORTER));
				reporter.setText(((UserInGroupFilter)reportedByFilter).getGroup());
			}
		} else {
			reporterType.setSelection(new StructuredSelection(ANY_REPORTER));
		}
		
		if (workingCopy.getAssignedToFilter() != null) {
			UserFilter assignedToFilter = workingCopy.getAssignedToFilter();
			if (assignedToFilter instanceof NobodyFilter) {
				assigneeType.setSelection(new StructuredSelection(UNASSIGNED));
			} else if (assignedToFilter instanceof CurrentUserFilter) {
				assigneeType.setSelection(new StructuredSelection(CURRENT_USER_ASSIGNEE));
			} else if (assignedToFilter instanceof SpecificUserFilter) {
				assigneeType.setSelection(new StructuredSelection(SPECIFIC_USER_ASSIGNEE));
				assignee.setText(((SpecificUserFilter)assignedToFilter).getUser());
			} else if (assignedToFilter instanceof UserInGroupFilter) {
				assigneeType.setSelection(new StructuredSelection(SPECIFIC_GROUP_ASSIGNEE));
				assignee.setText(((UserInGroupFilter)assignedToFilter).getGroup());
			}
		} else {
			assigneeType.setSelection(new StructuredSelection(ANY_ASSIGNEE));
		}
		
		if (workingCopy.getStatusFilter() != null) {
			status.setSelection(new StructuredSelection(workingCopy.getStatusFilter().getStatuses()));
		} else {
			status.setSelection(new StructuredSelection(ANY_STATUS));
		}
		
		if (workingCopy.getResolutionFilter() != null) {
			resolution.setSelection(new StructuredSelection(workingCopy.getResolutionFilter().getResolutions()));
		} else {
			resolution.setSelection(new StructuredSelection(ANY_RESOLUTION));
		}
		
		if (workingCopy.getPriorityFilter() != null) {
			priority.setSelection(new StructuredSelection(workingCopy.getPriorityFilter().getPriorities()));
		} else {
			priority.setSelection(new StructuredSelection(ANY_PRIORITY));
		}
	}
	
	private final class Placeholder {
		private final String text;
		
		public Placeholder(String text) {
			this.text = text;
		}
		/* (non-Javadoc)
		 * @see java.lang.Object#equals(java.lang.Object)
		 */
		public boolean equals(Object obj) {
			if (obj == null) return false;
			if (!(obj instanceof Placeholder)) return false;
			
			Placeholder that = (Placeholder) obj;
			return this.text.equals(that.text);
		}
		public String getText() {
			return this.text;
		}
	}
}

Return to bug 129086

Removed Link Here

(-)src/org/eclipse/mylar/internal/jira/JiraFilter.java (-141 lines)
1	/*******************************************************************************
2	* Copyright (c) 2006 - 2006 Mylar eclipse.org project and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Mylar project committers - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.mylar.internal.jira;
13
14	import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryQuery;
15	import org.tigris.jira.core.model.NamedFilter;
16
17	/**
18	* A JiraFilter represents a query for issues from a Jira repository.
19	*
20	* @author Mik Kersten
21	* @author Wesley Coelho (initial integration patch)
22	*/
23	public class JiraFilter extends AbstractRepositoryQuery {
24
25	// private static final String LABEL_REFRESH_JOB = "Refreshing Jira Filter(s)";
26
27	private static final int MAX_HITS = 75;
28
29	protected NamedFilter filter = null;
30
31	// private boolean isRefreshing = false;
32
33	public JiraFilter(String repositoryUrl, NamedFilter filter) {
34	setMaxHits(MAX_HITS);
35	this.filter = filter;
36	super.repositoryUrl = repositoryUrl;
37	setQueryUrl(repositoryUrl + MylarJiraPlugin.FILTER_URL_PREFIX + filter.getId());
38
39	super.setDescription(filter.getName());
40	}
41
42	public NamedFilter getNamedFilter() {
43	return filter;
44	}
45
46	// /**
47	// * TODO: refactor into common refresh mechanism.
48	// */
49	// public void refreshHits() {
50	// isRefreshing = true;
51	// Job j = new Job(LABEL_REFRESH_JOB) {
52	//
53	// @Override
54	// protected IStatus run(final IProgressMonitor monitor) {
55	// clearHits();
56	// try {
57	// TaskRepository repository = MylarTaskListPlugin.getRepositoryManager().getRepository(MylarJiraPlugin.JIRA_REPOSITORY_KIND, repositoryUrl);
58	// JiraServerFacade.getDefault().getJiraServer(repository).executeNamedFilter(filter, new IssueCollector() {
59	//
60	// public void done() {
61	// isRefreshing = false;
62	// Display.getDefault().asyncExec(new Runnable() {
63	// public void run() {
64	// if (TaskListView.getDefault() != null)
65	// TaskListView.getDefault().refreshAndFocus();
66	// }
67	// });
68	// }
69	//
70	// public boolean isCancelled() {
71	// return monitor.isCanceled();
72	// }
73	//
74	// public void collectIssue(Issue issue) {
75	// int issueId = new Integer(issue.getId());
76	// JiraFilterHit hit = new JiraFilterHit(issue, JiraFilter.this.getRepositoryUrl(), issueId);
77	// addHit(hit);
78	// }
79	//
80	// public void start() {
81	//
82	// }
83	// });
84	//
85	// } catch (Exception e) {
86	// isRefreshing = false;
87	// JiraServerFacade.handleConnectionException(e);
88	// return Status.CANCEL_STATUS;
89	// }
90	//
91	// return Status.OK_STATUS;
92	// }
93	//
94	// };
95	//
96	// j.schedule();
97	//
98	// }
99
100	public String getQueryUrl() {
101	return super.getQueryUrl();
102	}
103
104	public String getPriority() {
105	return "";
106	}
107
108	public String getDescription() {
109	if (filter.getName() != null) {
110	return filter.getName();
111	} else {
112	return super.getDescription();
113	}
114	}
115
116	public void setDescription(String description) {
117	filter.setDescription(description);
118	}
119
120	public boolean isLocal() {
121	return false;
122	}
123
124	// /** True if the filter is currently downloading hits */
125	// public boolean isRefreshing() {
126	// return isRefreshing;
127	// }
128
129	public String getRepositoryKind() {
130	return MylarJiraPlugin.JIRA_REPOSITORY_KIND;
131	}
132
133	public NamedFilter getFilter() {
134	return filter;
135	}
136
137	// public void setRefreshing(boolean refreshing) {
138	// this.isRefreshing = refreshing;
139	// }
140
141	}

Lines 51-125 Link Here

(-)src/org/eclipse/mylar/internal/jira/JiraTaskExternalizer.java (-42 / +55 lines)
51	private static final String KEY_FILTER_ID = "FilterID";	51	private static final String KEY_FILTER_ID = "FilterID";
52		52
53	private static final String KEY_FILTER_DESCRIPTION = "FilterDesc";	53	private static final String KEY_FILTER_DESCRIPTION = "FilterDesc";
		54
		55	private static final String KEY_QUERY_TYPE = "QueryType";
54		56
55	public boolean canReadQuery(Node node) {	57	public boolean canReadQuery(Node node) {
56	return node.getNodeName().equals(KEY_JIRA_QUERY);	58	return node.getNodeName().equals(KEY_JIRA_QUERY);
57	}	59	}
58		60
59	public boolean canCreateElementFor(AbstractRepositoryQuery category) {	61	public boolean canCreateElementFor(AbstractRepositoryQuery category) {
60	return category instanceof JiraFilter;	62	return category instanceof JiraNamedFilter \|\| category instanceof JiraCustomFilter;
61	}	63	}
62		64
63	public boolean canCreateElementFor(ITask task) {	65	public boolean canCreateElementFor(ITask task) {
64	return task instanceof JiraTask;	66	return task instanceof JiraTask;
65	}	67	}
66		68
		69	@Override
67	public AbstractRepositoryQuery readQuery(Node node, TaskList taskList) throws TaskExternalizationException {	70	public AbstractRepositoryQuery readQuery(Node node, TaskList taskList) throws TaskExternalizationException {
68	boolean hasCaughtException = false;	71	boolean hasCaughtException = false;
69	Element element = (Element) node;	72	Element element = (Element) node;
70		73
71	NamedFilter namedFilter = new NamedFilter();	74	String queryType = element.getAttribute(KEY_QUERY_TYPE);
72	namedFilter.setId(element.getAttribute(KEY_FILTER_ID));	75	if ("Custom".equals(queryType)) {
73	namedFilter.setName(element.getAttribute(KEY_FILTER_NAME));	76	return null;
74	// namedFilter.setDescription(element.getAttribute(KEY_FILTER_DESCRIPTION));	77	} else {
75		78	NamedFilter namedFilter = new NamedFilter();
76	AbstractRepositoryQuery query = new JiraFilter(element.getAttribute(KEY_REPOSITORY_URL), namedFilter);	79	namedFilter.setId(element.getAttribute(KEY_FILTER_ID));
		80	namedFilter.setName(element.getAttribute(KEY_FILTER_NAME));
		81	// namedFilter.setDescription(element.getAttribute(KEY_FILTER_DESCRIPTION));
		82
		83	AbstractRepositoryQuery query = new JiraNamedFilter(element.getAttribute(KEY_REPOSITORY_URL), namedFilter);
77		84
78	NodeList list = node.getChildNodes();	85	NodeList list = node.getChildNodes();
79	for (int i = 0; i < list.getLength(); i++) {	86	for (int i = 0; i < list.getLength(); i++) {
80	Node child = list.item(i);	87	Node child = list.item(i);
81	try {	88	try {
82	readQueryHit(child, taskList, query);	89	readQueryHit(child, taskList, query);
83	} catch (TaskExternalizationException e) {	90	} catch (TaskExternalizationException e) {
84	hasCaughtException = true;	91	hasCaughtException = true;
		92	}
		93	}
		94	if (hasCaughtException) {
		95	throw new TaskExternalizationException("Failed to load all hits");
		96	} else {
		97	return query;
85	}	98	}
86	}	99	}
87	if (hasCaughtException) {	100
88	throw new TaskExternalizationException("Failed to load all hits");
89	} else {
90	return query;
91	}
92	}	101	}
93		102
94	public Element createQueryElement(AbstractRepositoryQuery query, Document doc, Element parent) {	103	public Element createQueryElement(AbstractRepositoryQuery query, Document doc, Element parent) {
95	String queryTagName = getQueryTagNameForElement(query);	104	String queryTagName = getQueryTagNameForElement(query);
96	Element node = doc.createElement(queryTagName);	105	Element node = doc.createElement(queryTagName);
97		106
98	NamedFilter filter = ((JiraFilter) query).getNamedFilter();	107	if (query instanceof JiraNamedFilter) {
99	node.setAttribute(KEY_NAME, query.getDescription());	108	NamedFilter filter = ((JiraNamedFilter) query).getNamedFilter();
100	node.setAttribute(KEY_QUERY_MAX_HITS, query.getMaxHits() + "");	109	node.setAttribute(KEY_NAME, query.getDescription());
101	node.setAttribute(KEY_QUERY_STRING, query.getQueryUrl());	110	node.setAttribute(KEY_QUERY_MAX_HITS, query.getMaxHits() + "");
102	node.setAttribute(KEY_REPOSITORY_URL, query.getRepositoryUrl());	111	node.setAttribute(KEY_QUERY_STRING, query.getQueryUrl());
103		112	node.setAttribute(KEY_REPOSITORY_URL, query.getRepositoryUrl());
104	node.setAttribute(KEY_FILTER_ID, filter.getId());	113
105	node.setAttribute(KEY_FILTER_NAME, filter.getName());	114	node.setAttribute(KEY_FILTER_ID, filter.getId());
106	node.setAttribute(KEY_FILTER_DESCRIPTION, filter.getDescription());	115	node.setAttribute(KEY_FILTER_NAME, filter.getName());
107		116	node.setAttribute(KEY_FILTER_DESCRIPTION, filter.getDescription());
108	for (AbstractQueryHit hit : query.getHits()) {	117
109	try {	118	for (AbstractQueryHit hit : query.getHits()) {
110	Element element = null;	119	try {
111	for (ITaskListExternalizer externalizer : super.getDelegateExternalizers()) {	120	Element element = null;
112	if (externalizer.canCreateElementFor(hit))	121	for (ITaskListExternalizer externalizer : super.getDelegateExternalizers()) {
113	element = externalizer.createQueryHitElement(hit, doc, node);	122	if (externalizer.canCreateElementFor(hit))
		123	element = externalizer.createQueryHitElement(hit, doc, node);
		124	}
		125	if (element == null)
		126	createQueryHitElement(hit, doc, node);
		127	} catch (Exception e) {
		128	MylarStatusHandler.log(e, e.getMessage());
114	}	129	}
115	if (element == null)
116	createQueryHitElement(hit, doc, node);
117	} catch (Exception e) {
118	MylarStatusHandler.log(e, e.getMessage());
119	}	130	}
		131	parent.appendChild(node);
		132	return node;
		133	} else {
		134	return node;
120	}	135	}
121	parent.appendChild(node);
122	return node;
123	}	136	}
124		137
125	@Override	138	@Override
Lines 222-228 Link Here
222	}	235	}
223		236
224	public String getQueryTagNameForElement(AbstractRepositoryQuery query) {	237	public String getQueryTagNameForElement(AbstractRepositoryQuery query) {
225	if (query instanceof JiraFilter) {	238	if (query instanceof JiraNamedFilter \|\| query instanceof JiraCustomFilter) {
226	return KEY_JIRA_QUERY;	239	return KEY_JIRA_QUERY;
227	}	240	}
228	return "";	241	return "";

Added Link Here

(-)src/org/eclipse/mylar/internal/jira/ui/wizards/IssueFilterWizard.java (+95 lines)
1	/*******************************************************************************
2	* Copyright (c) 2005 Jira Dashboard project.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* Brock Janiczak - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.mylar.internal.jira.ui.wizards;
12
13	import org.eclipse.jface.wizard.Wizard;
14	import org.eclipse.mylar.internal.jira.JiraCustomFilter;
15	import org.eclipse.mylar.internal.jira.JiraNamedFilter;
16	import org.eclipse.mylar.internal.jira.JiraServerFacade;
17	import org.eclipse.mylar.provisional.tasklist.AbstractRepositoryConnector;
18	import org.eclipse.mylar.provisional.tasklist.MylarTaskListPlugin;
19	import org.eclipse.mylar.provisional.tasklist.TaskRepository;
20	import org.tigris.jira.core.model.filter.FilterDefinition;
21	import org.tigris.jira.core.service.JiraServer;
22
23
24	// TODO this should be two different wizards (create and update)
25	public class IssueFilterWizard extends Wizard {
26
27	private FilterSummaryPage filterSummaryPage;
28	private final JiraServer server;
29	private FilterDefinition workingCopy;
30	private final boolean isAdd;
31	private FilterDefinition filter;
32	private IssueAttributesPage issueAttributesPage;
33	private final TaskRepository repository;
34
35	public IssueFilterWizard(TaskRepository repository) {
36	this.repository = repository;
37	// TODO this is most likely not a cool thing to be doing
38	this.server = JiraServerFacade.getDefault().getJiraServer(repository);
39	workingCopy = new FilterDefinition();
40	this.setWindowTitle("Create Issue Filter");
41	isAdd = true;
42	}
43
44	public IssueFilterWizard(TaskRepository repository, FilterDefinition filter) {
45	this.repository = repository;
46	// TODO this is most likely not a cool thing to be doing
47	this.server = JiraServerFacade.getDefault().getJiraServer(repository);
48	this.filter = filter;
49	workingCopy = new FilterDefinition(filter);
50	this.setWindowTitle("Create Issue Filter");
51	isAdd = false;
52	}
53
54	/* (non-Javadoc)
55	* @see org.eclipse.jface.wizard.Wizard#addPages()
56	*/
57	public void addPages() {
58	filterSummaryPage = new FilterSummaryPage("summaryPage", "Filter Summary", null, server, workingCopy, isAdd);
59	issueAttributesPage = new IssueAttributesPage("issueAttributes", "Issue Attributes", null, server, workingCopy, isAdd);
60
61	addPage(filterSummaryPage);
62	addPage(issueAttributesPage);
63
64	}
65
66	public boolean performFinish() {
67	if (isAdd) {
68	filterSummaryPage.applyChanges();
69	issueAttributesPage.applyChanges();
70	server.addLocalFilter(workingCopy);
71
72	JiraCustomFilter customFilter = new JiraCustomFilter(repository.getUrl().toExternalForm(), workingCopy);
73	MylarTaskListPlugin.getTaskListManager().addQuery(customFilter);
74	AbstractRepositoryConnector connector = MylarTaskListPlugin.getRepositoryManager().getRepositoryConnector(repository.getKind());
75	if (connector != null) {
76	connector.synchronize(customFilter, null);
77	}
78	// filter.refreshHits();
79	} else {
80	filterSummaryPage.applyChanges();
81	issueAttributesPage.applyChanges();
82	filter.copyAttributes(workingCopy);
83
84	JiraCustomFilter customFilter = new JiraCustomFilter(repository.getUrl().toExternalForm(), workingCopy);
85	MylarTaskListPlugin.getTaskListManager().addQuery(customFilter);
86	AbstractRepositoryConnector connector = MylarTaskListPlugin.getRepositoryManager().getRepositoryConnector(repository.getKind());
87	if (connector != null) {
88	connector.synchronize(customFilter, null);
89	}
90	// filter.refreshHits();
91	}
92	return true;
93	}
94
95	}