Attachment #148100 for bug #290490




import org.eclipse.mylyn.internal.jira.core.model.SecurityLevel;
import org.eclipse.mylyn.internal.jira.core.model.ServerInfo;
import org.eclipse.mylyn.internal.jira.core.model.User;
import org.eclipse.osgi.util.NLS;

/**
 * @author Steffen Pingel

	}

	private void initializeProjects(JiraClientData data, IProgressMonitor monitor) throws JiraException {
		monitor = Policy.monitorFor(monitor);

		data.projects = jiraClient.getProjects(monitor);

		try {
			monitor.beginTask(Messages.JiraClientCache_getting_project_details, data.projects.length);

			data.projectsById = new HashMap<String, Project>(data.projects.length);
			data.projectsByKey = new HashMap<String, Project>(data.projects.length);

			for (Project project : data.projects) {
				initializeProject(project, monitor);

				data.projectsById.put(project.getId(), project);
				data.projectsByKey.put(project.getKey(), project);
				Policy.advance(monitor, 1);
			}
		} finally {
			monitor.done();
		}
	}

	private void initializeProject(Project project, IProgressMonitor monitor) throws JiraException {
		synchronized (project) {
			monitor.subTask(NLS.bind(Messages.JiraClientCache_project_details_for, project.getKey()));

			final String version = data.serverInfo.getVersion();

			project.setComponents(jiraClient.getComponents(project.getKey(), Policy.subMonitorFor(monitor, 0)));
			project.setVersions(jiraClient.getVersions(project.getKey(), Policy.subMonitorFor(monitor, 0)));
			project.setVersions(jiraClient.getVersions(project.getKey(), monitor));

			if (supportsPerProjectIssueTypes(version) >= 0) {
				IssueType[] issueTypes = jiraClient.getIssueTypes(project.getId(), Policy.subMonitorFor(monitor, 0));
				IssueType[] subTaskIssueTypes = jiraClient.getSubTaskIssueTypes(project.getId(), Policy.subMonitorFor(
						monitor, 1));
				for (IssueType issueType : subTaskIssueTypes) {
					issueType.setSubTaskType(true);
				}

			}
			if (new JiraVersion(version).compareTo(JiraVersion.JIRA_3_13) >= 0) {
				try {
					SecurityLevel[] securityLevels = jiraClient.getAvailableSecurityLevels(project.getKey(),
							Policy.subMonitorFor(monitor, 0));
					if (securityLevels.length > 0) {
						SecurityLevel[] projectSecurityLevels = new SecurityLevel[securityLevels.length + 1];
						projectSecurityLevels[0] = SecurityLevel.NONE;

					project.setSecurityLevels(null);
				}
			}

			data.projectsById.put(project.getId(), project);
			data.projectsByKey.put(project.getKey(), project);
		}
	}


	}

	private void initializePriorities(JiraClientData data, IProgressMonitor monitor) throws JiraException {
		monitor = Policy.monitorFor(monitor);
		try {
			monitor.beginTask(Messages.JiraClientCache_getting_priorities, 1);
			data.priorities = jiraClient.getPriorities(monitor);
			data.prioritiesById = new HashMap<String, Priority>(data.priorities.length);
			for (Priority priority : data.priorities) {
				data.prioritiesById.put(priority.getId(), priority);
			}
		} finally {
			monitor.done();
		}
	}


	}

	private void initializeIssueTypes(JiraClientData data, IProgressMonitor monitor) throws JiraException {
		monitor = Policy.monitorFor(monitor);
		try {
			monitor.beginTask(Messages.JiraClientCache_getting_issue_types, 2);

			String version = data.serverInfo.getVersion();
			if (supportsPerProjectIssueTypes(version) >= 0) {
				// collect issue types from all projects to avoid additional SOAP request
				Set<IssueType> issueTypes = new HashSet<IssueType>();
				for (Project project : data.projects) {
					IssueType[] projectIssueTypes = project.getIssueTypes();
					if (projectIssueTypes != null) {
						issueTypes.addAll(Arrays.asList(projectIssueTypes));
					}
				}
			}

				data.issueTypes = issueTypes.toArray(new IssueType[0]);
				data.issueTypesById = new HashMap<String, IssueType>(data.issueTypes.length);
				for (IssueType issueType : data.issueTypes) {
					data.issueTypesById.put(issueType.getId(), issueType);
				}
		} else {
			IssueType[] issueTypes = jiraClient.getIssueTypes(monitor);
			IssueType[] subTaskIssueTypes;
			if (new JiraVersion(version).compareTo(JiraVersion.JIRA_3_3) >= 0) {
				subTaskIssueTypes = jiraClient.getSubTaskIssueTypes(monitor);
			} else {
				IssueType[] issueTypes = jiraClient.getIssueTypes(Policy.subMonitorFor(monitor, 1));
				IssueType[] subTaskIssueTypes;
				if (new JiraVersion(version).compareTo(JiraVersion.JIRA_3_3) >= 0) {
					subTaskIssueTypes = jiraClient.getSubTaskIssueTypes(Policy.subMonitorFor(monitor, 1));
				} else {
					subTaskIssueTypes = new IssueType[0];
				}

				data.issueTypesById = new HashMap<String, IssueType>(issueTypes.length + subTaskIssueTypes.length);

				for (IssueType issueType : issueTypes) {
					data.issueTypesById.put(issueType.getId(), issueType);
				}

				for (IssueType issueType : subTaskIssueTypes) {
					issueType.setSubTaskType(true);
					data.issueTypesById.put(issueType.getId(), issueType);
				}

				data.issueTypes = new IssueType[issueTypes.length + subTaskIssueTypes.length];
				System.arraycopy(issueTypes, 0, data.issueTypes, 0, issueTypes.length);
				System.arraycopy(subTaskIssueTypes, 0, data.issueTypes, issueTypes.length, subTaskIssueTypes.length);
			}
		} finally {
			monitor.done();
		}
	}

	private void initializeStatuses(JiraClientData data, IProgressMonitor monitor) throws JiraException {
		monitor = Policy.monitorFor(monitor);
		try {
			monitor.beginTask(Messages.JiraClientCache_getting_statuses, 1);

			data.statuses = jiraClient.getStatuses(Policy.subMonitorFor(monitor, 1));
			data.statusesById = new HashMap<String, JiraStatus>(data.statuses.length);
			for (JiraStatus status : data.statuses) {
				data.statusesById.put(status.getId(), status);
			}
		} finally {
			monitor.done();
		}
	}

	private void initializeResolutions(JiraClientData data, IProgressMonitor monitor) throws JiraException {
		monitor = Policy.monitorFor(monitor);
		try {
			monitor.beginTask(Messages.JiraClientCache_getting_resolutions, 1);
			data.resolutions = jiraClient.getResolutions(monitor);
			data.resolutionsById = new HashMap<String, Resolution>(data.resolutions.length);
			for (Resolution resolution : data.resolutions) {
				data.resolutionsById.put(resolution.getId(), resolution);
			}
		} finally {
			monitor.done();
		}

	}

	public Resolution getResolutionById(String id) {

		return data;
	}

	public synchronized void refreshProjectDetails(String projectId, IProgressMonitor monitor) throws JiraException {
		Project project = getProjectById(projectId);
		if (project != null) {
			try {
				monitor.beginTask(Messages.JiraClientCache_getting_project_details, 100);
				initializeProject(project, monitor);
			} finally {
				monitor.done();
			}
		} else {
			refreshDetails(monitor);
		}
	}

	public synchronized void refreshDetails(IProgressMonitor monitor) throws JiraException {
		try {
			monitor = Policy.monitorFor(monitor);
			monitor.beginTask(Messages.JiraClientCache_Updating_repository_configuration, 1500);

			final JiraClientData newData = new JiraClientData();

			monitor.subTask(Messages.JiraClientCache_getting_server_info);
			IProgressMonitor submonitor = Policy.subMonitorFor(monitor, 100);
			try {
				submonitor.beginTask(Messages.JiraClientCache_getting_server_info, 1);
				data.serverInfo = newData.serverInfo = jiraClient.getServerInfo(submonitor);
			} finally {
				submonitor.done();
			}

			monitor.subTask(Messages.JiraClientCache_getting_project_details);
			submonitor = Policy.subMonitorFor(monitor, 1000);
			try {
				initializeProjects(newData, submonitor);
			} finally {
				submonitor.done();
			}

			monitor.subTask(Messages.JiraClientCache_getting_priorities);
			submonitor = Policy.subMonitorFor(monitor, 100);
			try {
				initializePriorities(newData, submonitor);
			} finally {
				submonitor.done();
			}

			monitor.subTask(Messages.JiraClientCache_getting_issue_types);
			submonitor = Policy.subMonitorFor(monitor, 100);
			try {
				initializeIssueTypes(newData, submonitor);
			} finally {
				submonitor.done();
			}

			monitor.subTask(Messages.JiraClientCache_getting_resolutions);
			submonitor = Policy.subMonitorFor(monitor, 100);
			try {
				initializeResolutions(newData, submonitor);
			} finally {
				submonitor.done();
			}

			monitor.subTask(Messages.JiraClientCache_getting_statuses);
			submonitor = Policy.subMonitorFor(monitor, 100);
			try {
				initializeStatuses(newData, submonitor);
			} finally {
				submonitor.done();
			}

			Policy.advance(monitor, 1);
			initializeProjects(newData, monitor);
			Policy.advance(monitor, 1);
			initializePriorities(newData, monitor);
			Policy.advance(monitor, 1);
			initializeIssueTypes(newData, monitor);
			Policy.advance(monitor, 1);
			initializeResolutions(newData, monitor);
			Policy.advance(monitor, 1);
			initializeStatuses(newData, monitor);
			Policy.advance(monitor, 1);

			newData.lastUpdate = System.currentTimeMillis();
			this.data = newData;

Lines 9-12 Link Here

(-)src/org/eclipse/mylyn/internal/jira/core/service/messages.properties (-1 / +8 lines)
9	# Tasktop Technologies - initial API and implementation	9	# Tasktop Technologies - initial API and implementation
10	###############################################################################	10	###############################################################################
11	JiraClientCache_Getting_server_information=Getting server information	11	JiraClientCache_Getting_server_information=Getting server information
12	JiraClientCache_Updating_repository_configuration=Updating repository configuration	12	JiraClientCache_Updating_repository_configuration=Updating repository configuration (may take even 15 minutes)
		13	JiraClientCache_getting_issue_types=Getting issue types
		14	JiraClientCache_getting_priorities=Getting priorities
		15	JiraClientCache_getting_project_details=Getting project details
		16	JiraClientCache_getting_resolutions=Gettings resolutions
		17	JiraClientCache_getting_server_info=Getting server info
		18	JiraClientCache_getting_statuses=Getting statuses
		19	JiraClientCache_project_details_for=Getting project details for {0}




	public static String JiraClientCache_Getting_server_information;

	public static String JiraClientCache_Updating_repository_configuration;

	public static String JiraClientCache_getting_issue_types;

	public static String JiraClientCache_getting_priorities;

	public static String JiraClientCache_getting_project_details;

	public static String JiraClientCache_getting_resolutions;

	public static String JiraClientCache_getting_server_info;

	public static String JiraClientCache_getting_statuses;

	public static String JiraClientCache_project_details_for;

}




	}

	@Override
	public void updateTaskConfiguration(TaskRepository taskRepository, TaskData task, IProgressMonitor monitor)
			throws CoreException {
		try {
			JiraClient client = JiraClientFactory.getDefault().getJiraClient(taskRepository);
			client.getCache().refreshProjectDetails(task.getRoot().getAttribute(JiraAttribute.PROJECT.id()).getValue(),
					monitor);
		} catch (JiraException e) {
			IStatus status = JiraCorePlugin.toStatus(taskRepository, e);
			trace(status);
			throw new CoreException(status);
		}
	}

	@Override
	public String getTaskIdPrefix() {
		return "issue"; //$NON-NLS-1$
	}




			@Override
			public void run() {
				getTaskEditorPage().showEditorBusy(true);
				final TaskJob job = TasksUiInternal.getJobFactory().createUpdateTaskConfigurationJob(
						getTaskEditorPage().getConnector(), getTaskEditorPage().getTaskRepository(),
						getTaskEditorPage().getModel().getTaskData());
				job.addJobChangeListener(new JobChangeAdapter() {
					@Override
					public void done(IJobChangeEvent event) {

							public void run() {
								getTaskEditorPage().showEditorBusy(false);
								if (job.getStatus() != null) {
									getTaskEditorPage().getTaskEditor().setStatus(
											Messages.TaskEditorAttributePart_Updating_of_task_configuration_failed,
											Messages.TaskEditorAttributePart_Update_Failed, job.getStatus());
													Messages.TaskEditorAttributePart_Update_Failed, job.getStatus());
								} else {
									getTaskEditorPage().refreshFormContent();
								}

Lines 63-68 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/editors/messages.properties (+1 lines)
63	TaskEditorAttributePart_Refresh_Attributes=Refresh Attributes	63	TaskEditorAttributePart_Refresh_Attributes=Refresh Attributes
64	TaskEditorAttributePart_Update_Failed=Update Failed	64	TaskEditorAttributePart_Update_Failed=Update Failed
65	TaskEditorAttributePart_Updating_of_repository_configuration_failed=Updating of repository configuration failed	65	TaskEditorAttributePart_Updating_of_repository_configuration_failed=Updating of repository configuration failed
		66	TaskEditorAttributePart_Updating_of_task_configuration_failed=Updating of task configuration failed
66		67
67	TaskEditorCommentPart_0=\ (	68	TaskEditorCommentPart_0=\ (
68	TaskEditorCommentPart_1=)	69	TaskEditorCommentPart_1=)

Lines 250-253 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/editors/Messages.java (+2 lines)
250	public static String TaskEditorExtensionSettingsContribution_Plain_Text;	250	public static String TaskEditorExtensionSettingsContribution_Plain_Text;
251		251
252	public static String TaskEditorExtensionSettingsContribution_Select_the_capabilities_of_the_task_editor;	252	public static String TaskEditorExtensionSettingsContribution_Select_the_capabilities_of_the_task_editor;
		253
		254	public static String TaskEditorAttributePart_Updating_of_task_configuration_failed;
253	}	255	}

Lines 41-46 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/messages.properties (+1 lines)
41		41
42	TaskJobFactory_Receiving_configuration=Receiving configuration	42	TaskJobFactory_Receiving_configuration=Receiving configuration
43	TaskJobFactory_Refreshing_repository_configuration=Refreshing repository configuration	43	TaskJobFactory_Refreshing_repository_configuration=Refreshing repository configuration
		44	TaskJobFactory_Refreshing_task_configuration=Refreshing task configuration
44		45
45	TaskListBackupManager_Error_occured_during_scheduled_tasklist_backup=Error occured during scheduled tasklist backup.\nCheck settings on Tasklist preferences page.	46	TaskListBackupManager_Error_occured_during_scheduled_tasklist_backup=Error occured during scheduled tasklist backup.\nCheck settings on Tasklist preferences page.
46	TaskListBackupManager_Scheduled_task_data_backup=Scheduled task data backup	47	TaskListBackupManager_Scheduled_task_data_backup=Scheduled task data backup

Lines 125-128 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/Messages.java (+1 lines)
125		125
126	public static String AbstractRetrieveTitleFromUrlJob_Retrieving_summary_from_URL;	126	public static String AbstractRetrieveTitleFromUrlJob_Retrieving_summary_from_URL;
127		127
		128	public static String TaskJobFactory_Refreshing_task_configuration;
128	}	129	}




		return updateJob;
	}

	public TaskJob createUpdateTaskConfigurationJob(final AbstractRepositoryConnector connector,
			final TaskRepository taskRepository, final TaskData task) {
		TaskJob updateJob = new TaskJob(Messages.TaskJobFactory_Refreshing_task_configuration) {
			private IStatus error;

			@Override
			protected IStatus run(IProgressMonitor monitor) {
				monitor.beginTask(Messages.TaskJobFactory_Receiving_configuration, IProgressMonitor.UNKNOWN);
				try {
					try {
						connector.updateTaskConfiguration(taskRepository, task, monitor);
					} catch (CoreException e) {
						error = e.getStatus();
					}
				} finally {
					monitor.done();
				}
				return Status.OK_STATUS;
			}

			@Override
			public boolean belongsTo(Object family) {
				return family == taskRepository;
			}

			@Override
			public IStatus getStatus() {
				return error;
			}
		};
		updateJob.setPriority(Job.INTERACTIVE);
		return updateJob;
	}

	public SubmitJob createSubmitTaskAttachmentJob(AbstractRepositoryConnector connector,
			TaskRepository taskRepository, final ITask task, AbstractTaskAttachmentSource source, String comment,
			TaskAttribute attachmentAttribute) {





/**
 * Encapsulates common operations that can be performed on a task repository. Extend to connect with a Java API or WS
 * API for accessing the repository. Only methods that take a progress monitor can do network I/O.
 * 
 * Only methods that take a progress monitor can do network I/O.
 * 
 * @author Mik Kersten
 * @author Rob Elves

	/**
	 * Runs <code>query</code> on <code>repository</code>, results are passed to <code>collector</code>. If a repository
	 * does not return the full task data for a result, {@link TaskData#isPartial()} will return true.
	 * 
	 * <p>
	 * Implementors must complete executing <code>query</code> before returning from this method.
	 * 

	 */
	public abstract void updateTaskFromTaskData(TaskRepository taskRepository, ITask task, TaskData taskData);

	/**
	 * @throws CoreException
	 * @since 3.3
	 */
	public void updateTaskConfiguration(TaskRepository taskRepository, TaskData task, IProgressMonitor monitor)
			throws CoreException {
		updateRepositoryConfiguration(taskRepository, monitor);
	}

}

Lines 43-48 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/core/ITaskJobFactory.java (+3 lines)
43	public abstract TaskJob createUpdateRepositoryConfigurationJob(AbstractRepositoryConnector connector,	43	public abstract TaskJob createUpdateRepositoryConfigurationJob(AbstractRepositoryConnector connector,
44	TaskRepository taskRepository);	44	TaskRepository taskRepository);
45		45
		46	public abstract TaskJob createUpdateTaskConfigurationJob(AbstractRepositoryConnector connector,
		47	TaskRepository taskRepository, TaskData task);
		48
46	public abstract SubmitJob createSubmitTaskAttachmentJob(AbstractRepositoryConnector connector,	49	public abstract SubmitJob createSubmitTaskAttachmentJob(AbstractRepositoryConnector connector,
47	TaskRepository taskRepository, ITask task, AbstractTaskAttachmentSource source, String comment,	50	TaskRepository taskRepository, ITask task, AbstractTaskAttachmentSource source, String comment,
48	TaskAttribute attachmentAttribute);	51	TaskAttribute attachmentAttribute);

Return to bug 290490

Lines 418-423 Link Here

(-)src/org/eclipse/mylyn/internal/jira/core/JiraRepositoryConnector.java (+14 lines)
418	}	418	}
419		419
420	@Override	420	@Override
		421	public void updateTaskConfiguration(TaskRepository taskRepository, TaskData task, IProgressMonitor monitor)
		422	throws CoreException {
		423	try {
		424	JiraClient client = JiraClientFactory.getDefault().getJiraClient(taskRepository);
		425	client.getCache().refreshProjectDetails(task.getRoot().getAttribute(JiraAttribute.PROJECT.id()).getValue(),
		426	monitor);
		427	} catch (JiraException e) {
		428	IStatus status = JiraCorePlugin.toStatus(taskRepository, e);
		429	trace(status);
		430	throw new CoreException(status);
		431	}
		432	}
		433
		434	@Override
421	public String getTaskIdPrefix() {	435	public String getTaskIdPrefix() {
422	return "issue"; //$NON-NLS-1$	436	return "issue"; //$NON-NLS-1$
423	}	437	}

Lines 229-236 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/editors/TaskEditorAttributePart.java (-6 / +6 lines)
229	@Override	229	@Override
230	public void run() {	230	public void run() {
231	getTaskEditorPage().showEditorBusy(true);	231	getTaskEditorPage().showEditorBusy(true);
232	final TaskJob job = TasksUiInternal.getJobFactory().createUpdateRepositoryConfigurationJob(	232	final TaskJob job = TasksUiInternal.getJobFactory().createUpdateTaskConfigurationJob(
233	getTaskEditorPage().getConnector(), getTaskEditorPage().getTaskRepository());	233	getTaskEditorPage().getConnector(), getTaskEditorPage().getTaskRepository(),
		234	getTaskEditorPage().getModel().getTaskData());
234	job.addJobChangeListener(new JobChangeAdapter() {	235	job.addJobChangeListener(new JobChangeAdapter() {
235	@Override	236	@Override
236	public void done(IJobChangeEvent event) {	237	public void done(IJobChangeEvent event) {
Lines 238-247 Link Here
238	public void run() {	239	public void run() {
239	getTaskEditorPage().showEditorBusy(false);	240	getTaskEditorPage().showEditorBusy(false);
240	if (job.getStatus() != null) {	241	if (job.getStatus() != null) {
241	getTaskEditorPage().getTaskEditor()	242	getTaskEditorPage().getTaskEditor().setStatus(
242	.setStatus(	243	Messages.TaskEditorAttributePart_Updating_of_task_configuration_failed,
243	Messages.TaskEditorAttributePart_Updating_of_repository_configuration_failed,	244	Messages.TaskEditorAttributePart_Update_Failed, job.getStatus());
244	Messages.TaskEditorAttributePart_Update_Failed, job.getStatus());
245	} else {	245	} else {
246	getTaskEditorPage().refreshFormContent();	246	getTaskEditorPage().refreshFormContent();
247	}	247	}

Lines 161-166 Link Here

(-)src/org/eclipse/mylyn/internal/tasks/ui/TaskJobFactory.java (+34 lines)
161	return updateJob;	161	return updateJob;
162	}	162	}
163		163
		164	public TaskJob createUpdateTaskConfigurationJob(final AbstractRepositoryConnector connector,
		165	final TaskRepository taskRepository, final TaskData task) {
		166	TaskJob updateJob = new TaskJob(Messages.TaskJobFactory_Refreshing_task_configuration) {
		167	private IStatus error;
		168
		169	@Override
		170	protected IStatus run(IProgressMonitor monitor) {
		171	monitor.beginTask(Messages.TaskJobFactory_Receiving_configuration, IProgressMonitor.UNKNOWN);
		172	try {
		173	try {
		174	connector.updateTaskConfiguration(taskRepository, task, monitor);
		175	} catch (CoreException e) {
		176	error = e.getStatus();
		177	}
		178	} finally {
		179	monitor.done();
		180	}
		181	return Status.OK_STATUS;
		182	}
		183
		184	@Override
		185	public boolean belongsTo(Object family) {
		186	return family == taskRepository;
		187	}
		188
		189	@Override
		190	public IStatus getStatus() {
		191	return error;
		192	}
		193	};
		194	updateJob.setPriority(Job.INTERACTIVE);
		195	return updateJob;
		196	}
		197
164	public SubmitJob createSubmitTaskAttachmentJob(AbstractRepositoryConnector connector,	198	public SubmitJob createSubmitTaskAttachmentJob(AbstractRepositoryConnector connector,
165	TaskRepository taskRepository, final ITask task, AbstractTaskAttachmentSource source, String comment,	199	TaskRepository taskRepository, final ITask task, AbstractTaskAttachmentSource source, String comment,
166	TaskAttribute attachmentAttribute) {	200	TaskAttribute attachmentAttribute) {

Lines 29-37 Link Here

(-)src/org/eclipse/mylyn/tasks/core/AbstractRepositoryConnector.java (-4 / +10 lines)
29		29
30	/**	30	/**
31	* Encapsulates common operations that can be performed on a task repository. Extend to connect with a Java API or WS	31	* Encapsulates common operations that can be performed on a task repository. Extend to connect with a Java API or WS
32	* API for accessing the repository.	32	* API for accessing the repository. Only methods that take a progress monitor can do network I/O.
33	*
34	* Only methods that take a progress monitor can do network I/O.
35	*	33	*
36	* @author Mik Kersten	34	* @author Mik Kersten
37	* @author Rob Elves	35	* @author Rob Elves
Lines 226-232 Link Here
226	/**	224	/**
227	* Runs <code>query</code> on <code>repository</code>, results are passed to <code>collector</code>. If a repository	225	* Runs <code>query</code> on <code>repository</code>, results are passed to <code>collector</code>. If a repository
228	* does not return the full task data for a result, {@link TaskData#isPartial()} will return true.	226	* does not return the full task data for a result, {@link TaskData#isPartial()} will return true.
229	*
230	* <p>	227	* <p>
231	* Implementors must complete executing <code>query</code> before returning from this method.	228	* Implementors must complete executing <code>query</code> before returning from this method.
232	*	229	*
Lines 298-301 Link Here
298	*/	295	*/
299	public abstract void updateTaskFromTaskData(TaskRepository taskRepository, ITask task, TaskData taskData);	296	public abstract void updateTaskFromTaskData(TaskRepository taskRepository, ITask task, TaskData taskData);
300		297
		298	/**
		299	* @throws CoreException
		300	* @since 3.3
		301	*/
		302	public void updateTaskConfiguration(TaskRepository taskRepository, TaskData task, IProgressMonitor monitor)
		303	throws CoreException {
		304	updateRepositoryConfiguration(taskRepository, monitor);
		305	}
		306
301	}	307	}

Lines 27-32 Link Here

(-)src/org/eclipse/mylyn/internal/jira/core/service/JiraClientCache.java (-75 / +168 lines)
27	import org.eclipse.mylyn.internal.jira.core.model.SecurityLevel;	27	import org.eclipse.mylyn.internal.jira.core.model.SecurityLevel;
28	import org.eclipse.mylyn.internal.jira.core.model.ServerInfo;	28	import org.eclipse.mylyn.internal.jira.core.model.ServerInfo;
29	import org.eclipse.mylyn.internal.jira.core.model.User;	29	import org.eclipse.mylyn.internal.jira.core.model.User;
		30	import org.eclipse.osgi.util.NLS;
30		31
31	/**	32	/**
32	* @author Steffen Pingel	33	* @author Steffen Pingel
Lines 64-83 Link Here
64	}	65	}
65		66
66	private void initializeProjects(JiraClientData data, IProgressMonitor monitor) throws JiraException {	67	private void initializeProjects(JiraClientData data, IProgressMonitor monitor) throws JiraException {
67	String version = data.serverInfo.getVersion();	68	monitor = Policy.monitorFor(monitor);
68		69
69	data.projects = jiraClient.getProjects(monitor);	70	data.projects = jiraClient.getProjects(monitor);
70		71
71	data.projectsById = new HashMap<String, Project>(data.projects.length);	72	try {
72	data.projectsByKey = new HashMap<String, Project>(data.projects.length);	73	monitor.beginTask(Messages.JiraClientCache_getting_project_details, data.projects.length);
		74
		75	data.projectsById = new HashMap<String, Project>(data.projects.length);
		76	data.projectsByKey = new HashMap<String, Project>(data.projects.length);
		77
		78	for (Project project : data.projects) {
		79	initializeProject(project, monitor);
		80
		81	data.projectsById.put(project.getId(), project);
		82	data.projectsByKey.put(project.getKey(), project);
		83	Policy.advance(monitor, 1);
		84	}
		85	} finally {
		86	monitor.done();
		87	}
		88	}
		89
		90	private void initializeProject(Project project, IProgressMonitor monitor) throws JiraException {
		91	synchronized (project) {
		92	monitor.subTask(NLS.bind(Messages.JiraClientCache_project_details_for, project.getKey()));
		93
		94	final String version = data.serverInfo.getVersion();
73		95
74	for (Project project : data.projects) {	96	project.setComponents(jiraClient.getComponents(project.getKey(), Policy.subMonitorFor(monitor, 0)));
75	project.setComponents(jiraClient.getComponents(project.getKey(), monitor));	97	project.setVersions(jiraClient.getVersions(project.getKey(), Policy.subMonitorFor(monitor, 0)));
76	project.setVersions(jiraClient.getVersions(project.getKey(), monitor));
77		98
78	if (supportsPerProjectIssueTypes(version) >= 0) {	99	if (supportsPerProjectIssueTypes(version) >= 0) {
79	IssueType[] issueTypes = jiraClient.getIssueTypes(project.getId(), monitor);	100	IssueType[] issueTypes = jiraClient.getIssueTypes(project.getId(), Policy.subMonitorFor(monitor, 0));
80	IssueType[] subTaskIssueTypes = jiraClient.getSubTaskIssueTypes(project.getId(), monitor);	101	IssueType[] subTaskIssueTypes = jiraClient.getSubTaskIssueTypes(project.getId(), Policy.subMonitorFor(
		102	monitor, 1));
81	for (IssueType issueType : subTaskIssueTypes) {	103	for (IssueType issueType : subTaskIssueTypes) {
82	issueType.setSubTaskType(true);	104	issueType.setSubTaskType(true);
83	}	105	}
Lines 90-96 Link Here
90	}	112	}
91	if (new JiraVersion(version).compareTo(JiraVersion.JIRA_3_13) >= 0) {	113	if (new JiraVersion(version).compareTo(JiraVersion.JIRA_3_13) >= 0) {
92	try {	114	try {
93	SecurityLevel[] securityLevels = jiraClient.getAvailableSecurityLevels(project.getKey(), monitor);	115	SecurityLevel[] securityLevels = jiraClient.getAvailableSecurityLevels(project.getKey(),
		116	Policy.subMonitorFor(monitor, 0));
94	if (securityLevels.length > 0) {	117	if (securityLevels.length > 0) {
95	SecurityLevel[] projectSecurityLevels = new SecurityLevel[securityLevels.length + 1];	118	SecurityLevel[] projectSecurityLevels = new SecurityLevel[securityLevels.length + 1];
96	projectSecurityLevels[0] = SecurityLevel.NONE;	119	projectSecurityLevels[0] = SecurityLevel.NONE;
Lines 102-110 Link Here
102	project.setSecurityLevels(null);	125	project.setSecurityLevels(null);
103	}	126	}
104	}	127	}
105
106	data.projectsById.put(project.getId(), project);
107	data.projectsByKey.put(project.getKey(), project);
108	}	128	}
109	}	129	}
110		130
Lines 121-130 Link Here
121	}	141	}
122		142
123	private void initializePriorities(JiraClientData data, IProgressMonitor monitor) throws JiraException {	143	private void initializePriorities(JiraClientData data, IProgressMonitor monitor) throws JiraException {
124	data.priorities = jiraClient.getPriorities(monitor);	144	monitor = Policy.monitorFor(monitor);
125	data.prioritiesById = new HashMap<String, Priority>(data.priorities.length);	145	try {
126	for (Priority priority : data.priorities) {	146	monitor.beginTask(Messages.JiraClientCache_getting_priorities, 1);
127	data.prioritiesById.put(priority.getId(), priority);	147	data.priorities = jiraClient.getPriorities(monitor);
		148	data.prioritiesById = new HashMap<String, Priority>(data.priorities.length);
		149	for (Priority priority : data.priorities) {
		150	data.prioritiesById.put(priority.getId(), priority);
		151	}
		152	} finally {
		153	monitor.done();
128	}	154	}
129	}	155	}
130		156
Lines 137-198 Link Here
137	}	163	}
138		164
139	private void initializeIssueTypes(JiraClientData data, IProgressMonitor monitor) throws JiraException {	165	private void initializeIssueTypes(JiraClientData data, IProgressMonitor monitor) throws JiraException {
140	String version = data.serverInfo.getVersion();	166	monitor = Policy.monitorFor(monitor);
141	if (supportsPerProjectIssueTypes(version) >= 0) {	167	try {
142	// collect issue types from all projects to avoid additional SOAP request	168	monitor.beginTask(Messages.JiraClientCache_getting_issue_types, 2);
143	Set<IssueType> issueTypes = new HashSet<IssueType>();	169
144	for (Project project : data.projects) {	170	String version = data.serverInfo.getVersion();
145	IssueType[] projectIssueTypes = project.getIssueTypes();	171	if (supportsPerProjectIssueTypes(version) >= 0) {
146	if (projectIssueTypes != null) {	172	// collect issue types from all projects to avoid additional SOAP request
147	issueTypes.addAll(Arrays.asList(projectIssueTypes));	173	Set<IssueType> issueTypes = new HashSet<IssueType>();
		174	for (Project project : data.projects) {
		175	IssueType[] projectIssueTypes = project.getIssueTypes();
		176	if (projectIssueTypes != null) {
		177	issueTypes.addAll(Arrays.asList(projectIssueTypes));
		178	}
148	}	179	}
149	}
150		180
151	data.issueTypes = issueTypes.toArray(new IssueType[0]);	181	data.issueTypes = issueTypes.toArray(new IssueType[0]);
152	data.issueTypesById = new HashMap<String, IssueType>(data.issueTypes.length);	182	data.issueTypesById = new HashMap<String, IssueType>(data.issueTypes.length);
153	for (IssueType issueType : data.issueTypes) {	183	for (IssueType issueType : data.issueTypes) {
154	data.issueTypesById.put(issueType.getId(), issueType);	184	data.issueTypesById.put(issueType.getId(), issueType);
155	}	185	}
156	} else {
157	IssueType[] issueTypes = jiraClient.getIssueTypes(monitor);
158	IssueType[] subTaskIssueTypes;
159	if (new JiraVersion(version).compareTo(JiraVersion.JIRA_3_3) >= 0) {
160	subTaskIssueTypes = jiraClient.getSubTaskIssueTypes(monitor);
161	} else {	186	} else {
162	subTaskIssueTypes = new IssueType[0];	187	IssueType[] issueTypes = jiraClient.getIssueTypes(Policy.subMonitorFor(monitor, 1));
163	}	188	IssueType[] subTaskIssueTypes;
		189	if (new JiraVersion(version).compareTo(JiraVersion.JIRA_3_3) >= 0) {
		190	subTaskIssueTypes = jiraClient.getSubTaskIssueTypes(Policy.subMonitorFor(monitor, 1));
		191	} else {
		192	subTaskIssueTypes = new IssueType[0];
		193	}
164		194
165	data.issueTypesById = new HashMap<String, IssueType>(issueTypes.length + subTaskIssueTypes.length);	195	data.issueTypesById = new HashMap<String, IssueType>(issueTypes.length + subTaskIssueTypes.length);
166		196
167	for (IssueType issueType : issueTypes) {	197	for (IssueType issueType : issueTypes) {
168	data.issueTypesById.put(issueType.getId(), issueType);	198	data.issueTypesById.put(issueType.getId(), issueType);
169	}	199	}
170		200
171	for (IssueType issueType : subTaskIssueTypes) {	201	for (IssueType issueType : subTaskIssueTypes) {
172	issueType.setSubTaskType(true);	202	issueType.setSubTaskType(true);
173	data.issueTypesById.put(issueType.getId(), issueType);	203	data.issueTypesById.put(issueType.getId(), issueType);
174	}	204	}
175		205
176	data.issueTypes = new IssueType[issueTypes.length + subTaskIssueTypes.length];	206	data.issueTypes = new IssueType[issueTypes.length + subTaskIssueTypes.length];
177	System.arraycopy(issueTypes, 0, data.issueTypes, 0, issueTypes.length);	207	System.arraycopy(issueTypes, 0, data.issueTypes, 0, issueTypes.length);
178	System.arraycopy(subTaskIssueTypes, 0, data.issueTypes, issueTypes.length, subTaskIssueTypes.length);	208	System.arraycopy(subTaskIssueTypes, 0, data.issueTypes, issueTypes.length, subTaskIssueTypes.length);
		209	}
		210	} finally {
		211	monitor.done();
179	}	212	}
180	}	213	}
181		214
182	private void initializeStatuses(JiraClientData data, IProgressMonitor monitor) throws JiraException {	215	private void initializeStatuses(JiraClientData data, IProgressMonitor monitor) throws JiraException {
183	data.statuses = jiraClient.getStatuses(monitor);	216	monitor = Policy.monitorFor(monitor);
184	data.statusesById = new HashMap<String, JiraStatus>(data.statuses.length);	217	try {
185	for (JiraStatus status : data.statuses) {	218	monitor.beginTask(Messages.JiraClientCache_getting_statuses, 1);
186	data.statusesById.put(status.getId(), status);	219
		220	data.statuses = jiraClient.getStatuses(Policy.subMonitorFor(monitor, 1));
		221	data.statusesById = new HashMap<String, JiraStatus>(data.statuses.length);
		222	for (JiraStatus status : data.statuses) {
		223	data.statusesById.put(status.getId(), status);
		224	}
		225	} finally {
		226	monitor.done();
187	}	227	}
188	}	228	}
189		229
190	private void initializeResolutions(JiraClientData data, IProgressMonitor monitor) throws JiraException {	230	private void initializeResolutions(JiraClientData data, IProgressMonitor monitor) throws JiraException {
191	data.resolutions = jiraClient.getResolutions(monitor);	231	monitor = Policy.monitorFor(monitor);
192	data.resolutionsById = new HashMap<String, Resolution>(data.resolutions.length);	232	try {
193	for (Resolution resolution : data.resolutions) {	233	monitor.beginTask(Messages.JiraClientCache_getting_resolutions, 1);
194	data.resolutionsById.put(resolution.getId(), resolution);	234	data.resolutions = jiraClient.getResolutions(monitor);
		235	data.resolutionsById = new HashMap<String, Resolution>(data.resolutions.length);
		236	for (Resolution resolution : data.resolutions) {
		237	data.resolutionsById.put(resolution.getId(), resolution);
		238	}
		239	} finally {
		240	monitor.done();
195	}	241	}
		242
196	}	243	}
197		244
198	public Resolution getResolutionById(String id) {	245	public Resolution getResolutionById(String id) {
Lines 211-239 Link Here
211	return data;	258	return data;
212	}	259	}
213		260
		261	public synchronized void refreshProjectDetails(String projectId, IProgressMonitor monitor) throws JiraException {
		262	Project project = getProjectById(projectId);
		263	if (project != null) {
		264	try {
		265	monitor.beginTask(Messages.JiraClientCache_getting_project_details, 100);
		266	initializeProject(project, monitor);
		267	} finally {
		268	monitor.done();
		269	}
		270	} else {
		271	refreshDetails(monitor);
		272	}
		273	}
		274
214	public synchronized void refreshDetails(IProgressMonitor monitor) throws JiraException {	275	public synchronized void refreshDetails(IProgressMonitor monitor) throws JiraException {
215	try {	276	try {
216	monitor = Policy.monitorFor(monitor);	277	monitor = Policy.monitorFor(monitor);
		278	monitor.beginTask(Messages.JiraClientCache_Updating_repository_configuration, 1500);
		279
		280	final JiraClientData newData = new JiraClientData();
		281
		282	monitor.subTask(Messages.JiraClientCache_getting_server_info);
		283	IProgressMonitor submonitor = Policy.subMonitorFor(monitor, 100);
		284	try {
		285	submonitor.beginTask(Messages.JiraClientCache_getting_server_info, 1);
		286	data.serverInfo = newData.serverInfo = jiraClient.getServerInfo(submonitor);
		287	} finally {
		288	submonitor.done();
		289	}
		290
		291	monitor.subTask(Messages.JiraClientCache_getting_project_details);
		292	submonitor = Policy.subMonitorFor(monitor, 1000);
		293	try {
		294	initializeProjects(newData, submonitor);
		295	} finally {
		296	submonitor.done();
		297	}
		298
		299	monitor.subTask(Messages.JiraClientCache_getting_priorities);
		300	submonitor = Policy.subMonitorFor(monitor, 100);
		301	try {
		302	initializePriorities(newData, submonitor);
		303	} finally {
		304	submonitor.done();
		305	}
		306
		307	monitor.subTask(Messages.JiraClientCache_getting_issue_types);
		308	submonitor = Policy.subMonitorFor(monitor, 100);
		309	try {
		310	initializeIssueTypes(newData, submonitor);
		311	} finally {
		312	submonitor.done();
		313	}
		314
		315	monitor.subTask(Messages.JiraClientCache_getting_resolutions);
		316	submonitor = Policy.subMonitorFor(monitor, 100);
		317	try {
		318	initializeResolutions(newData, submonitor);
		319	} finally {
		320	submonitor.done();
		321	}
217		322
218	// use UNKNOWN since some of the update operations block for a long time	323	monitor.subTask(Messages.JiraClientCache_getting_statuses);
219	// TODO use InfiniteSubProgressMonitor	324	submonitor = Policy.subMonitorFor(monitor, 100);
220	monitor.beginTask(Messages.JiraClientCache_Updating_repository_configuration, IProgressMonitor.UNKNOWN);	325	try {
221		326	initializeStatuses(newData, submonitor);
222	JiraClientData newData = new JiraClientData();	327	} finally {
223		328	submonitor.done();
224	data.serverInfo = newData.serverInfo = jiraClient.getServerInfo(monitor);	329	}
225
226	Policy.advance(monitor, 1);
227	initializeProjects(newData, monitor);
228	Policy.advance(monitor, 1);
229	initializePriorities(newData, monitor);
230	Policy.advance(monitor, 1);
231	initializeIssueTypes(newData, monitor);
232	Policy.advance(monitor, 1);
233	initializeResolutions(newData, monitor);
234	Policy.advance(monitor, 1);
235	initializeStatuses(newData, monitor);
236	Policy.advance(monitor, 1);
237		330
238	newData.lastUpdate = System.currentTimeMillis();	331	newData.lastUpdate = System.currentTimeMillis();
239	this.data = newData;	332	this.data = newData;

Lines 28-31 Link Here

(-)src/org/eclipse/mylyn/internal/jira/core/service/Messages.java (+15 lines)
28	public static String JiraClientCache_Getting_server_information;	28	public static String JiraClientCache_Getting_server_information;
29		29
30	public static String JiraClientCache_Updating_repository_configuration;	30	public static String JiraClientCache_Updating_repository_configuration;
		31
		32	public static String JiraClientCache_getting_issue_types;
		33
		34	public static String JiraClientCache_getting_priorities;
		35
		36	public static String JiraClientCache_getting_project_details;
		37
		38	public static String JiraClientCache_getting_resolutions;
		39
		40	public static String JiraClientCache_getting_server_info;
		41
		42	public static String JiraClientCache_getting_statuses;
		43
		44	public static String JiraClientCache_project_details_for;
		45
31	}	46	}