public static void assertSubnode(MapXNode xmap, QName key, Class expectedClass) { XNode xsubnode = xmap.get(key); assert xsubnode != null : "No subnode "+key+" in "+xmap; assert expectedClass.isAssignableFrom(xsubnode.getClass()) : "Wrong class of subnode "+key+" in "+xmap+"; expected "+expectedClass+", got "+xsubnode.getClass(); }
public MapXNode serializeToXNode(PrismContext prismContext) throws SchemaException { MapXNode xmap = getFilterClauseXNode(); if (description == null) { return xmap; } else { // we have to serialize the map in correct order (see MID-1847): description first, filter clause next Map<QName, XNode> newXMap = new HashMap<>(); newXMap.put(SearchFilterType.F_DESCRIPTION, prismContext.xnodeFactory().primitive(description)); if (xmap != null && !xmap.isEmpty()) { Map.Entry<QName, ? extends XNode> filter = xmap.getSingleSubEntry("search filter"); newXMap.put(filter.getKey(), filter.getValue()); } return prismContext.xnodeFactory().map(newXMap); } }
public MapXNode getFilterClauseXNode() { if (this.filterClauseXNode == null) { return null; } else { return this.filterClauseXNode.clone(); } }
public static void displaySearchFilterType(SearchFilterType filterType) throws SchemaException { MapXNode mapXNode = filterType.getFilterClauseXNode(); String dumpX = mapXNode.debugDump(); LOGGER.info(dumpX); System.out.println("filter clause xnode:\n" + dumpX + "\n"); String dumpXml = prismContext.xmlSerializer().serialize( prismContext.xnodeFactory().root(new QName("filterClauseXNode"), mapXNode)); System.out.println("filter clause xnode serialized:\n" + dumpXml + "\n"); }
@SuppressWarnings("unchecked") @Test public void testEvaluateExpression() throws Exception { PrismObject<ShadowType> account = PrismTestUtil.parseObject(new File(TEST_FOLDER, "account.xml")); ShadowType accountType = account.asObjectable(); PrismObject<ResourceType> resource = PrismTestUtil.parseObject(new File(TEST_FOLDER_COMMON, "resource-dummy.xml")); ResourceType resourceType = resource.asObjectable(); accountType.setResource(resourceType); ObjectSynchronizationType synchronization = resourceType.getSynchronization().getObjectSynchronization().get(0); for (ConditionalSearchFilterType filter : synchronization.getCorrelation()){ MapXNode clauseXNode = filter.getFilterClauseXNode(); // key = q:equal, value = map (path + expression) RootXNode expressionNode = ((MapXNode) clauseXNode.getSingleSubEntry("filter value").getValue()) .getEntryAsRoot(new QName(SchemaConstants.NS_C, "expression")); ExpressionType expression = PrismTestUtil.getPrismContext().parserFor(expressionNode).parseRealValue(ExpressionType.class); LOGGER.debug("Expression: {}",SchemaDebugUtil.prettyPrint(expression)); OperationResult result = new OperationResult("testCorrelationRule"); String name = expressionHandler.evaluateExpression(accountType, expression, "test expression", null, result); LOGGER.info(result.debugDump()); assertEquals("Wrong expression result", "hbarbossa", name); } }
public RootXNode getFilterClauseAsRootXNode() throws SchemaException { MapXNode clause = getFilterClauseXNode(); return clause != null ? clause.getSingleSubEntryAsRoot("getFilterClauseAsRootXNode") : null; }
SearchObjectExpressionEvaluatorType evaluatorValue = (SearchObjectExpressionEvaluatorType)evaluator.getValue(); if (evaluatorValue.getFilter() != null) { DebugUtil.debugDumpMapMultiLine(expressionString, evaluatorValue.getFilter().getFilterClauseXNode().asMap(), 0, false, null);
@Test public void testFilterNotInOid() throws Exception { displayTestTitle("testFilterNotInOid"); SearchFilterType filterType = PrismTestUtil.parseAnyValue(FILTER_NOT_IN_OID); ObjectQuery query = toObjectQuery(UserType.class, filterType); displayQuery(query); assertNotNull(query); ObjectFilter filter = query.getFilter(); assertTrue("Filter is not of NOT type", filter instanceof NotFilter); ObjectFilter subFilter = ((NotFilter) filter).getFilter(); assertTrue("Subfilter is not of IN_OID type", subFilter instanceof InOidFilter); QueryType convertedQueryType = toQueryType(query); System.out.println("Re-converted query type"); System.out.println(convertedQueryType.debugDump()); Element filterClauseElement = convertedQueryType.getFilter().getFilterClauseAsElement(getPrismContext()); LOGGER.info(convertedQueryType.getFilter().getFilterClauseXNode().debugDump()); System.out.println("Serialized filter (JAXB->DOM)"); String filterAsString = DOMUtil.serializeDOMToString(filterClauseElement); System.out.println(filterAsString); LOGGER.info(filterAsString); DomAsserts.assertElementQName(filterClauseElement, new QName(PrismConstants.NS_QUERY, "not")); assertEquals("wrong # of inOid subfilters", 1, filterClauseElement.getElementsByTagNameNS(PrismConstants.NS_QUERY, "inOid").getLength()); assertEquals("wrong # of value subfilters", 4, filterClauseElement.getElementsByTagNameNS(PrismConstants.NS_QUERY, "value").getLength()); }
@Test public void testParseSerialize() throws Exception{ displayTestTitle("testParseSerialize"); PrismContext prismContext = getPrismContext(); PrismParser parser = prismContext.parserFor(getFile()); PrismContainerValue<MappingType> mappingPval = parser.parseItemValue(); System.out.println("\nmappingPval:\n"+mappingPval.debugDump(1)); PrismSerializer<RootXNode> serializer = prismContext.xnodeSerializer(); RootXNode xnode = serializer.root(new QName("dummy")).serialize(mappingPval); System.out.println("\nSerialized xnode:\n"+xnode.debugDump(1)); MapXNode xexpression = (MapXNode)((MapXNode)xnode.getSubnode()).get(new QName("expression")); ListXNode xconstList = (ListXNode) xexpression.get(new QName("const")); XNode xconst = xconstList.get(0); if (!(xconst instanceof PrimitiveXNode<?>)) { AssertJUnit.fail("const is not primitive: "+xconst); } }
@Test public void testFilterNotFullText() throws Exception { displayTestTitle("testFilterNotFullText"); SearchFilterType filterType = PrismTestUtil.parseAnyValue(FILTER_NOT_FULL_TEXT); ObjectQuery query = toObjectQuery(UserType.class, filterType); displayQuery(query); assertNotNull(query); ObjectFilter filter = query.getFilter(); assertTrue("Filter is not of NOT type", filter instanceof NotFilter); ObjectFilter subFilter = ((NotFilter) filter).getFilter(); assertTrue("Subfilter is not of FULL_TEXT type", subFilter instanceof FullTextFilter); QueryType convertedQueryType = toQueryType(query); System.out.println("Re-converted query type"); System.out.println(convertedQueryType.debugDump()); Element filterClauseElement = convertedQueryType.getFilter().getFilterClauseAsElement(getPrismContext()); LOGGER.info(convertedQueryType.getFilter().getFilterClauseXNode().debugDump()); System.out.println("Serialized filter (JAXB->DOM)"); String filterAsString = DOMUtil.serializeDOMToString(filterClauseElement); System.out.println(filterAsString); LOGGER.info(filterAsString); DomAsserts.assertElementQName(filterClauseElement, new QName(PrismConstants.NS_QUERY, "not")); assertEquals("wrong # of fullText subfilters", 1, filterClauseElement.getElementsByTagNameNS(PrismConstants.NS_QUERY, "fullText").getLength()); assertEquals("wrong # of value subfilters", 2, filterClauseElement.getElementsByTagNameNS(PrismConstants.NS_QUERY, "value").getLength()); }
/** * Creates a new {@code QueryType} instance by deeply copying a given {@code QueryType} instance. * * * @param o * The instance to copy. * @throws NullPointerException * if {@code o} is {@code null}. */ public SearchFilterType(final SearchFilterType o) { // CC-XJC Version 2.0 Build 2011-09-16T18:27:24+0000 super(); if (o == null) { throw new NullPointerException("Cannot create a copy of 'SearchFilterType' from 'null'."); } this.filterClauseXNode = o.filterClauseXNode.clone(); }
private void assertDummyResource(PrismObject<ResourceType> resource, boolean fromRepo) { PrismContainer<Containerable> configurationPropertiesContainer = assertResource(resource, "Dummy Resource", RESOURCE_DUMMY_NAMESPACE, dummyConnector.getOid(), fromRepo); PrismProperty<ProtectedStringType> guardedProperty = configurationPropertiesContainer.findProperty( new ItemName(CONNECTOR_DUMMY_NAMESPACE, "uselessGuardedString")); // The resource was pulled from the repository. Therefore it does not have the right schema here. We should proceed with caution // and inspect the DOM elements there assertNotNull("No uselessGuardedString property in configuration properties", guardedProperty); PrismPropertyValue<ProtectedStringType> guardedPVal = guardedProperty.getValue(); if (fromRepo) { Object passwordRawElement = guardedPVal.getRawElement(); if (!(passwordRawElement instanceof MapXNode)) { AssertJUnit.fail("Expected password value of type "+ MapXNode.class+" but got "+passwordRawElement.getClass()); } MapXNode passwordXNode = (MapXNode) passwordRawElement; assertTrue("uselessGuardedString was not encrypted (clearValue)", passwordXNode.get(new QName("clearValue")) == null); assertTrue("uselessGuardedString was not encrypted (no encryptedData)", passwordXNode.get(new QName("encryptedData")) != null); } else { ProtectedStringType psType = guardedPVal.getValue(); assertNull("uselessGuardedString was not encrypted (clearValue)", psType.getClearValue()); assertNotNull("uselessGuardedString was not encrypted (no EncryptedData)", psType.getEncryptedDataType()); } }
@Test public void testFilterTypeUserNone() throws Exception { displayTestTitle("testFilterTypeUserNone"); SearchFilterType filterType = PrismTestUtil.parseAnyValue(FILTER_TYPE_USER_NONE); ObjectQuery query = toObjectQuery(UserType.class, filterType); displayQuery(query); assertNotNull(query); ObjectFilter filter = query.getFilter(); assertTrue("Filter is not of TYPE type", filter instanceof TypeFilter); ObjectFilter subFilter = ((TypeFilter) filter).getFilter(); assertTrue("Filter is not of NONE type", subFilter instanceof NoneFilter); QueryType convertedQueryType = toQueryType(query); System.out.println("Re-converted query type"); System.out.println(convertedQueryType.debugDump()); Element filterClauseElement = convertedQueryType.getFilter().getFilterClauseAsElement(getPrismContext()); LOGGER.info(convertedQueryType.getFilter().getFilterClauseXNode().debugDump()); System.out.println("Serialized filter (JAXB->DOM)"); String filterAsString = DOMUtil.serializeDOMToString(filterClauseElement); System.out.println(filterAsString); LOGGER.info(filterAsString); DomAsserts.assertElementQName(filterClauseElement, new QName(PrismConstants.NS_QUERY, "type")); }
/** * Creates and returns a deep copy of this object. * * * @return * A deep copy of this object. */ @Override public SearchFilterType clone() { final SearchFilterType clone; try { clone = this.getClass().newInstance(); // TODO fix this using super.clone() } catch (InstantiationException|IllegalAccessException e) { throw new IllegalStateException("Couldn't instantiate " + this.getClass() + ": " + e.getMessage(), e); } clone.description = this.description; if (this.filterClauseXNode != null) { clone.filterClauseXNode = this.filterClauseXNode.clone(); } return clone; }
RawType val = valueElements.get(0); MapXNode valXNode = (MapXNode) val.serializeToXNode(); PrimitiveXNode clearValueNode = (PrimitiveXNode) valXNode.get(ProtectedStringType.F_CLEAR_VALUE); val.getParsedValue(null, null);
PrismAsserts.assertSize(xFilter, 1); PrismAsserts.assertSubnode(xFilter, AndFilter.ELEMENT_NAME, MapXNode.class); MapXNode xandmap = (MapXNode) xFilter.get(AndFilter.ELEMENT_NAME); PrismAsserts.assertSize(xandmap, 1); PrismAsserts.assertSubnode(xandmap, EqualFilter.ELEMENT_NAME, ListXNode.class); ListXNode xequalsList = (ListXNode) xandmap.get(EqualFilter.ELEMENT_NAME); PrismAsserts.assertSize(xequalsList, 2);
PrismAsserts.assertSize(xFilter, 1); PrismAsserts.assertSubnode(xFilter, AndFilter.ELEMENT_NAME, MapXNodeImpl.class); MapXNodeImpl xandmap = (MapXNodeImpl) xFilter.get(AndFilter.ELEMENT_NAME); PrismAsserts.assertSize(xandmap, 1); PrismAsserts.assertSubnode(xandmap, EqualFilter.ELEMENT_NAME, ListXNodeImpl.class);