private void doUpdate(@Nullable Runnable onComplete) { try { List<Task> issues = getIssuesFromRepositories( null, myConfig.updateIssuesCount, 0, false, new EmptyProgressIndicator()); if (issues == null) return; synchronized (myIssueCache) { myIssueCache.clear(); for (Task issue : issues) { myIssueCache.put(issue.getId(), issue); } } // update local tasks synchronized (myTasks) { for (Map.Entry<String, LocalTask> entry : myTasks.entrySet()) { Task issue = myIssueCache.get(entry.getKey()); if (issue != null) { entry.getValue().updateFromIssue(issue); } } } } finally { if (onComplete != null) { onComplete.run(); } myUpdating = false; } }
@Override public void removeTask(LocalTask task) { if (task.isDefault()) return; if (myActiveTask.equals(task)) { activateTask(myTasks.get(LocalTaskImpl.DEFAULT_TASK_ID), true); } myTasks.remove(task.getId()); myDispatcher.getMulticaster().taskRemoved(task); myContextManager.removeContext(task); }
public void updateIssues(final @Nullable Runnable onComplete) { TaskRepository first = ContainerUtil.find( getAllRepositories(), new Condition<TaskRepository>() { public boolean value(TaskRepository repository) { return repository.isConfigured(); } }); if (first == null) { myIssueCache.clear(); if (onComplete != null) { onComplete.run(); } return; } myUpdating = true; if (ApplicationManager.getApplication().isUnitTestMode()) { doUpdate(onComplete); } else { ApplicationManager.getApplication() .executeOnPooledThread( new Runnable() { public void run() { doUpdate(onComplete); } }); } }
public <T extends TaskRepository> void setRepositories(List<T> repositories) { Set<TaskRepository> set = new HashSet<TaskRepository>(myRepositories); set.removeAll(repositories); myBadRepositories.removeAll(set); // remove all changed reps myIssueCache.clear(); myRepositories.clear(); myRepositories.addAll(repositories); reps: for (T repository : repositories) { if (repository.isShared() && repository.getUrl() != null) { List<TaskProjectConfiguration.SharedServer> servers = getProjectConfiguration().servers; TaskRepositoryType type = repository.getRepositoryType(); for (TaskProjectConfiguration.SharedServer server : servers) { if (repository.getUrl().equals(server.url) && type.getName().equals(server.type)) { continue reps; } } TaskProjectConfiguration.SharedServer server = new TaskProjectConfiguration.SharedServer(); server.type = type.getName(); server.url = repository.getUrl(); servers.add(server); } } }
@Override public List<Task> getCachedIssues(final boolean withClosed) { return ContainerUtil.filter( myIssueCache.values(), new Condition<Task>() { @Override public boolean value(final Task task) { return withClosed || !task.isClosed(); } }); }
@SuppressWarnings({"unchecked"}) public void loadState(Config config) { XmlSerializerUtil.copyBean(config, myConfig); myTasks.clear(); for (LocalTaskImpl task : config.tasks) { addTask(task); } myRepositories.clear(); Element element = config.servers; List<TaskRepository> repositories = loadRepositories(element); myRepositories.addAll(repositories); }
@Override public List<LocalTask> getLocalTasks(final boolean withClosed) { synchronized (myTasks) { return ContainerUtil.filter( myTasks.values(), new Condition<LocalTask>() { @Override public boolean value(final LocalTask task) { return withClosed || !isLocallyClosed(task); } }); } }
@SuppressWarnings({"unchecked"}) @NotNull public Config getState() { myConfig.tasks = ContainerUtil.map( myTasks.values(), new Function<Task, LocalTaskImpl>() { public LocalTaskImpl fun(Task task) { return new LocalTaskImpl(task); } }); myConfig.servers = XmlSerializer.serialize(getAllRepositories()); return myConfig; }
@Override public List<Task> getIssues( @Nullable String query, int max, long since, boolean forceRequest, final boolean withClosed, @NotNull final ProgressIndicator cancelled) { List<Task> tasks = getIssuesFromRepositories(query, max, since, forceRequest, cancelled); if (tasks == null) return getCachedIssues(withClosed); myIssueCache.putAll(ContainerUtil.newMapFromValues(tasks.iterator(), KEY_CONVERTOR)); return ContainerUtil.filter( tasks, new Condition<Task>() { @Override public boolean value(final Task task) { return withClosed || !task.isClosed(); } }); }
private void addTask(LocalTaskImpl task) { myTasks.put(task.getId(), task); myDispatcher.getMulticaster().taskAdded(task); }
@Nullable @Override public LocalTask findTask(String id) { return myTasks.get(id); }