/*******************************************************************************
* Copyright (c) 2004, 2016 Tasktop Technologies 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:
* Tasktop Technologies - initial API and implementation
* Steve Elsemore - fix for bug 296963
* Atlassian - fix for bug 319699
*******************************************************************************/
package org.eclipse.mylyn.internal.tasks.ui.util;
import java.net.MalformedURLException;
import java.net.SocketTimeoutException;
import java.net.URL;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.eclipse.core.commands.Command;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.NotEnabledException;
import org.eclipse.core.commands.NotHandledException;
import org.eclipse.core.commands.ParameterizedCommand;
import org.eclipse.core.commands.common.NotDefinedException;
import org.eclipse.core.commands.operations.IUndoContext;
import org.eclipse.core.commands.operations.ObjectUndoContext;
import org.eclipse.core.expressions.EvaluationContext;
import org.eclipse.core.expressions.IEvaluationContext;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.ProgressMonitorWrapper;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.IJobChangeListener;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.runtime.jobs.JobChangeAdapter;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.IInputValidator;
import org.eclipse.jface.dialogs.InputDialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITreeSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.jface.window.Window;
import org.eclipse.jface.wizard.IWizard;
import org.eclipse.mylyn.commons.core.CoreUtil;
import org.eclipse.mylyn.commons.core.StatusHandler;
import org.eclipse.mylyn.commons.identity.core.Account;
import org.eclipse.mylyn.commons.ui.CommonImages;
import org.eclipse.mylyn.commons.ui.CommonUiUtil;
import org.eclipse.mylyn.commons.workbench.WorkbenchUtil;
import org.eclipse.mylyn.internal.monitor.ui.MonitorUiPlugin;
import org.eclipse.mylyn.internal.tasks.core.AbstractTask;
import org.eclipse.mylyn.internal.tasks.core.AbstractTaskCategory;
import org.eclipse.mylyn.internal.tasks.core.AbstractTaskContainer;
import org.eclipse.mylyn.internal.tasks.core.DateRange;
import org.eclipse.mylyn.internal.tasks.core.ITaskJobFactory;
import org.eclipse.mylyn.internal.tasks.core.ITaskList;
import org.eclipse.mylyn.internal.tasks.core.ITasksCoreConstants;
import org.eclipse.mylyn.internal.tasks.core.LocalRepositoryConnector;
import org.eclipse.mylyn.internal.tasks.core.LocalTask;
import org.eclipse.mylyn.internal.tasks.core.RepositoryQuery;
import org.eclipse.mylyn.internal.tasks.core.TaskActivityUtil;
import org.eclipse.mylyn.internal.tasks.core.TaskCategory;
import org.eclipse.mylyn.internal.tasks.core.TaskList;
import org.eclipse.mylyn.internal.tasks.core.UncategorizedTaskContainer;
import org.eclipse.mylyn.internal.tasks.core.UnsubmittedTaskContainer;
import org.eclipse.mylyn.internal.tasks.core.data.TaskDataState;
import org.eclipse.mylyn.internal.tasks.core.sync.SynchronizationScheduler;
import org.eclipse.mylyn.internal.tasks.core.sync.SynchronizationScheduler.Synchronizer;
import org.eclipse.mylyn.internal.tasks.core.util.TasksCoreUtil;
import org.eclipse.mylyn.internal.tasks.ui.ITasksUiPreferenceConstants;
import org.eclipse.mylyn.internal.tasks.ui.OpenRepositoryTaskJob;
import org.eclipse.mylyn.internal.tasks.ui.TasksUiPlugin;
import org.eclipse.mylyn.internal.tasks.ui.views.TaskListView;
import org.eclipse.mylyn.internal.tasks.ui.wizards.MultiRepositoryAwareWizard;
import org.eclipse.mylyn.internal.tasks.ui.wizards.NewAttachmentWizardDialog;
import org.eclipse.mylyn.internal.tasks.ui.wizards.NewTaskWizardInternal;
import org.eclipse.mylyn.internal.tasks.ui.wizards.QueryWizardDialog;
import org.eclipse.mylyn.internal.tasks.ui.wizards.TaskAttachmentWizard;
import org.eclipse.mylyn.tasks.core.AbstractRepositoryConnector;
import org.eclipse.mylyn.tasks.core.IRepositoryElement;
import org.eclipse.mylyn.tasks.core.IRepositoryManager;
import org.eclipse.mylyn.tasks.core.IRepositoryPerson;
import org.eclipse.mylyn.tasks.core.IRepositoryQuery;
import org.eclipse.mylyn.tasks.core.ITask;
import org.eclipse.mylyn.tasks.core.ITask.PriorityLevel;
import org.eclipse.mylyn.tasks.core.ITask.SynchronizationState;
import org.eclipse.mylyn.tasks.core.ITaskMapping;
import org.eclipse.mylyn.tasks.core.RepositoryStatus;
import org.eclipse.mylyn.tasks.core.TaskRepository;
import org.eclipse.mylyn.tasks.core.data.AbstractTaskAttachmentSource;
import org.eclipse.mylyn.tasks.core.data.AbstractTaskDataHandler;
import org.eclipse.mylyn.tasks.core.data.ITaskDataWorkingCopy;
import org.eclipse.mylyn.tasks.core.data.TaskAttachmentMapper;
import org.eclipse.mylyn.tasks.core.data.TaskAttribute;
import org.eclipse.mylyn.tasks.core.data.TaskAttributeMapper;
import org.eclipse.mylyn.tasks.core.data.TaskCommentMapper;
import org.eclipse.mylyn.tasks.core.data.TaskData;
import org.eclipse.mylyn.tasks.core.data.TaskHistory;
import org.eclipse.mylyn.tasks.core.data.TaskRevision;
import org.eclipse.mylyn.tasks.core.data.TaskRevision.Change;
import org.eclipse.mylyn.tasks.core.sync.SynchronizationJob;
import org.eclipse.mylyn.tasks.core.sync.TaskJob;
import org.eclipse.mylyn.tasks.ui.AbstractRepositoryConnectorUi;
import org.eclipse.mylyn.tasks.ui.TasksUi;
import org.eclipse.mylyn.tasks.ui.TasksUiImages;
import org.eclipse.mylyn.tasks.ui.TasksUiUtil;
import org.eclipse.mylyn.tasks.ui.editors.TaskEditor;
import org.eclipse.mylyn.tasks.ui.editors.TaskEditorInput;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.ISources;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchPreferenceConstants;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.IWorkingSet;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.commands.ICommandService;
import org.eclipse.ui.handlers.IHandlerService;
import org.eclipse.ui.progress.IProgressConstants2;
import org.eclipse.ui.services.IServiceLocator;
import org.eclipse.ui.statushandlers.IStatusAdapterConstants;
import org.eclipse.ui.statushandlers.StatusAdapter;
import org.eclipse.ui.statushandlers.StatusManager;
import com.google.common.base.Strings;
/**
* @author Steffen Pingel
*/
public class TasksUiInternal {
private static SynchronizationScheduler synchronizationScheduler = new SynchronizationScheduler();
private static final TaskDropHandler taskDropHandler = new TaskDropHandler();
/**
* @deprecated use SWT.SHEET instead
*/
@Deprecated
public static final int SWT_SHEET = 1 << 28;
public static final String ID_MENU_ACTIVE_TASK = "org.eclipse.mylyn.tasks.ui.menus.activeTask"; //$NON-NLS-1$
private static ObjectUndoContext undoContext;
public static MultiRepositoryAwareWizard createNewTaskWizard(ITaskMapping taskSelection) {
return new NewTaskWizardInternal(taskSelection);
}
/**
* get the connector discovery wizard command. Calling code should check {@link Command#isEnabled()} on return.
*
* @return the command, or null if it is not available.
*/
public static Command getConfiguredDiscoveryWizardCommand() {
ICommandService service = (ICommandService) PlatformUI.getWorkbench().getService(ICommandService.class);
final Command discoveryWizardCommand = service.getCommand("org.eclipse.mylyn.tasks.ui.discoveryWizardCommand"); //$NON-NLS-1$
if (discoveryWizardCommand != null) {
IHandlerService handlerService = (IHandlerService) PlatformUI.getWorkbench()
.getService(IHandlerService.class);
EvaluationContext evaluationContext = createDiscoveryWizardEvaluationContext(handlerService);
if (!discoveryWizardCommand.isEnabled()) {
// update enabled state in case something has changed (ProxyHandler caches state)
discoveryWizardCommand.setEnabled(evaluationContext);
}
}
return discoveryWizardCommand;
}
public static EvaluationContext createDiscoveryWizardEvaluationContext(IHandlerService handlerService) {
EvaluationContext evaluationContext = new EvaluationContext(handlerService.getCurrentState(), Platform.class);
// must specify this variable otherwise the PlatformPropertyTester won't work
evaluationContext.addVariable("platform", Platform.class); //$NON-NLS-1$
return evaluationContext;
}
public static ImageDescriptor getPriorityImage(ITask task) {
if (task.isCompleted()) {
return CommonImages.COMPLETE;
} else {
return TasksUiImages.getImageDescriptorForPriority(PriorityLevel.fromString(task.getPriority()));
}
}
public static List<TaskEditor> getActiveRepositoryTaskEditors() {
List<TaskEditor> repositoryTaskEditors = new ArrayList<TaskEditor>();
IWorkbenchWindow[] windows = PlatformUI.getWorkbench().getWorkbenchWindows();
for (IWorkbenchWindow window : windows) {
IEditorReference[] editorReferences = window.getActivePage().getEditorReferences();
for (IEditorReference editorReference : editorReferences) {
try {
if (editorReference.getEditorInput() instanceof TaskEditorInput) {
TaskEditorInput input = (TaskEditorInput) editorReference.getEditorInput();
if (input.getTask() != null) {
IEditorPart editorPart = editorReference.getEditor(false);
if (editorPart instanceof TaskEditor) {
repositoryTaskEditors.add((TaskEditor) editorPart);
}
}
}
} catch (PartInitException e) {
// ignore
}
}
}
return repositoryTaskEditors;
}
public static IProgressMonitor getUiMonitor(IProgressMonitor monitor) {
return new ProgressMonitorWrapper(monitor) {
@Override
public void beginTask(final String name, final int totalWork) {
PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
public void run() {
getWrappedProgressMonitor().beginTask(name, totalWork);
}
});
}
@Override
public void done() {
PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
public void run() {
getWrappedProgressMonitor().done();
}
});
}
@Override
public void subTask(final String name) {
PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
public void run() {
getWrappedProgressMonitor().subTask(name);
}
});
}
@Override
public void worked(final int work) {
PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
public void run() {
getWrappedProgressMonitor().worked(work);
}
});
}
};
}
public static void openEditor(TaskCategory category) {
final String name = category.getSummary();
InputDialog dialog = new InputDialog(WorkbenchUtil.getShell(), Messages.TasksUiInternal_Rename_Category_Title,
Messages.TasksUiInternal_Rename_Category_Message, name, new IInputValidator() {
public String isValid(String newName) {
if (newName.trim().length() == 0 || newName.equals(name)) {
return ""; //$NON-NLS-1$
}
Set<AbstractTaskCategory> categories = TasksUiPlugin.getTaskList().getCategories();
for (AbstractTaskCategory category : categories) {
if (newName.equals(category.getSummary())) {
return Messages.TasksUiInternal_Rename_Category_Name_already_exists_Error;
}
}
return null;
}
});
if (dialog.open() == Window.OK) {
TasksUiPlugin.getTaskList().renameContainer(category, dialog.getValue());
}
}
public static void refreshAndOpenTaskListElement(IRepositoryElement element) {
if (element instanceof ITask) {
final AbstractTask task = (AbstractTask) element;
if (task instanceof LocalTask) {
TasksUiUtil.openTask(task);
} else {
String repositoryKind = task.getConnectorKind();
final AbstractRepositoryConnector connector = TasksUi.getRepositoryManager()
.getRepositoryConnector(repositoryKind);
TaskRepository repository = TasksUi.getRepositoryManager().getRepository(repositoryKind,
task.getRepositoryUrl());
if (repository == null) {
displayStatus(Messages.TasksUiInternal_Failed_to_open_task, new Status(IStatus.ERROR,
TasksUiPlugin.ID_PLUGIN, Messages.TasksUiInternal_No_repository_found));
return;
}
if (connector != null) {
boolean opened = false;
if (TasksUiPlugin.getTaskDataManager().hasTaskData(task)) {
opened = TasksUiUtil.openTask(task);
}
if (!opened) {
if (connector.canSynchronizeTask(repository, task)) {
// TODO consider moving this into the editor, i.e. have the editor refresh the task if task data is missing
TasksUiInternal.synchronizeTask(connector, task, true, new JobChangeAdapter() {
@Override
public void done(IJobChangeEvent event) {
PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {
public void run() {
TasksUiUtil.openTask(task);
}
});
}
});
} else {
TasksUiUtil.openTask(task);
}
}
}
}
} else if (element instanceof TaskCategory) {
TasksUiInternal.openEditor((TaskCategory) element);
} else if (element instanceof IRepositoryQuery) {
RepositoryQuery query = (RepositoryQuery) element;
AbstractRepositoryConnectorUi connectorUi = TasksUiPlugin.getConnectorUi(query.getConnectorKind());
TasksUiInternal.openEditQueryDialog(connectorUi, query);
}
}
public static TaskJob updateRepositoryConfiguration(final TaskRepository taskRepository) {
synchronized (taskRepository) {
taskRepository.setUpdating(true);
}
AbstractRepositoryConnector connector = TasksUi.getRepositoryManager()
.getRepositoryConnector(taskRepository.getConnectorKind());
final TaskJob job = TasksUiInternal.getJobFactory().createUpdateRepositoryConfigurationJob(connector,
taskRepository, null);
job.addJobChangeListener(new JobChangeAdapter() {
@Override
public void done(IJobChangeEvent event) {
synchronized (taskRepository) {
taskRepository.setUpdating(false);
}
if (job.getStatus() != null) {
TasksUiInternal.asyncLogAndDisplayStatus(Messages.TasksUiInternal_Configuration_Refresh_Failed,
job.getStatus());
}
}
});
job.schedule();
return job;
}
private static void joinIfInTestMode(SynchronizationJob job) {
// FIXME the client code should join the job
if (CoreUtil.TEST_MODE) {
try {
job.join();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
public static final Job synchronizeQueries(AbstractRepositoryConnector connector, TaskRepository repository,
Set<RepositoryQuery> queries, IJobChangeListener listener, boolean force) {
Assert.isTrue(queries.size() > 0);
TaskList taskList = TasksUiPlugin.getTaskList();
for (RepositoryQuery query : queries) {
query.setSynchronizing(true);
}
taskList.notifySynchronizationStateChanged(queries);
SynchronizationJob job = TasksUiPlugin.getTaskJobFactory().createSynchronizeQueriesJob(connector, repository,
queries);
job.setUser(force);
if (force) {
// show the progress in the system task bar if this is a user job (i.e. forced)
job.setProperty(IProgressConstants2.SHOW_IN_TASKBAR_ICON_PROPERTY, Boolean.TRUE);
}
if (listener != null) {
job.addJobChangeListener(listener);
}
if (force) {
final RepositoryQuery query = queries.iterator().next();
job.addJobChangeListener(new JobChangeAdapter() {
@Override
public void done(IJobChangeEvent event) {
if (query.getStatus() != null) {
TasksUiInternal.asyncLogAndDisplayStatus(Messages.TasksUiInternal_Query_Synchronization_Failed,
query.getStatus());
}
}
});
}
job.schedule();
joinIfInTestMode(job);
return job;
}
/**
* For synchronizing a single query. Use synchronize(Set, IJobChangeListener) if synchronizing multiple queries at a
* time.
*/
public static final Job synchronizeQuery(AbstractRepositoryConnector connector, RepositoryQuery repositoryQuery,
IJobChangeListener listener, boolean force) {
TaskRepository repository = TasksUi.getRepositoryManager().getRepository(repositoryQuery.getConnectorKind(),
repositoryQuery.getRepositoryUrl());
return synchronizeQueries(connector, repository, Collections.singleton(repositoryQuery), listener, force);
}
public static SynchronizationJob synchronizeAllRepositories(boolean force) {
SynchronizationJob job = TasksUiPlugin.getTaskJobFactory().createSynchronizeRepositoriesJob(null);
job.setUser(force);
if (force) {
// show the progress in the system task bar if this is a user job (i.e. forced)
job.setProperty(IProgressConstants2.SHOW_IN_TASKBAR_ICON_PROPERTY, Boolean.TRUE);
}
job.schedule();
joinIfInTestMode(job);
return job;
}
public static void synchronizeRepositoryInBackground(final TaskRepository repository) {
synchronizationScheduler.schedule(repository, new Synchronizer<SynchronizationJob>() {
@Override
public SynchronizationJob createJob() {
return synchronizeRepositoryInternal(repository, false);
}
});
}
public static SynchronizationJob synchronizeRepository(TaskRepository repository, boolean force) {
SynchronizationJob job = synchronizeRepositoryInternal(repository, force);
synchronizationScheduler.cancel(repository);
job.schedule();
return job;
}
private static SynchronizationJob synchronizeRepositoryInternal(TaskRepository repository, boolean force) {
SynchronizationJob job = TasksUiInternal.getJobFactory()
.createSynchronizeRepositoriesJob(Collections.singleton(repository));
// do not show in progress view by default
job.setSystem(true);
job.setUser(force);
if (force) {
// show the progress in the system task bar if this is a user job (i.e. forced)
job.setProperty(IProgressConstants2.SHOW_IN_TASKBAR_ICON_PROPERTY, Boolean.TRUE);
}
job.setFullSynchronization(false);
return job;
}
public static void synchronizeTaskInBackground(final AbstractRepositoryConnector connector, final ITask task) {
synchronizationScheduler.schedule(task, new Synchronizer<Job>() {
@Override
public Job createJob() {
SynchronizationJob job = TasksUiPlugin.getTaskJobFactory().createSynchronizeTasksJob(connector,
Collections.singleton(task));
job.setUser(false);
job.setSystem(true);
return job;
}
});
}
/**
* Synchronize a single task. Note that if you have a collection of tasks to synchronize with this connector then
* you should call synchronize(Set<Set<AbstractTask> repositoryTasks, ...)
*
* @param listener
* can be null
*/
public static Job synchronizeTask(AbstractRepositoryConnector connector, ITask task, boolean force,
IJobChangeListener listener) {
return synchronizeTasks(connector, Collections.singleton(task), force, listener);
}
/**
* @param listener
* can be null
*/
public static Job synchronizeTasks(AbstractRepositoryConnector connector, Set<ITask> tasks, boolean force,
IJobChangeListener listener) {
ITaskList taskList = TasksUiInternal.getTaskList();
for (ITask task : tasks) {
((AbstractTask) task).setSynchronizing(true);
synchronizationScheduler.cancel(task);
}
((TaskList) taskList).notifySynchronizationStateChanged(tasks);
// TODO notify task list?
SynchronizationJob job = TasksUiPlugin.getTaskJobFactory().createSynchronizeTasksJob(connector, tasks);
job.setUser(force);
job.setSystem(!force);
job.setPriority(Job.DECORATE);
if (listener != null) {
job.addJobChangeListener(listener);
}
if (force && tasks.size() == 1) {
final ITask task = tasks.iterator().next();
job.addJobChangeListener(new JobChangeAdapter() {
@Override
public void done(IJobChangeEvent event) {
if (task instanceof AbstractTask && ((AbstractTask) task).getStatus() != null) {
TasksUiInternal.asyncLogAndDisplayStatus(Messages.TasksUiInternal_Task_Synchronization_Failed,
((AbstractTask) task).getStatus());
}
}
});
}
job.schedule();
joinIfInTestMode(job);
return job;
}
public static ITaskJobFactory getJobFactory() {
return TasksUiPlugin.getTaskJobFactory();
}
public static NewAttachmentWizardDialog openNewAttachmentWizard(Shell shell, TaskRepository taskRepository,
ITask task, TaskAttribute taskAttribute, TaskAttachmentWizard.Mode mode,
AbstractTaskAttachmentSource source) {
TaskAttachmentWizard attachmentWizard = new TaskAttachmentWizard(taskRepository, task, taskAttribute);
attachmentWizard.setSource(source);
attachmentWizard.setMode(mode);
NewAttachmentWizardDialog dialog = new NewAttachmentWizardDialog(shell, attachmentWizard, false);
dialog.setBlockOnOpen(false);
dialog.create();
dialog.open();
return dialog;
}
private static MessageDialog createDialog(Shell shell, String title, String message, int type) {
return new MessageDialog(shell, title, null, message, type, new String[] { IDialogConstants.OK_LABEL }, 0);
}
private static void displayStatus(Shell shell, final String title, final IStatus status,
boolean showLinkToErrorLog) {
// avoid blocking ui when in test mode
if (CoreUtil.TEST_MODE) {
StatusHandler.log(status);
return;
}
if (status instanceof RepositoryStatus && ((RepositoryStatus) status).isHtmlMessage()) {
WebBrowserDialog.openAcceptAgreement(shell, title, status.getMessage(),
((RepositoryStatus) status).getHtmlMessage());
} else {
String message = status.getMessage();
if (message == null || message.trim().length() == 0) {
message = Messages.TasksUiInternal_An_unknown_error_occurred;
}
if (message.length() > 256) {
message = message.substring(0, 256) + "..."; //$NON-NLS-1$
}
if (showLinkToErrorLog) {
message += "\n\n" + Messages.TasksUiInternal_See_error_log_for_details; //$NON-NLS-1$
}
switch (status.getSeverity()) {
case IStatus.CANCEL:
case IStatus.INFO:
createDialog(shell, title, message, MessageDialog.INFORMATION).open();
break;
case IStatus.WARNING:
createDialog(shell, title, message, MessageDialog.WARNING).open();
break;
case IStatus.ERROR:
default:
createDialog(shell, title, message, MessageDialog.ERROR).open();
break;
}
}
}
public static void asyncDisplayStatus(final String title, final IStatus status) {
Display display = PlatformUI.getWorkbench().getDisplay();
if (!display.isDisposed()) {
display.asyncExec(new Runnable() {
public void run() {
displayStatus(title, status);
}
});
} else {
StatusHandler.log(status);
}
}
public static void asyncLogAndDisplayStatus(final String title, final IStatus status) {
Display display = PlatformUI.getWorkbench().getDisplay();
if (!display.isDisposed()) {
display.asyncExec(new Runnable() {
public void run() {
logAndDisplayStatus(title, status);
}
});
} else {
StatusHandler.log(status);
}
}
public static void logAndDisplayStatus(final String title, final IStatus status) {
StatusHandler.log(status);
IWorkbench workbench = PlatformUI.getWorkbench();
if (workbench != null && !workbench.getDisplay().isDisposed()) {
displayStatus(WorkbenchUtil.getShell(), title, status, false);
}
}
public static void displayStatus(final String title, final IStatus status) {
IWorkbench workbench = PlatformUI.getWorkbench();
if (workbench != null && !workbench.getDisplay().isDisposed()) {
displayStatus(WorkbenchUtil.getShell(), title, status, false);
} else {
StatusHandler.log(status);
}
}
/**
* Creates a new local task and schedules for today
*
* @param summary
* if null DEFAULT_SUMMARY (New Task) used.
*/
public static LocalTask createNewLocalTask(String summary) {
if (summary == null) {
summary = LocalRepositoryConnector.DEFAULT_SUMMARY;
}
TaskList taskList = TasksUiPlugin.getTaskList();
LocalTask newTask = new LocalTask("" + taskList.getNextLocalTaskId(), summary); //$NON-NLS-1$
newTask.setPriority(PriorityLevel.P3.toString());
TasksUiInternal.getTaskList().addTask(newTask);
scheduleNewTask(newTask);
TaskListView view = TaskListView.getFromActivePerspective();
AbstractTaskCategory category = getSelectedCategory(view);
if (view != null && view.getDrilledIntoCategory() != null && view.getDrilledIntoCategory() != category) {
MessageDialog.openInformation(Display.getCurrent().getActiveShell(), Messages.TasksUiInternal_Create_Task,
MessageFormat.format(Messages.TasksUiInternal_The_new_task_will_be_added_to_the_X_container,
UncategorizedTaskContainer.LABEL));
}
newTask.setAttribute(ITasksCoreConstants.PROPERTY_NEW_UNSAVED_TASK, Boolean.TRUE.toString());
taskList.addTask(newTask, category);
return newTask;
}
/**
* Schedules the new task according to the Tasks UI preferences
*
* @param newTask
* the task to schedule
*/
public static void scheduleNewTask(LocalTask newTask) {
IPreferenceStore preferenceStore = TasksUiPlugin.getDefault().getPreferenceStore();
String preference = preferenceStore.getString(ITasksUiPreferenceConstants.SCHEDULE_NEW_TASKS_FOR);
DateRange dateRange = getNewTaskScheduleDateRange(preference);
TasksUiPlugin.getTaskActivityManager().scheduleNewTask(newTask, dateRange);
}
private static DateRange getNewTaskScheduleDateRange(String preference) {
switch (preference) {
case ITasksUiPreferenceConstants.SCHEDULE_NEW_TASKS_FOR_NOT_SCHEDULED:
return null;
case ITasksUiPreferenceConstants.SCHEDULE_NEW_TASKS_FOR_TODAY:
return TaskActivityUtil.getCurrentWeek().getToday();
case ITasksUiPreferenceConstants.SCHEDULE_NEW_TASKS_FOR_TOMORROW:
return TaskActivityUtil.getCurrentWeek().getToday().next();
case ITasksUiPreferenceConstants.SCHEDULE_NEW_TASKS_FOR_THIS_WEEK:
return TaskActivityUtil.getCurrentWeek();
}
return TaskActivityUtil.getCurrentWeek();
}
public static AbstractTaskCategory getSelectedCategory(TaskListView view) {
Object selectedObject = null;
if (view != null) {
selectedObject = ((IStructuredSelection) view.getViewer().getSelection()).getFirstElement();
}
if (selectedObject instanceof TaskCategory) {
return (TaskCategory) selectedObject;
} else if (selectedObject instanceof ITask) {
ITask task = (ITask) selectedObject;
AbstractTaskContainer container = TaskCategory.getParentTaskCategory(task);
if (container instanceof TaskCategory) {
return (TaskCategory) container;
} else if (view != null && view.getDrilledIntoCategory() instanceof TaskCategory) {
return (TaskCategory) view.getDrilledIntoCategory();
}
} else if (view != null && view.getDrilledIntoCategory() instanceof TaskCategory) {
return (TaskCategory) view.getDrilledIntoCategory();
}
return TasksUiPlugin.getTaskList().getDefaultCategory();
}
public static Set<AbstractTaskContainer> getContainersFromWorkingSet(Set<IWorkingSet> containers) {
Set<AbstractTaskContainer> allTaskContainersInWorkingSets = new HashSet<AbstractTaskContainer>();
for (IWorkingSet workingSet : containers) {
IAdaptable[] elements = workingSet.getElements();
for (IAdaptable adaptable : elements) {
if (adaptable instanceof AbstractTaskContainer) {
allTaskContainersInWorkingSets.add(((AbstractTaskContainer) adaptable));
}
}
}
return allTaskContainersInWorkingSets;
}
/**
* @param connectorUi
* - repository connector ui
* @param query
* - repository query
* @return - true if dialog was opened successfully and not canceled, false otherwise
* @since 3.0
*/
public static boolean openEditQueryDialog(AbstractRepositoryConnectorUi connectorUi, final IRepositoryQuery query) {
try {
TaskRepository repository = TasksUi.getRepositoryManager().getRepository(query.getConnectorKind(),
query.getRepositoryUrl());
if (repository == null) {
return false;
}
IWizard wizard = connectorUi.getQueryWizard(repository, query);
Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
if (wizard != null && shell != null && !shell.isDisposed()) {
QueryWizardDialog dialog = new QueryWizardDialog(shell, wizard) {
private static final String DIALOG_SETTINGS = "EditQueryWizardWizard"; //$NON-NLS-1$
@Override
protected IDialogSettings getDialogBoundsSettings() {
IDialogSettings settings = TasksUiPlugin.getDefault().getDialogSettings();
String settingsSectionId = DIALOG_SETTINGS + '.' + query.getRepositoryUrl();
IDialogSettings section = settings.getSection(settingsSectionId);
if (section == null) {
section = settings.addNewSection(settingsSectionId);
}
return section;
}
};
dialog.create();
dialog.setBlockOnOpen(true);
if (dialog.open() == Window.CANCEL) {
return false;
} else {
return true;
}
}
} catch (Exception e) {
StatusHandler.log(new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN, "Failed to open query dialog", e)); //$NON-NLS-1$
}
return false;
}
public static ITaskList getTaskList() {
return TasksUiPlugin.getTaskList();
}
public static boolean isAnimationsEnabled() {
IPreferenceStore store = PlatformUI.getPreferenceStore();
return store.getBoolean(IWorkbenchPreferenceConstants.ENABLE_ANIMATIONS);
}
public static boolean hasValidUrl(ITask task) {
return isValidUrl(task.getUrl());
}
public static boolean isValidUrl(String url) {
if (url != null && !url.equals("") && !url.equals("http://") && !url.equals("https://")) { //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
try {
new URL(url);
return true;
} catch (MalformedURLException e) {
return false;
}
}
return false;
}
/**
* @deprecated use {@link #closeTaskEditorInAllPages(ITask, boolean)}
*/
@Deprecated
public static void closeEditorInActivePage(ITask task, boolean save) {
Assert.isNotNull(task);
IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
if (window == null) {
return;
}
IWorkbenchPage page = window.getActivePage();
if (page == null) {
return;
}
TaskRepository taskRepository = TasksUi.getRepositoryManager().getRepository(task.getConnectorKind(),
task.getRepositoryUrl());
IEditorInput input = new TaskEditorInput(taskRepository, task);
IEditorPart editor = page.findEditor(input);
if (editor != null) {
page.closeEditor(editor, save);
}
}
public static void closeTaskEditorInAllPages(ITask task, boolean save) {
Assert.isNotNull(task);
TaskRepository taskRepository = TasksUi.getRepositoryManager().getRepository(task.getConnectorKind(),
task.getRepositoryUrl());
IEditorInput input = new TaskEditorInput(taskRepository, task);
IWorkbenchWindow[] windows = PlatformUI.getWorkbench().getWorkbenchWindows();
for (IWorkbenchWindow window : windows) {
IWorkbenchPage[] pages = window.getPages();
for (IWorkbenchPage page : pages) {
IEditorPart editor = page.findEditor(input);
if (editor != null) {
page.closeEditor(editor, save);
}
}
}
}
public static boolean hasLocalCompletionState(ITask task) {
TaskRepository taskRepository = TasksUi.getRepositoryManager().getRepository(task.getConnectorKind(),
task.getRepositoryUrl());
AbstractRepositoryConnector connector = TasksUi.getRepositoryManager()
.getRepositoryConnector(task.getConnectorKind());
return connector.hasLocalCompletionState(taskRepository, task);
}
/**
* Utility method to get the best parenting possible for a dialog. If there is a modal shell create it so as to
* avoid two modal dialogs. If not then return the shell of the active workbench window. If neither can be found
* return null.
* <p>
* <b>Note: Applied from patch on bug 99472.</b>
*
* @return Shell or <code>null</code>
* @deprecated Use {@link WorkbenchUtil#getShell()} instead
*/
@Deprecated
public static Shell getShell() {
return WorkbenchUtil.getShell();
}
public static TaskData createTaskData(TaskRepository taskRepository, ITaskMapping initializationData,
ITaskMapping selectionData, IProgressMonitor monitor) throws CoreException {
AbstractRepositoryConnector connector = TasksUi.getRepositoryManager()
.getRepositoryConnector(taskRepository.getConnectorKind());
AbstractTaskDataHandler taskDataHandler = connector.getTaskDataHandler();
TaskAttributeMapper mapper = taskDataHandler.getAttributeMapper(taskRepository);
TaskData taskData = new TaskData(mapper, taskRepository.getConnectorKind(), taskRepository.getRepositoryUrl(),
""); //$NON-NLS-1$
boolean result = taskDataHandler.initializeTaskData(taskRepository, taskData, initializationData, monitor);
if (!result) {
throw new CoreException(new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN,
"Initialization of task failed. The provided data is insufficient.")); //$NON-NLS-1$
}
if (selectionData != null) {
connector.getTaskMapping(taskData).merge(selectionData);
}
return taskData;
}
public static void createAndOpenNewTask(TaskData taskData) throws CoreException {
ITask task = TasksUiUtil.createOutgoingNewTask(taskData.getConnectorKind(), taskData.getRepositoryUrl());
AbstractRepositoryConnector connector = TasksUi.getRepositoryManager()
.getRepositoryConnector(taskData.getConnectorKind());
ITaskMapping mapping = connector.getTaskMapping(taskData);
String summary = mapping.getSummary();
if (!Strings.isNullOrEmpty(summary)) {
task.setSummary(summary);
}
String taskKind = mapping.getTaskKind();
if (!Strings.isNullOrEmpty(taskKind)) {
task.setTaskKind(taskKind);
}
UnsubmittedTaskContainer unsubmitted = TasksUiPlugin.getTaskList()
.getUnsubmittedContainer(taskData.getRepositoryUrl());
if (unsubmitted != null) {
TasksUiPlugin.getTaskList().addTask(task, unsubmitted);
}
ITaskDataWorkingCopy workingCopy = TasksUi.getTaskDataManager().createWorkingCopy(task, taskData);
workingCopy.save(null, null);
TaskRepository taskRepository = TasksUi.getRepositoryManager().getRepository(taskData.getConnectorKind(),
taskData.getRepositoryUrl());
connector.updateNewTaskFromTaskData(taskRepository, task, taskData);
TaskRepository localTaskRepository = TasksUi.getRepositoryManager().getRepository(task.getConnectorKind(),
task.getRepositoryUrl());
TaskEditorInput editorInput = new TaskEditorInput(localTaskRepository, task);
TasksUiUtil.openEditor(editorInput, TaskEditor.ID_EDITOR, null);
}
public static boolean openTask(TaskRepository repository, String taskId, TaskOpenListener listener) {
AbstractTask task = getTaskFromTaskList(repository, taskId);
if (task != null) {
// task is known, open in task editor
return openKnownTaskInEditor(task, taskId, listener);
} else {
// search for task
AbstractRepositoryConnectorUi connectorUi = TasksUiPlugin.getConnectorUi(repository.getConnectorKind());
if (connectorUi != null) {
try {
return openRepositoryTask(connectorUi.getConnectorKind(), repository.getRepositoryUrl(), taskId,
listener);
} catch (Exception e) {
StatusHandler.log(new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN,
"Internal error while opening repository task", e)); //$NON-NLS-1$
}
}
}
return false;
}
public static boolean openTaskByIdOrKey(TaskRepository repository, String taskIdOrKey, TaskOpenListener listener) {
AbstractTask task = getTaskFromTaskList(repository, taskIdOrKey);
if (task != null) {
// task is known, open in task editor
return openKnownTaskInEditor(task, taskIdOrKey, listener);
} else {
// search for task
AbstractRepositoryConnectorUi connectorUi = TasksUiPlugin.getConnectorUi(repository.getConnectorKind());
if (connectorUi != null) {
try {
return openRepositoryTaskByIdOrKey(connectorUi.getConnectorKind(), repository.getRepositoryUrl(),
taskIdOrKey, listener);
} catch (Exception e) {
StatusHandler.log(new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN,
"Internal error while opening repository task", e)); //$NON-NLS-1$
}
}
}
return false;
}
private static boolean openKnownTaskInEditor(AbstractTask task, String taskIdOrKey, TaskOpenListener listener) {
TaskOpenEvent event = TasksUiInternal.openTask(task, taskIdOrKey);
if (listener != null && event != null) {
listener.taskOpened(event);
}
return event != null;
}
private static AbstractTask getTaskFromTaskList(TaskRepository repository, String taskIdOrKey) {
Assert.isNotNull(repository);
Assert.isNotNull(taskIdOrKey);
AbstractTask task = (AbstractTask) TasksUiInternal.getTaskList().getTask(repository.getRepositoryUrl(),
taskIdOrKey);
if (task == null) {
task = TasksUiPlugin.getTaskList().getTaskByKey(repository.getRepositoryUrl(), taskIdOrKey);
}
return task;
}
public static TaskOpenEvent openTask(ITask task, String taskId) {
Assert.isNotNull(task);
IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
if (window != null) {
TaskRepository taskRepository = TasksUi.getRepositoryManager().getRepository(task.getConnectorKind(),
task.getRepositoryUrl());
boolean openWithBrowser = !TasksUiPlugin.getDefault()
.getPreferenceStore()
.getBoolean(ITasksUiPreferenceConstants.EDITOR_TASKS_RICH);
if (openWithBrowser && !(task instanceof LocalTask)) {
TasksUiUtil.openWithBrowser(taskRepository, task);
return new TaskOpenEvent(taskRepository, task, taskId, null, true);
} else {
IEditorInput editorInput = getTaskEditorInput(taskRepository, task);
IEditorPart editor = refreshEditorContentsIfOpen(task, editorInput);
if (editor != null) {
synchronizeTask(taskRepository, task);
return new TaskOpenEvent(taskRepository, task, taskId, editor, false);
} else {
IWorkbenchPage page = window.getActivePage();
editor = TasksUiUtil.openEditor(editorInput, getTaskEditorId(task), page);
if (editor != null) {
synchronizeTask(taskRepository, task);
return new TaskOpenEvent(taskRepository, task, taskId, editor, false);
}
}
}
} else {
StatusHandler.log(new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN, "Unable to open editor for \"" //$NON-NLS-1$
+ task.getSummary() + "\": no active workbench window")); //$NON-NLS-1$
}
return null;
}
private static IEditorInput getTaskEditorInput(TaskRepository repository, ITask task) {
Assert.isNotNull(task);
Assert.isNotNull(repository);
AbstractRepositoryConnectorUi connectorUi = TasksUiPlugin.getConnectorUi(task.getConnectorKind());
IEditorInput editorInput = connectorUi.getTaskEditorInput(repository, task);
if (editorInput != null) {
return editorInput;
} else {
return new TaskEditorInput(repository, task);
}
}
private static String getTaskEditorId(final ITask task) {
String taskEditorId = TaskEditor.ID_EDITOR;
if (task != null) {
ITask repositoryTask = task;
AbstractRepositoryConnectorUi repositoryUi = TasksUiPlugin
.getConnectorUi(repositoryTask.getConnectorKind());
String customTaskEditorId = repositoryUi.getTaskEditorId(repositoryTask);
if (customTaskEditorId != null) {
taskEditorId = customTaskEditorId;
}
}
return taskEditorId;
}
/**
* If task is already open and has incoming, must force refresh in place
*/
private static IEditorPart refreshEditorContentsIfOpen(ITask task, IEditorInput editorInput) {
if (task != null) {
if (task.getSynchronizationState() == SynchronizationState.INCOMING
|| task.getSynchronizationState() == SynchronizationState.CONFLICT) {
for (TaskEditor editor : TasksUiInternal.getActiveRepositoryTaskEditors()) {
if (editor.getEditorInput().equals(editorInput)) {
editor.refreshPages();
editor.getEditorSite().getPage().activate(editor);
return editor;
}
}
}
}
return null;
}
private static void synchronizeTask(TaskRepository taskRepository, ITask task) {
if (task instanceof LocalTask) {
return;
}
AbstractRepositoryConnector connector = TasksUi.getRepositoryManager()
.getRepositoryConnector(task.getConnectorKind());
if (connector.canSynchronizeTask(taskRepository, task)) {
TasksUiInternal.synchronizeTaskInBackground(connector, task);
}
}
public static boolean openRepositoryTask(String connectorKind, String repositoryUrl, String id) {
return openRepositoryTask(connectorKind, repositoryUrl, id, null);
}
/**
* Only override if task should be opened by a custom editor, default behavior is to open with a rich editor,
* falling back to the web browser if not available.
*
* @return true if the task was successfully opened
*/
public static boolean openRepositoryTask(String connectorKind, String repositoryUrl, String id,
TaskOpenListener listener) {
return openRepositoryTask(connectorKind, repositoryUrl, id, listener, 0);
}
/**
* Only override if task should be opened by a custom editor, default behavior is to open with a rich editor,
* falling back to the web browser if not available.
*
* @return true if the task was successfully opened
*/
public static boolean openRepositoryTask(String connectorKind, String repositoryUrl, String id,
TaskOpenListener listener, long timestamp) {
String taskUrl = getTaskUrl(connectorKind, repositoryUrl, id);
if (taskUrl == null) {
return false;
}
IWorkbenchWindow window = getWorkbenchWindow();
if (window == null) {
return false;
}
IWorkbenchPage page = window.getActivePage();
OpenRepositoryTaskJob job = new OpenRepositoryTaskJob(connectorKind, repositoryUrl, id, taskUrl, timestamp,
page);
job.setListener(listener);
job.schedule();
return true;
}
/**
* Opens a task with a given search string that can be a task id or task key.
*
* @return true if the task was successfully opened
*/
public static boolean openRepositoryTaskByIdOrKey(String connectorKind, String repositoryUrl, String idOrKey,
TaskOpenListener listener) {
String taskUrl = getTaskUrl(connectorKind, repositoryUrl, idOrKey);
if (taskUrl == null) {
return false;
}
IWorkbenchWindow window = getWorkbenchWindow();
if (window == null) {
return false;
}
IWorkbenchPage page = window.getActivePage();
OpenRepositoryTaskJob job = new OpenRepositoryTaskJob(page, connectorKind, repositoryUrl, idOrKey, taskUrl);
job.setListener(listener);
job.schedule();
return true;
}
private static IWorkbenchWindow getWorkbenchWindow() {
IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
if (window == null) {
IWorkbenchWindow[] windows = PlatformUI.getWorkbench().getWorkbenchWindows();
if (windows != null && windows.length > 0) {
window = windows[0];
}
}
return window;
}
private static String getTaskUrl(String connectorKind, String repositoryUrl, String idOrKey) {
IRepositoryManager repositoryManager = TasksUi.getRepositoryManager();
AbstractRepositoryConnector connector = repositoryManager.getRepositoryConnector(connectorKind);
return connector.getTaskUrl(repositoryUrl, idOrKey);
}
/**
* @since 3.0
*/
public static boolean openTaskInBackground(ITask task, boolean bringToTop) {
IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
if (window != null) {
IEditorPart activeEditor = null;
IWorkbenchPart activePart = null;
IWorkbenchPage activePage = window.getActivePage();
if (activePage != null) {
activeEditor = activePage.getActiveEditor();
activePart = activePage.getActivePart();
}
boolean opened = TasksUiUtil.openTask(task);
if (opened && activePage != null) {
if (!bringToTop && activeEditor != null) {
activePage.bringToTop(activeEditor);
}
if (activePart != null) {
activePage.activate(activePart);
}
}
return opened;
} else {
StatusHandler.log(new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN, "Unable to open editor for \"" //$NON-NLS-1$
+ task.getSummary() + "\": no active workbench window")); //$NON-NLS-1$
}
return false;
}
/**
* Returns text masking the &-character from decoration as an accelerator in SWT labels.
*
* @deprecated Use {@link CommonUiUtil#toLabel(String)} instead
*/
@Deprecated
public static String escapeLabelText(String text) {
return CommonUiUtil.toLabel(text);
}
public static void preservingSelection(final TreeViewer viewer, Runnable runnable) {
final ISelection selection = viewer.getSelection();
runnable.run();
if (selection != null) {
ISelection newSelection = viewer.getSelection();
if ((newSelection == null || newSelection.isEmpty()) && !(selection == null || selection.isEmpty())) {
// delay execution to ensure that any delayed tree updates such as expand all have been processed and the selection is revealed properly
Display.getDefault().asyncExec(new Runnable() {
public void run() {
viewer.setSelection(selection, true);
}
});
} else if (newSelection instanceof ITreeSelection && !newSelection.isEmpty()) {
viewer.reveal(((ITreeSelection) newSelection).getFirstElement());
}
}
}
public static String getFormattedDuration(long duration, boolean includeSeconds) {
long seconds = duration / 1000;
long minutes = 0;
long hours = 0;
// final long SECOND = 1000;
final long MIN = 60;
final long HOUR = MIN * 60;
String formatted = ""; //$NON-NLS-1$
String hour = ""; //$NON-NLS-1$
String min = ""; //$NON-NLS-1$
String sec = ""; //$NON-NLS-1$
if (seconds >= HOUR) {
hours = seconds / HOUR;
if (hours == 1) {
hour = hours + Messages.TasksUiInternal__hour_;
} else if (hours > 1) {
hour = hours + Messages.TasksUiInternal__hours_;
}
seconds -= hours * HOUR;
minutes = seconds / MIN;
if (minutes == 1) {
min = minutes + Messages.TasksUiInternal__minute_;
} else if (minutes != 1) {
min = minutes + Messages.TasksUiInternal__minutes_;
}
seconds -= minutes * MIN;
if (seconds == 1) {
sec = seconds + Messages.TasksUiInternal__second;
} else if (seconds > 1) {
sec = seconds + Messages.TasksUiInternal__seconds;
}
formatted += hour + min;
if (includeSeconds) {
formatted += sec;
}
} else if (seconds >= MIN) {
minutes = seconds / MIN;
if (minutes == 1) {
min = minutes + Messages.TasksUiInternal__minute_;
} else if (minutes != 1) {
min = minutes + Messages.TasksUiInternal__minutes_;
}
seconds -= minutes * MIN;
if (seconds == 1) {
sec = seconds + Messages.TasksUiInternal__second;
} else if (seconds > 1) {
sec = seconds + Messages.TasksUiInternal__seconds;
}
formatted += min;
if (includeSeconds) {
formatted += sec;
}
} else {
if (seconds == 1) {
sec = seconds + Messages.TasksUiInternal__second;
} else if (seconds > 1) {
sec = seconds + Messages.TasksUiInternal__seconds;
}
if (includeSeconds) {
formatted += sec;
}
}
return formatted;
}
public static AbstractTask getTask(String repositoryUrl, String taskId, String fullUrl) {
AbstractTask task = null;
if (repositoryUrl != null && taskId != null) {
task = (AbstractTask) TasksUiInternal.getTaskList().getTask(repositoryUrl, taskId);
}
if (task == null && fullUrl != null) {
task = TasksUiInternal.getTaskByUrl(fullUrl);
}
if (task == null && repositoryUrl != null && taskId != null) {
task = TasksUiPlugin.getTaskList().getTaskByKey(repositoryUrl, taskId);
}
return task;
}
/**
* Searches for a task whose URL matches
*
* @return first task with a matching URL.
*/
public static AbstractTask getTaskByUrl(String taskUrl) {
return TasksCoreUtil.getTaskByUrl(TasksUiPlugin.getTaskList(), TasksUi.getRepositoryManager(), taskUrl);
}
public static boolean isTaskUrl(String taskUrl) {
Assert.isNotNull(taskUrl);
List<TaskRepository> repositories = TasksUiPlugin.getRepositoryManager().getAllRepositories();
for (TaskRepository repository : repositories) {
if (taskUrl.startsWith(repository.getUrl())) {
return true;
}
}
return false;
}
/**
* Cleans text for use as the text of an action to ensure that it is displayed properly.
*
* @return the cleaned text
* @deprecated use {@link CommonUiUtil#toMenuLabel(String)} instead
*/
@Deprecated
public static String cleanTextForAction(String label) {
return CommonUiUtil.toMenuLabel(label);
}
public static void executeCommand(IServiceLocator serviceLocator, String commandId, String title, Object object,
Event event) throws NotEnabledException {
IHandlerService service = (IHandlerService) serviceLocator.getService(IHandlerService.class);
if (service != null) {
ICommandService commandService = (ICommandService) serviceLocator.getService(ICommandService.class);
if (commandService != null) {
Command command = commandService.getCommand(commandId);
if (command != null) {
try {
if (object != null) {
IEvaluationContext context = service.createContextSnapshot(false);
context.addVariable(ISources.ACTIVE_CURRENT_SELECTION_NAME,
new StructuredSelection(object));
service.executeCommandInContext(new ParameterizedCommand(command, null), event, context);
} else {
service.executeCommand(commandId, event);
}
} catch (ExecutionException e) {
TasksUiInternal.displayStatus(title,
new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN, "Command execution failed", e)); //$NON-NLS-1$
} catch (NotDefinedException e) {
TasksUiInternal.displayStatus(title, new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN,
NLS.bind("The command with the id ''{0}'' is not defined.", commandId), e)); //$NON-NLS-1$
} catch (NotHandledException e) {
TasksUiInternal.displayStatus(title, new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN,
NLS.bind("The command with the id ''{0}'' is not bound.", commandId), e)); //$NON-NLS-1$
}
} else {
TasksUiInternal.displayStatus(title, new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN,
NLS.bind("The command with the id ''{0}'' does not exist.", commandId))); //$NON-NLS-1$
}
} else {
TasksUiInternal
.displayStatus(title,
new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN, NLS.bind(
"Command service is not available to execute command with the id ''{0}''.", //$NON-NLS-1$
commandId), new Exception()));
}
} else {
TasksUiInternal.displayStatus(title,
new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN,
NLS.bind("Handler service is not available to execute command with the id ''{0}''.", //$NON-NLS-1$
commandId),
new Exception()));
}
}
public static void activateTaskThroughCommand(ITask task) {
try {
TasksUiInternal.executeCommand(PlatformUI.getWorkbench(),
"org.eclipse.mylyn.tasks.ui.command.activateSelectedTask", Messages.TasksUiInternal_Activate_Task, //$NON-NLS-1$
task, null);
} catch (NotEnabledException e) {
StatusHandler.log(new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN,
NLS.bind("Failed to activate task ''{0}''.", task.getSummary()), e)); //$NON-NLS-1$
}
}
public static long getActiveTime(ITask task) {
if (TasksUiInternal.isActivityTrackingEnabled()) {
return TasksUiPlugin.getTaskActivityManager().getElapsedTime(task);
}
return 0;
}
public static String getTaskPrefix(String connectorKind) {
AbstractRepositoryConnector connector = TasksUiPlugin.getConnector(connectorKind);
if (connector != null) {
String prefix = connector.getTaskIdPrefix();
// work around short prefixes which are not separated by space, e.g. "#" for Trac
return (prefix.length() > 1) ? prefix + " " : prefix; //$NON-NLS-1$
}
return ""; //$NON-NLS-1$
}
public static void displayFrameworkError(String message) {
RuntimeException exception = new RuntimeException(message);
if (!CoreUtil.TEST_MODE) {
StatusAdapter status = new StatusAdapter(
new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN, message, exception));
status.setProperty(IStatusAdapterConstants.TITLE_PROPERTY, "Framework Error"); //$NON-NLS-1$
StatusManager.getManager().handle(status, StatusManager.SHOW | StatusManager.LOG | StatusManager.BLOCK);
}
throw exception;
}
public static String getAuthenticatedUrl(TaskRepository repository, IRepositoryElement element) {
Assert.isNotNull(repository);
Assert.isNotNull(element);
IRepositoryManager repositoryManager = TasksUi.getRepositoryManager();
AbstractRepositoryConnector connector = repositoryManager.getRepositoryConnector(repository.getConnectorKind());
if (connector != null) {
URL authenticatedUrl = connector.getAuthenticatedUrl(repository, element);
if (authenticatedUrl != null) {
return authenticatedUrl.toString();
} else {
String url = element.getUrl();
if (TasksUiInternal.isValidUrl(url)) {
return url;
}
}
}
return null;
}
public static TaskRepository getRepository(IRepositoryElement element) {
IRepositoryManager repositoryManager = TasksUi.getRepositoryManager();
TaskRepository repository = null;
if (element instanceof ITask) {
repository = repositoryManager.getRepository(((ITask) element).getConnectorKind(),
((ITask) element).getRepositoryUrl());
} else if (element instanceof IRepositoryQuery) {
repository = repositoryManager.getRepository(((IRepositoryQuery) element).getConnectorKind(),
((IRepositoryQuery) element).getRepositoryUrl());
}
return repository;
}
/**
* Returns all the tasks in the given selection, or an empty list if the selection contains no tasks.
*/
public static List<ITask> getTasksFromSelection(ISelection selection) {
Assert.isNotNull(selection);
if (selection.isEmpty()) {
return Collections.emptyList();
}
List<ITask> tasks = new ArrayList<ITask>();
if (selection instanceof IStructuredSelection) {
for (Object element : ((IStructuredSelection) selection).toList()) {
ITask task = null;
if (element instanceof ITask) {
task = (ITask) element;
} else if (element instanceof IAdaptable) {
IAdaptable adaptable = (IAdaptable) element;
task = (ITask) adaptable.getAdapter(ITask.class);
}
if (task != null) {
tasks.add(task);
}
}
}
return tasks;
}
public static boolean shouldShowIncoming(ITask task) {
SynchronizationState state = task.getSynchronizationState();
if ((state == SynchronizationState.INCOMING
&& !Boolean.valueOf(task.getAttribute(ITasksCoreConstants.ATTRIBUTE_TASK_SUPPRESS_INCOMING)))
|| state == SynchronizationState.INCOMING_NEW || state == SynchronizationState.CONFLICT) {
return true;
}
return false;
}
public static TaskData computeTaskData(TaskData taskData, TaskHistory history, String revisionId,
IProgressMonitor monitor) throws CoreException {
TaskData newTaskData = TaskDataState.createCopy(taskData);
List<TaskRevision> revisions = history.getRevisions();
Collections.reverse(revisions);
TaskRevision lastRevision = null;
for (TaskRevision revision : revisions) {
for (Change change : revision.getChanges()) {
TaskAttribute attribute = newTaskData.getRoot().getAttribute(change.getAttributeId());
if (attribute != null) {
attribute.setValue(change.getRemoved());
}
}
// only apply changes up to this revision
if (revisionId.equals(revision.getId())) {
lastRevision = revision;
break;
}
}
if (lastRevision != null && lastRevision.getDate() != null) {
// remove attachments and comments that are newer than lastRevision
List<TaskAttribute> attributes = new ArrayList<TaskAttribute>(
newTaskData.getRoot().getAttributes().values());
for (TaskAttribute attribute : attributes) {
if (TaskAttribute.TYPE_COMMENT.equals(attribute.getMetaData().getType())) {
TaskCommentMapper mapper = TaskCommentMapper.createFrom(attribute);
if (mapper.getCreationDate() != null && mapper.getCreationDate().after(lastRevision.getDate())) {
newTaskData.getRoot().removeAttribute(attribute.getId());
}
} else if (TaskAttribute.TYPE_ATTACHMENT.equals(attribute.getMetaData().getType())) {
TaskAttachmentMapper mapper = TaskAttachmentMapper.createFrom(attribute);
if (mapper.getCreationDate() != null && mapper.getCreationDate().after(lastRevision.getDate())) {
newTaskData.getRoot().removeAttribute(attribute.getId());
}
}
}
}
return newTaskData;
}
public static boolean canGetTaskHistory(ITask task) {
TaskRepository repository = TasksUi.getRepositoryManager().getRepository(task.getConnectorKind(),
task.getRepositoryUrl());
AbstractRepositoryConnector connector = TasksUi.getRepositoryManager()
.getRepositoryConnector(repository.getConnectorKind());
return connector.canGetTaskHistory(repository, task);
}
public static Account getAccount(TaskAttribute attribute) {
Account account;
if (TaskAttribute.TYPE_PERSON.equals(attribute.getMetaData().getType())) {
IRepositoryPerson person = attribute.getTaskData().getAttributeMapper().getRepositoryPerson(attribute);
account = Account.id(person.getPersonId()).name(person.getName());
} else {
account = Account.id(attribute.getValue());
}
TaskRepository repository = attribute.getTaskData().getAttributeMapper().getTaskRepository();
return account.kind(repository.getConnectorKind()).url(repository.getRepositoryUrl());
}
public static boolean isActivityTrackingEnabled() {
return TasksUiPlugin.getTaskActivityMonitor().isEnabled()
&& MonitorUiPlugin.getDefault().isActivityTrackingEnabled();
}
public static TaskDropHandler getTaskDropHandler() {
return taskDropHandler;
}
public static ImageDescriptor getIconFromStatusOfQuery(RepositoryQuery query) {
ImageDescriptor image;
boolean showError = false;
Throwable exception = query.getStatus().getException();
showError = (query.getLastSynchronizedTimeStamp().equals("<never>") //$NON-NLS-1$
&& ((RepositoryStatus.ERROR_IO == query.getStatus().getCode() && exception != null
&& exception instanceof SocketTimeoutException) || //
// only when we change SocketTimeout or Eclipse.org change there timeout for long running Queries
(RepositoryStatus.ERROR_NETWORK) == query.getStatus().getCode()
&& query.getStatus().getMessage().equals("Http error: Internal Server Error"))); //$NON-NLS-1$
if (showError) {
image = CommonImages.OVERLAY_SYNC_ERROR;
} else {
image = CommonImages.OVERLAY_SYNC_WARNING;
}
return image;
}
public static synchronized IUndoContext getUndoContext() {
if (undoContext == null) {
undoContext = new ObjectUndoContext(new Object(), "Tasks Context"); //$NON-NLS-1$
}
return undoContext;
}
/**
* Deletes the given task from the Task List, the Task Context Store, and the Task Data Manager.
*
* @param task
* the task to delete
*/
public static void deleteTask(ITask task) {
TasksUiInternal.getTaskList().deleteTask(task);
TasksUiPlugin.getContextStore().deleteContext(task);
try {
TasksUiPlugin.getTaskDataManager().deleteTaskData(task);
} catch (CoreException e) {
StatusHandler.log(new Status(IStatus.ERROR, TasksUiPlugin.ID_PLUGIN, "Failed to delete task data", e)); //$NON-NLS-1$
}
}
}