private List<AccessCertificationCaseType> getCertificationCampaignCasesAsBeans(String campaignName) throws SchemaException, SecurityViolationException, ConfigurationException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException { Task task = taskManager.createTaskInstance(); ObjectQuery query; if (StringUtils.isEmpty(campaignName)) { //query = null; return new ArrayList<>(); } else { query = prismContext.queryFor(AccessCertificationCaseType.class) .item(PrismConstants.T_PARENT, F_NAME).eqPoly(campaignName, "").matchingOrig() // TODO first by object/target type then by name (not supported by the repository as of now) .asc(AccessCertificationCaseType.F_OBJECT_REF, PrismConstants.T_OBJECT_REFERENCE, ObjectType.F_NAME) .asc(AccessCertificationCaseType.F_TARGET_REF, PrismConstants.T_OBJECT_REFERENCE, ObjectType.F_NAME) .build(); } Collection<SelectorOptions<GetOperationOptions>> options = SelectorOptions.createCollection(GetOperationOptions.createResolveNames()); return model.searchContainers(AccessCertificationCaseType.class, query, options, task, task.getResult()); }
private List<AccessCertificationCaseType> getCertificationCampaignNotRespondedCasesAsBeans(String campaignName) throws SchemaException, SecurityViolationException, ConfigurationException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException { Task task = taskManager.createTaskInstance(); ObjectQuery query; if (StringUtils.isEmpty(campaignName)) { //query = null; return new ArrayList<>(); } else { query = prismContext.queryFor(AccessCertificationCaseType.class) .item(PrismConstants.T_PARENT, F_NAME).eqPoly(campaignName, "").matchingOrig() .and().item(AccessCertificationCaseType.F_CURRENT_STAGE_OUTCOME).eq(SchemaConstants.MODEL_CERTIFICATION_OUTCOME_NO_RESPONSE) // TODO first by object/target type then by name (not supported by the repository as of now) .asc(AccessCertificationCaseType.F_OBJECT_REF, PrismConstants.T_OBJECT_REFERENCE, ObjectType.F_NAME) .asc(AccessCertificationCaseType.F_TARGET_REF, PrismConstants.T_OBJECT_REFERENCE, ObjectType.F_NAME) .build(); } Collection<SelectorOptions<GetOperationOptions>> options = SelectorOptions.createCollection(GetOperationOptions.createResolveNames()); return model.searchContainers(AccessCertificationCaseType.class, query, options, task, task.getResult()); }
@Test public void test200OrderByName() throws Exception{ ObjectQuery actual = getPrismContext().queryFor(UserType.class) .asc(UserType.F_NAME) .build(); ObjectQuery expected = ObjectQueryImpl.createObjectQuery( ObjectPagingImpl.createPaging(UserType.F_NAME, OrderDirection.ASCENDING) ); compare(actual, expected); }
@Test public void test011OrgFilter() throws Exception { final String TEST_NAME = "test011OrgFilter"; TestUtil.displayTestTitle(TEST_NAME); OperationResult opResult = new OperationResult(TEST_NAME); ObjectQuery query = prismContext.queryFor(ObjectType.class) .isDirectChildOf(ORG_F001_OID) .asc(ObjectType.F_NAME) .build(); // WHEN List<PrismObject<ObjectType>> orgClosure = repositoryService.searchObjects(ObjectType.class, query, null, opResult); // THEN AssertJUnit.assertEquals(4, orgClosure.size()); }
private void cleanupCampaignsByNumber(int maxRecords, Task task, OperationResult parentResult) { OperationResult result = parentResult.createSubresult(OPERATION_CLEANUP_CAMPAIGNS_BY_NUMBER); LOGGER.info("Starting cleanup for closed certification campaigns, keeping {} ones.", maxRecords); int deleted = 0; Set<String> poisonedCampaigns = new HashSet<>(); try { for (;;) { ObjectQuery query = prismContext.queryFor(AccessCertificationCampaignType.class) .item(AccessCertificationCampaignType.F_STATE).eq(AccessCertificationCampaignStateType.CLOSED) .and().not().id(poisonedCampaigns.toArray(new String[0])) // hoping there are not many of these .desc(AccessCertificationCampaignType.F_END_TIMESTAMP) .offset(maxRecords) .maxSize(DELETE_BLOCK_SIZE) .build(); int delta = searchAndDeleteCampaigns(query, poisonedCampaigns, result, task); if (delta == 0) { LOGGER.info("Deleted {} campaigns.", deleted); return; } } } finally { result.computeStatusIfUnknown(); } }
@Test public void test006searchOrgStructUserUnbounded() throws Exception { OperationResult parentResult = new OperationResult("test006searchOrgStructUserUnbounded"); ObjectQuery objectQuery = prismContext.queryFor(ObjectType.class) .isChildOf(SEARCH_ORG_OID_UNBOUNDED_DEPTH) .asc(ObjectType.F_NAME) .build(); List<PrismObject<ObjectType>> orgClosure = repositoryService.searchObjects(ObjectType.class, objectQuery, null, parentResult); for (PrismObject<ObjectType> u : orgClosure) { LOGGER.info("USER000 ======> {}", ObjectTypeUtil.toShortString(u.asObjectable())); } AssertJUnit.assertEquals(7, orgClosure.size()); }
@Test public void test008searchRootOrg() throws Exception { OperationResult parentResult = new OperationResult("test008searchRootOrg"); ObjectQuery qSearch = prismContext.queryFor(ObjectType.class) .isRoot() .asc(ObjectType.F_NAME) .build(); List<PrismObject<OrgType>> rootOrgs = repositoryService.searchObjects(OrgType.class, qSearch, null, parentResult); for (PrismObject<OrgType> ro : rootOrgs) { LOGGER.info("ROOT ========= {}", ObjectTypeUtil.toShortString(ro.asObjectable())); } AssertJUnit.assertEquals(5, rootOrgs.size()); }
@Test public void test1400QueryOrderByNameOrigLimit20() throws Exception { Session session = open(); try { ObjectQuery query = prismContext.queryFor(UserType.class).asc(UserType.F_NAME).maxSize(20).build(); String expected = "select\n" + " u.oid, u.fullObject, u.stringsCount, u.longsCount, u.datesCount, u.referencesCount, u.polysCount, u.booleansCount\n" + "from\n" + " RUser u\n" + "order by\n" + "u.nameCopy.orig asc"; String real = getInterpretedQuery2(session, UserType.class, query); assertEqualsIgnoreWhitespace(expected, real); } finally { close(session); } }
@Test public void test1410QueryOrderByNameOrigLimit20() throws Exception { Session session = open(); try { ObjectQuery query = prismContext.queryFor(RoleType.class).asc(RoleType.F_NAME).maxSize(20).build(); String expected = "select\n" + " r.oid, r.fullObject, r.stringsCount, r.longsCount, r.datesCount, r.referencesCount, r.polysCount, r.booleansCount\n" + "from\n" + " RRole r\n" + "order by\n" + "r.nameCopy.orig asc"; String real = getInterpretedQuery2(session, RoleType.class, query); assertEqualsIgnoreWhitespace(expected, real); } finally { close(session); } }
@Test public void test0707QueryCertWorkItemAllOrderByCampaignName() throws Exception { Session session = open(); try { ObjectQuery q = prismContext.queryFor(AccessCertificationWorkItemType.class) .asc(PrismConstants.T_PARENT, PrismConstants.T_PARENT, F_NAME) .build(); String real = getInterpretedQuery2(session, AccessCertificationWorkItemType.class, q, false); String expected = "select\n" + " a.ownerOwnerOid,\n" + " a.ownerId,\n" + " a.id\n" + "from\n" + " RAccessCertificationWorkItem a\n" + " left join a.owner o\n" + " left join o.owner o2\n" + "order by o2.nameCopy.orig asc\n"; assertEqualsIgnoreWhitespace(expected, real); } finally { close(session); } }
public List<PrismObject<AccessCertificationCampaignType>> getCertificationCampaigns(Boolean alsoClosedCampaigns) throws SchemaException, ConfigurationException, ObjectNotFoundException, CommunicationException, SecurityViolationException, ExpressionEvaluationException { Task task = taskManager.createTaskInstance(); ObjectQuery query = prismContext.queryFor(AccessCertificationCampaignType.class) .asc(F_NAME) .build(); if (!Boolean.TRUE.equals(alsoClosedCampaigns)) { query.addFilter( prismContext.queryFor(AccessCertificationCampaignType.class) .not().item(F_STATE).eq(CLOSED) .buildFilter() ); } Collection<SelectorOptions<GetOperationOptions>> options = schemaHelper.getOperationOptionsBuilder() .root().resolveNames() .item(AccessCertificationCampaignType.F_CASE).retrieve() .build(); return model.searchObjects(AccessCertificationCampaignType.class, query, options, task, task.getResult()); }
@Test public void test1220IgnorableDistinctAndOrderBy() throws Exception { Session session = open(); try { ObjectQuery query = prismContext.queryFor(UserType.class) .asc(UserType.F_NAME) .build(); String real = getInterpretedQuery2(session, UserType.class, query, false, distinct()); String expected; expected = "select u.oid,\n" + " u.fullObject,\n" + " u.stringsCount,\n" + " u.longsCount,\n" + " u.datesCount,\n" + " u.referencesCount,\n" + " u.polysCount,\n" + " u.booleansCount\n" + "from\n" + " RUser u\n" + "order by u.nameCopy.orig asc\n"; assertEqualsIgnoreWhitespace(expected, real); } finally { close(session); } }
@Test public void test0300CountObjectOrderByName() throws Exception { Session session = open(); try { ObjectQuery query = prismContext.queryFor(UserType.class) .item(F_NAME).eqPoly("cpt. Jack Sparrow", "cpt jack sparrow") .asc(F_NAME).build(); String real = getInterpretedQuery2(session, UserType.class, query, true); String expected = "select\n" + " count(u.oid)\n" + "from\n" + " RUser u\n" + "where\n" + " (\n" + " u.nameCopy.orig = :orig and\n" + " u.nameCopy.norm = :norm\n" + " )\n"; assertEqualsIgnoreWhitespace(expected, real); } finally { close(session); } }
/** * Q{AND: (EQUALS: parent, PPV(null)),PAGING: O: 0,M: 5,BY: name, D:ASCENDING, */ @Test public void test0320CountTaskOrderByName() throws Exception { Session session = open(); try { ObjectQuery query = prismContext.queryFor(TaskType.class) .item(TaskType.F_PARENT).isNull() .asc(F_NAME) .build(); String real = getInterpretedQuery2(session, TaskType.class, query, true); String expected = "select\n" + " count(t.oid)\n" + "from\n" + " RTask t\n" + "where\n" + " t.parent is null"; assertEqualsIgnoreWhitespace(expected, real); } finally { close(session); } }
@Test public void test120DeleteHalf() throws Exception { OperationResult result = new OperationResult("test120DeleteHalf"); createObjects(); final List<PrismObject<UserType>> objects = new ArrayList<>(); ResultHandler<UserType> handler = (object, parentResult) -> { objects.add(object); try { int number = Integer.parseInt(object.asObjectable().getCostCenter()); if (number % 2 == 0) { repositoryService.deleteObject(UserType.class, object.getOid(), parentResult); } } catch (ObjectNotFoundException e) { throw new SystemException(e); } return true; }; repositoryService.searchObjectsIterative(UserType.class, null, handler, null, true, result); result.recomputeStatus(); assertTrue(result.isSuccess()); assertObjects(objects, COUNT); int count = repositoryService.countObjects(UserType.class, null, null, result); assertEquals("Wrong # of objects after operation", COUNT/2, count); ObjectQuery query = prismContext.queryFor(UserType.class) .asc(UserType.F_NAME) .build(); List<PrismObject<UserType>> objectsAfter = repositoryService.searchObjects(UserType.class, query, null, result); objectsAfter.forEach(o -> System.out.println("Exists: " + o.asObjectable().getName())); }
@Test public void test007searchOrgStructOrgDepth() throws Exception { OperationResult parentResult = new OperationResult("test007searchOrgStructOrgDepth"); Session session = open(); try { List<ROrgClosure> orgClosure = getOrgClosure(SEARCH_ORG_OID_DEPTH1, SEARCH_ORG_OID_DEPTH1, session); LOGGER.info("==============CLOSURE TABLE=========="); for (ROrgClosure o : orgClosure) { LOGGER.info("=> A: {}, D: {}", o.getAncestor(), o.getDescendant()); } AssertJUnit.assertEquals(1, orgClosure.size()); session.getTransaction().commit(); session.close(); ObjectQuery objectQuery = prismContext.queryFor(ObjectType.class) .isDirectChildOf(SEARCH_ORG_OID_DEPTH1) .asc(ObjectType.F_NAME) .build(); List<PrismObject<ObjectType>> sOrgClosure = repositoryService.searchObjects(ObjectType.class, objectQuery, null, parentResult); for (PrismObject<ObjectType> u : sOrgClosure) { LOGGER.info("USER000 ======> {}", ObjectTypeUtil.toShortString(u.asObjectable())); } AssertJUnit.assertEquals(4, sOrgClosure.size()); } finally { if (session.isOpen()) { close(session); } } }
@Test public void test0340QueryOrgTreeFindOrgs() throws Exception { Session session = open(); try { ObjectQuery query = prismContext.queryFor(OrgType.class) .isDirectChildOf("some oid") .asc(F_NAME) .build(); String real = getInterpretedQuery2(session, OrgType.class, query); OperationResult result = new OperationResult("query org structure"); repositoryService.searchObjects(OrgType.class, query, null, result); String expected = "select\n" + " o.oid, o.fullObject,\n" + " o.stringsCount,\n" + " o.longsCount,\n" + " o.datesCount,\n" + " o.referencesCount,\n" + " o.polysCount,\n" + " o.booleansCount\n" + "from\n" + " ROrg o\n" + "where\n" + " o.oid in (select ref.ownerOid from RObjectReference ref where ref.referenceType = 0 and ref.targetOid = :orgOid)\n" + "order by o.nameCopy.orig asc\n"; assertEqualsIgnoreWhitespace(expected, real); } finally { close(session); } }
@Test public void test210OrderByNameAndId() { ObjectQuery actual = getPrismContext().queryFor(UserType.class) .item(UserType.F_LOCALITY).eq("Caribbean") .asc(UserType.F_NAME) .desc(PrismConstants.T_ID) .build(); ObjectPaging paging = ObjectPagingImpl.createEmptyPaging(); paging.addOrderingInstruction(UserType.F_NAME, OrderDirection.ASCENDING); paging.addOrderingInstruction(ItemPath.create(PrismConstants.T_ID), OrderDirection.DESCENDING); ObjectQuery expected = ObjectQueryImpl.createObjectQuery( createEqual(UserType.F_LOCALITY, UserType.class, null, "Caribbean"), paging); compare(actual, expected); }
@Test(expectedExceptions = UnsupportedOperationException.class) public void test0089QueryExistsAssignmentAll() throws Exception { Session session = open(); try { ObjectQuery query = prismContext.queryFor(UserType.class) .exists(F_ASSIGNMENT).all() .asc(F_NAME) .build(); query.setFilter(ObjectQueryUtil.simplify(query.getFilter(), prismContext)); String real = getInterpretedQuery2(session, UserType.class, query); // this doesn't work as expected ... maybe inner join would be better! Until implemented, we should throw UOO String expected = "select\n" + " u.oid, u.fullObject,\n" + " u.stringsCount,\n" + " u.longsCount,\n" + " u.datesCount,\n" + " u.referencesCount,\n" + " u.polysCount,\n" + " u.booleansCount\n" + "from\n" + " RUser u\n" + " left join u.assignments a with a.assignmentOwner = :assignmentOwner\n" + "order by u.name.orig asc\n"; assertEqualsIgnoreWhitespace(expected, real); } finally { close(session); } }
private <T extends ObjectType> void checkQueryResult(Class<T> type, String oid, OrgFilter.Scope scope, int count) throws Exception { LOGGER.info("checkQueryResult"); ObjectQuery query = prismContext.queryFor(type) .isInScopeOf(oid, scope) .asc(F_NAME) .build(); OperationResult result = new OperationResult("checkQueryResult"); List<PrismObject<T>> objects = repositoryService.searchObjects(type, query, null, result); for (PrismObject object : objects) { LOGGER.info("{}", object.getOid()); } int realCount = objects.size(); assertEquals("Expected count doesn't match for searchObjects " + query, count, realCount); result.computeStatusIfUnknown(); assertTrue(result.isSuccess()); realCount = repositoryService.countObjects(type, query, null, result); assertEquals("Expected count doesn't match for countObjects " + query, count, realCount); result.computeStatusIfUnknown(); assertTrue(result.isSuccess()); }