protected WorkItemType getWorkItem(Task task, OperationResult result) throws SchemaException, SecurityViolationException, ConfigurationException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException { //Collection<SelectorOptions<GetOperationOptions>> options = GetOperationOptions.resolveItemsNamed(WorkItemType.F_TASK_REF); SearchResultList<WorkItemType> itemsAll = modelService.searchContainers(WorkItemType.class, null, null, task, result); if (itemsAll.size() != 1) { System.out.println("Unexpected # of work items: " + itemsAll.size()); for (WorkItemType workItem : itemsAll) { System.out.println(PrismUtil.serializeQuietly(prismContext, workItem)); } } assertEquals("Wrong # of total work items", 1, itemsAll.size()); return itemsAll.get(0); }
public SearchResultList<T> clone() { SearchResultList<T> clone = new SearchResultList<>(); clone.metadata = this.metadata; // considered read-only object if (this.list != null) { clone.list = new ArrayList(this.list.size()); for (T item : this.list) { clone.list.add(CloneUtil.clone(item)); } } return clone; }
private Collection<String> getNodeIdentifiers(WorkerTasksPerNodeConfigurationType perNodeConfig, OperationResult opResult) throws SchemaException { if (!perNodeConfig.getNodeIdentifier().isEmpty()) { return perNodeConfig.getNodeIdentifier(); } else { SearchResultList<PrismObject<NodeType>> nodes = taskManager.searchObjects(NodeType.class, null, null, opResult); return nodes.stream() .filter(n -> n.asObjectable().getExecutionStatus() == NodeExecutionStatusType.RUNNING) .map(n -> n.asObjectable().getNodeIdentifier()) .collect(Collectors.toSet()); } }
public SearchResultList<PrismObject<ShadowType>> searchObjects(ObjectQuery query, Collection<SelectorOptions<GetOperationOptions>> options, final boolean readFromRepository, Task task, final OperationResult parentResult) throws SchemaException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException, ExpressionEvaluationException { SearchResultList<PrismObject<ShadowType>> list = new SearchResultList<>(); SearchResultMetadata metadata = searchObjectsIterative(query, options, (shadow,result) -> list.add(shadow), readFromRepository, task, parentResult); list.setMetadata(metadata); return list; }
private SearchResultList<WorkItemType> tasksToWorkItems(List<Task> tasks, Map<String, Object> processVariables, boolean resolveTask, boolean resolveAssignee, boolean resolveCandidates, boolean fetchAllVariables, OperationResult result) { SearchResultList<WorkItemType> retval = new SearchResultList<>(new ArrayList<WorkItemType>()); for (Task task : tasks) { try { retval.add(taskToWorkItem(task, processVariables, resolveTask, resolveAssignee, resolveCandidates, fetchAllVariables, result)); } catch (RuntimeException e) { // operation result already contains corresponding error record LoggingUtils.logUnexpectedException(LOGGER, "Couldn't get information on activiti task {}", e, task.getId()); } } return retval; }
private void checkResult(Class<? extends ObjectType> queryClass, Class<? extends ObjectType> realClass, String oid, ObjectQuery query, String[] names) throws SchemaException { OperationResult result = new OperationResult("search"); SearchResultList<? extends PrismObject<? extends ObjectType>> objects = repositoryService.searchObjects(queryClass, query, null, result); System.out.println(realClass.getSimpleName() + " owned by " + oid + ": " + objects.size()); assertEquals("Wrong # of found objects", names.length, objects.size()); Set<String> expectedNames = new HashSet<>(Arrays.asList(names)); Set<String> realNames = new HashSet<>(); for (PrismObject<? extends ObjectType> object : objects) { realNames.add(object.asObjectable().getName().getOrig()); } assertEquals("Wrong names of found objects", expectedNames, realNames); }
return new SearchResultList<>(new ArrayList<>()); list = new SearchResultList<>(new ArrayList<PrismObject<T>>()); LOGGER.trace("Basic search returned {} results (before hooks, security, etc.)", list.size()); LOGGER.trace("Final search returned {} results (after hooks, security and all other processing)", list.size()); OP_LOGGER.debug("MODEL OP exit searchObjects({},{},{}): {}", type.getSimpleName(), query, rawOptions, list.shortDump()); OP_LOGGER.trace("MODEL OP exit searchObjects({},{},{}): {}\n{}", type.getSimpleName(), query, rawOptions, list.shortDump(), DebugUtil.debugDump(list.getList(), 1));
@Test public void test100FixDuplicatesWithDifferentObjectClasses() throws Exception { final String TEST_NAME = "test100FixDuplicatesWithDifferentObjectClasses"; TestUtil.displayTestTitle(this, TEST_NAME); login(userAdministrator); Task task = createTask(TEST_NAME); OperationResult result = task.getResult(); // GIVEN SearchResultList<PrismObject<ShadowType>> shadowsBefore = repositoryService .searchObjects(ShadowType.class, null, null, result); display("shadows before", shadowsBefore); assertEquals("Wrong # of shadows before", 3, shadowsBefore.size()); repoAddObjectFromFile(TASK_SHADOW_INTEGRITY_CHECK_FILE, result); // WHEN displayWhen(TEST_NAME); waitForTaskCloseOrSuspend(TASK_SHADOW_INTEGRITY_CHECK_OID); // THEN displayThen(TEST_NAME); PrismObject<TaskType> taskAfter = getTask(TASK_SHADOW_INTEGRITY_CHECK_OID); display("task after", taskAfter); SearchResultList<PrismObject<ShadowType>> shadowsAfter = repositoryService .searchObjects(ShadowType.class, null, null, result); display("shadows after", shadowsAfter); assertEquals("Wrong # of shadows after", 2, shadowsAfter.size()); PrismObject<ShadowType> intent1 = shadowsAfter.stream() .filter(o -> "intent1".equals(o.asObjectable().getIntent())).findFirst().orElse(null); assertNotNull("intent1 shadow was removed", intent1); }
try { owners = repositoryService.searchObjects(UserType.class, query, null, result); if (owners.isEmpty()) { return null; if (owners.size() > 1) { LOGGER.warn("More than one owner of {}: {}", object, owners); owner = (PrismObject<F>) owners.get(0); } catch (SchemaException e) { LOGGER.warn("Cannot resolve owner of {}: {}", object, e.getMessage(), e);
if (nodes == null || nodes.isEmpty()) { LOGGER.error("Could not found node for storing the report."); throw new ObjectNotFoundException("Could not find node where to save report"); if (nodes.size() > 1) { LOGGER.error("Found more than one node with ID {}.", task.getNode()); throw new IllegalStateException("Found more than one node with ID " + task.getNode()); reportOutputType.setNodeRef(ObjectTypeUtil.createObjectRef(nodes.iterator().next(), prismContext));
while (true) { objects = modelService.searchObjects(objectType, query, searchOptions, task, opResult); if (objects.isEmpty()) { break; if (LOGGER.isTraceEnabled()) { LOGGER.trace("Search returned {} objects, {} skipped, progress: {}, result:\n{}", objects.size(), skipped, task.getProgress(), opResult.debugDump()); if (objects.size() == skipped) { break;
@Test public void test201SearchObjects() throws Exception { final String TEST_NAME = "test201SearchObjects"; displayTestTitle(TEST_NAME); Task task = createTask(TEST_NAME); OperationResult result = task.getResult(); ShadowType object = parseObjectType(ACCOUNT_SEARCH_FILE, ShadowType.class); display("New object", object); String addedObjectOid = provisioningService.addObject(object.asPrismObject(), null, null, taskManager.createTaskInstance(), result); assertEquals(ACCOUNT_SEARCH_OID, addedObjectOid); QueryType queryType = PrismTestUtil.parseAtomicValue(QUERY_ALL_ACCOUNTS_FILE, QueryType.COMPLEX_TYPE); ObjectQuery query = getQueryConverter().createObjectQuery(ShadowType.class, queryType); rememberCounter(InternalCounters.CONNECTOR_OPERATION_COUNT); rememberCounter(InternalCounters.CONNECTOR_SIMULATED_PAGING_SEARCH_COUNT); // WHEN SearchResultList<PrismObject<ShadowType>> searchResults = provisioningService.searchObjects(ShadowType.class, query, null, task, result); // THEN result.computeStatus(); assertSuccess(result); display("Search resutls", searchResults); assertEquals("Unexpected number of search results", 14, searchResults.size()); assertConnectorOperationIncrement(1, 29); assertCounterIncrement(InternalCounters.CONNECTOR_SIMULATED_PAGING_SEARCH_COUNT, 0); // SPR search. No estimate. assertApproxNumberOfAllResults(searchResults.getMetadata(), null); }
return new SearchResultList<>(newValues, originalResultList.getMetadata());
@Override public <T extends ObjectType> SearchResultMetadata searchObjectsIterative(Class<T> type, ObjectQuery query, Collection<SelectorOptions<GetOperationOptions>> options, ResultHandler<T> handler, OperationResult parentResult) throws SchemaException { OperationResult result = parentResult.createMinorSubresult(DOT_INTERFACE + ".searchObjects"); result.addParam("objectType", type); result.addParam("query", query); result.addArbitraryObjectCollectionAsParam("options", options); result.addContext(OperationResult.CONTEXT_IMPLEMENTATION_CLASS, TaskManagerQuartzImpl.class); SearchResultList<PrismObject<T>> objects; if (TaskType.class.isAssignableFrom(type)) { //noinspection unchecked objects = (SearchResultList<PrismObject<T>>) (SearchResultList) searchTasks(query, options, result); } else if (NodeType.class.isAssignableFrom(type)) { //noinspection unchecked objects = (SearchResultList<PrismObject<T>>) (SearchResultList) searchNodes(query, options, result); } else { throw new IllegalArgumentException("Unsupported object type: " + type); } for (PrismObject<T> object: objects) { handler.handle(object, result); } result.computeStatus(); return objects.getMetadata(); }
private boolean campaignExists(String name, OperationResult result) throws SchemaException { ObjectQuery query = ObjectQueryUtil.createNameQuery(AccessCertificationCampaignType.class, prismContext, name); SearchResultList<PrismObject<AccessCertificationCampaignType>> existingCampaigns = repositoryService.searchObjects(AccessCertificationCampaignType.class, query, null, result); return !existingCampaigns.isEmpty(); }
<T extends ObjectType> List<T> searchObjects(Class<T> type, ObjectQuery query) { List<T> ret = new ArrayList<>(); Task task = taskManager.createTaskInstance(); try { List<PrismObject<T>> list = model.searchObjects(type, query, null, task, task.getResult()).getList(); for (PrismObject<T> po : list) { ret.add(po.asObjectable()); } } catch (SchemaException | ObjectNotFoundException | SecurityViolationException | CommunicationException | ConfigurationException | ExpressionEvaluationException e) { LOGGER.error("Could not search objects of type: " + type + " with query " + query + ". Reason: " + e.getMessage()); } return ret; }
@Override public boolean handle(PrismObject<ResourceType> object, OperationResult parentResult) { resources.add(object); return true; } };
@Test public void test100SearchCases() throws Exception { final String TEST_NAME = "test100CreateCase"; Task task = taskManager.createTaskInstance(TEST_NAME); OperationResult result = task.getResult(); login(userAdministrator); SearchResultList<PrismObject<CaseType>> cases = controller.searchObjects(CaseType.class, null, null, task, result); assertEquals(3, cases.size()); SearchResultList<CaseWorkItemType> workItems = controller.searchContainers(CaseWorkItemType.class, null, null, task, result); assertEquals(4, workItems.size()); }