Java IRepositoryQuery类代码示例

import org.eclipse.mylyn.tasks.core.IRepositoryQuery; //导入依赖的package包/类
/**
 * Queries tasks and returns a list of CharmTasks
 * 
 * @param monitor
 *            monitor for indicating the progress
 * @param query
 *            query-object which contains the query parameters
 * @return List of CharmTasks
 * @throws CharmException
 *             Error occurred while querying tasks
 */
public CharmQueryResults queryTasks(IProgressMonitor monitor, @NonNull IRepositoryQuery query)
		throws CharmException {

	Response response = buildWebTarget("/tasks", CharmQueryMessageBodyReader.class,
			CharmErrorMessageBodyReader.class)
					.queryParam("developer", query.getAttribute(CharmCorePlugin.QUERY_KEY_DEVELOPER))
					.queryParam("object_id", query.getAttribute(CharmCorePlugin.QUERY_KEY_OBJECT_ID))
					.queryParam("proc_type", query.getAttribute(CharmCorePlugin.QUERY_KEY_PROC_TYPE))
					.queryParam("status", query.getAttribute(CharmCorePlugin.QUERY_KEY_STATUS))
					.queryParam("priority", query.getAttribute(CharmCorePlugin.QUERY_KEY_PRIORITY))
					.request(MediaType.APPLICATION_XML).get();

	if (response.getStatus() == 200) {
		return (CharmQueryResults) response.readEntity(CharmQueryResults.class);
	} else {
		handleError(response);
	}
	return null;

}
 

import org.eclipse.mylyn.tasks.core.IRepositoryQuery; //导入依赖的package包/类
private void initialize() {
	IRepositoryQuery query = getQuery();
	if (query == null) {
		return;
	}
	
	titleText.setText(query.getSummary());
	assigneeText.setText(query.getAttribute("assignee"));
	milestoneCombo.setText(query.getAttribute("milestone"));
	
	openButton.setSelection(Boolean.parseBoolean(query.getAttribute("opened")));
	closedButton.setSelection(Boolean.parseBoolean(query.getAttribute("closed")));
	
	for(String label : query.getAttribute("labels").split(",")) {
		if(label.trim().length() > 0) {
			labelsViewer.add(label.trim());
		}
	}
	
}
 

import org.eclipse.mylyn.tasks.core.IRepositoryQuery; //导入依赖的package包/类
public SynchronizeQueryCommand createSynchronizeQueriesCommand (TaskRepository taskRepository, IRepositoryQuery iquery, IProgressMonitor monitor) {
    assert iquery instanceof RepositoryQuery;
    RepositoryQuery repositoryQuery;
    if (iquery instanceof RepositoryQuery) {
        repositoryQuery = (RepositoryQuery) iquery;
    } else {
        return null;
    }
    AbstractRepositoryConnector repositoryConnector = taskRepositoryManager.getRepositoryConnector(taskRepository.getConnectorKind());
    return new SynchronizeQueryCommand(repositoryModel, repositoryConnector,
            taskRepository, taskList, taskDataManager, repositoryQuery, monitor);
}
 

import org.eclipse.mylyn.tasks.core.IRepositoryQuery; //导入依赖的package包/类
SimpleQueryCommand (AbstractRepositoryConnector repositoryConnector, 
        TaskRepository taskRepository, TaskDataManager taskDataManager,
        IRepositoryQuery query) {
    this.taskRepository = taskRepository;
    this.repositoryConnector = repositoryConnector;
    this.query = query;
    this.taskDataManager = taskDataManager;
    this.monitor = new CancelableProgressMonitor();        
    tasks = new HashSet<NbTask>();
}
 

import org.eclipse.mylyn.tasks.core.IRepositoryQuery; //导入依赖的package包/类
public Collection<NbTask> getTasks (IRepositoryQuery query) throws CoreException {
    assert query instanceof RepositoryQuery;
    if (query instanceof RepositoryQuery) {
        ensureTaskListLoaded();
        assert taskRepositoryManager.getRepositoryConnector(query.getConnectorKind()) != null
            : "Did you forget to implement RepositoryConnectorProvider?";
        return toNbTasks(((RepositoryQuery) query).getChildren());
    } else {
        return Collections.<NbTask>emptyList();
    }
}
 

import org.eclipse.mylyn.tasks.core.IRepositoryQuery; //导入依赖的package包/类
public void addQuery (TaskRepository taskRepository, IRepositoryQuery query) throws CoreException {
    if (!(query instanceof RepositoryQuery)) {
        throw new IllegalArgumentException("Query must be instance of RepositoryQuery: " + query);
    }
    ensureTaskListLoaded();
    assert taskRepositoryManager.getRepositoryConnector(taskRepository.getConnectorKind()) != null
            : "Did you forget to implement RepositoryConnectorProvider?";
    taskList.addQuery((RepositoryQuery) query);
}
 

import org.eclipse.mylyn.tasks.core.IRepositoryQuery; //导入依赖的package包/类
public IRepositoryQuery getRepositoryQuery (TaskRepository taskRepository, String queryName) throws CoreException {
    for (IRepositoryQuery q : getRepositoryQueries(taskRepository)) {
        if (queryName.equals(q.getSummary())) {
            return q;
        }
    }
    return null;
}
 

import org.eclipse.mylyn.tasks.core.IRepositoryQuery; //导入依赖的package包/类
public IRepositoryQuery createNewQuery (TaskRepository taskRepository, String queryName) throws CoreException {
    ensureTaskListLoaded();
    assert taskRepositoryManager.getRepositoryConnector(taskRepository.getConnectorKind()) != null
            : "Did you forget to implement RepositoryConnectorProvider?";
    IRepositoryQuery query = repositoryModel.createRepositoryQuery(taskRepository);
    assert query instanceof RepositoryQuery;
    query.setSummary(queryName);
    return query;
}
 

import org.eclipse.mylyn.tasks.core.IRepositoryQuery; //导入依赖的package包/类
public void removeQuery(BugzillaRepository repository, BugzillaQuery query) {
    getPreferences().remove(getQueryKey(repository.getID(), query.getDisplayName()));
    try {
        String storedName = query.getStoredQueryName();
        IRepositoryQuery iquery = storedName == null ? null 
                : MylynSupport.getInstance().getRepositoryQuery(repository.getTaskRepository(), storedName);
        if (iquery != null) {
            MylynSupport.getInstance().deleteQuery(iquery);
        }
    } catch (CoreException ex) {
        Bugzilla.LOG.log(Level.WARNING, null, ex);
    }
}
 

import org.eclipse.mylyn.tasks.core.IRepositoryQuery; //导入依赖的package包/类
public BugzillaQuery (String name, IRepositoryQuery query, BugzillaRepository repository, String urlParameters, boolean saved, boolean urlDef, boolean initControler) {
    this.repository = repository;
    this.saved = saved;
    this.name = name;
    this.iquery = query;
    this.urlParameters = urlParameters;
    this.initialUrlDef = urlDef;
    this.lastRefresh = BugzillaConfig.getInstance().getLastQueryRefresh(repository, getStoredQueryName());
    
    if(initControler) {
        controller = createControler(repository, this, urlParameters);
    }
}
 

import org.eclipse.mylyn.tasks.core.IRepositoryQuery; //导入依赖的package包/类
/**
 * Do not call this method other than from BugzillaConfig.
 * To be overridden by KenaiRepository
 */
public BugzillaQuery createPersistentQuery (String queryName, String urlParams, boolean urlDef) {
    IRepositoryQuery query = null;
    try {
        query = MylynSupport.getInstance().getRepositoryQuery(getTaskRepository(), queryName);
    } catch (CoreException ex) {
        Bugzilla.LOG.log(Level.WARNING, null, ex);
    }
    return new BugzillaQuery(queryName, query, this, urlParams, true, urlDef, true);
}
 

import org.eclipse.mylyn.tasks.core.IRepositoryQuery; //导入依赖的package包/类
public void testModifyQuery () throws Exception {
    MylynSupport supp = MylynSupport.getInstance();
    IRepositoryQuery query = supp.getRepositoryQuery(btr, QUERY_NAME);
    Collection<NbTask> tasks = supp.getTasks(query);
    Collection<NbTask> toRemove = new HashSet<NbTask>();
    for (NbTask task : tasks) {
        if (task.isCompleted()) {
            toRemove.add(task);
        }
    }
    assertFalse(toRemove.isEmpty());
    
    // make another new task so the query is not empty
    NbTask createdTask = createNewTask("New task testModifyQuery");
    
    // modify query to make it more precise - will not list closed tasks
    assertFalse(tasks.isEmpty());
    DummyQueryController controller = new DummyQueryController(query);
    query.setUrl(query.getUrl() + "&bug_status=NEW" + "&bug_status=REOPENED"); //NOI18N
    // synchronize
    SynchronizeQueryCommand cmd = supp.getCommandFactory().createSynchronizeQueriesCommand(btr, query);
    cmd.addCommandProgressListener(controller);
    br.getExecutor().execute(cmd);
    
    tasks = controller.tasks;
    assertFalse(tasks.isEmpty());
    assertEquals(new HashSet<NbTask>(supp.getTasks(query)), new HashSet<NbTask>(tasks));
    for (NbTask removedTask : toRemove) {
        assertFalse(tasks.contains(removedTask));
    }
    assertTrue(tasks.contains(createdTask));
}
 

import org.eclipse.mylyn.tasks.core.IRepositoryQuery; //导入依赖的package包/类
public void testTaskRemovedFromQueryInt () throws Exception {
    MylynSupport supp = MylynSupport.getInstance();
    IRepositoryQuery q = supp.getRepositoryQuery(btr, QUERY_NAME);
    Collection<NbTask> tasks = supp.getTasks(q);
    
    // get tasks from the query
    assertFalse(tasks.isEmpty());
    DummyQueryController controller = new DummyQueryController(q);
    // get a task to close
    NbTask task = tasks.iterator().next();
    assertTrue(controller.tasks.contains(task));
    // close the task in editor
    DummyEditorPage page = new DummyEditorPage(task);
    page.open();
    page.closeTask("WONTFIX");
    page.save();
    
    // submit
    page.submit();
    assertTrue(task.isCompleted());
    
    // refresh query
    SynchronizeQueryCommand cmd = supp.getCommandFactory().createSynchronizeQueriesCommand(btr, q);
    cmd.addCommandProgressListener(controller);
    br.getExecutor().execute(cmd);
    
    // task should be removed from the list
    assertFalse(controller.getTasks().contains(task));
    
    page.close();
}
 

import org.eclipse.mylyn.tasks.core.IRepositoryQuery; //导入依赖的package包/类
public void testTaskRemovedFromQueryExt () throws Exception {
    MylynSupport supp = MylynSupport.getInstance();
    IRepositoryQuery q = supp.getRepositoryQuery(btr, QUERY_NAME);
    Collection<NbTask> tasks = supp.getTasks(q);
    
    // get tasks from the query
    assertFalse(tasks.isEmpty());
    DummyQueryController controller = new DummyQueryController(q);
    // get a task to close
    NbTask task = tasks.iterator().next();
    assertTrue(controller.tasks.contains(task));
    
    // close the task externally
    assertFalse(task.isCompleted());
    TaskData external = task.getTaskDataState().getRepositoryData();
    TaskAttribute opAttr = external.getRoot().getMappedAttribute(TaskAttribute.OPERATION);
    TaskOperation taskOperation = null;
    for (TaskOperation op : external.getAttributeMapper().getTaskOperations(opAttr)) {
        if (BugzillaOperation.resolve.getLabel().equals(op.getLabel())) {
            taskOperation = op;
            break;
        }
    }
    assertNotNull(taskOperation);
    external.getAttributeMapper().setTaskOperation(opAttr, taskOperation);
    TaskAttribute resolutionAttr = external.getRoot().getMappedAttribute(BugzillaOperation.resolve.getInputId());
    resolutionAttr.setValue("WONTFIX");
    SubmitCommand submitCmd = new SubmitCommand(Bugzilla.getInstance().getRepositoryConnector(), btr, external);
    br.getExecutor().execute(submitCmd);
    
    // refresh query
    SynchronizeQueryCommand cmd = supp.getCommandFactory().createSynchronizeQueriesCommand(btr, q);
    cmd.addCommandProgressListener(controller);
    br.getExecutor().execute(cmd);
    
    // task should be removed from the list
    assertFalse(controller.getTasks().contains(task));
}
 

import org.eclipse.mylyn.tasks.core.IRepositoryQuery; //导入依赖的package包/类
@Override
public @NonNull IStatus performQuery(@NonNull TaskRepository repository, @NonNull IRepositoryQuery query,
		@NonNull TaskDataCollector collector, @Nullable ISynchronizationSession session,
		@NonNull IProgressMonitor monitor) {

	try {

		List<CharmQueryResult> charmTasks = getClient(repository).queryTasks(monitor, query).getQueryResults();
		SubMonitor subMonitor = SubMonitor.convert(monitor, charmTasks.size());

		for (CharmQueryResult charmTask : charmTasks) {
			TaskData taskData = this.taskDataHandler.parseQueryResults(repository, charmTask, monitor);
			taskData.setPartial(true);
			collector.accept(taskData);
			subMonitor.split(1);
		}

	} catch (CharmException | CoreException e) {
		return new Status(IStatus.ERROR, CharmCorePlugin.PLUGIN_ID, NLS.bind("Query failed: ''{0}''", e.getMessage()),
				e);
	} finally {
		monitor.done();
	}

	return Status.OK_STATUS;

}