private RefFilter createResourceRefFilter(String oid) throws SchemaException { PrismContext prismContext = context.getPrismContext(); List<PrismReferenceValue> values = new ArrayList<>(); if (oid != null) { values.add(prismContext.itemFactory().createReferenceValue(oid, ResourceType.COMPLEX_TYPE)); } SchemaRegistry registry = prismContext.getSchemaRegistry(); PrismReferenceDefinition def = registry.findItemDefinitionByFullPath(ShadowType.class, PrismReferenceDefinition.class, ShadowType.F_RESOURCE_REF); return prismContext.queryFactory().createReferenceEqual(ShadowType.F_RESOURCE_REF, def, values); }
public EvaluatedAssignmentImpl( @NotNull ItemDeltaItem<PrismContainerValue<AssignmentType>, PrismContainerDefinition<AssignmentType>> assignmentIdi, boolean evaluatedOld, PrismContext prismContext) { this.assignmentIdi = assignmentIdi; this.evaluatedOld = evaluatedOld; this.constructionTriple = prismContext.deltaFactory().createDeltaSetTriple(); this.personaConstructionTriple = prismContext.deltaFactory().createDeltaSetTriple(); this.roles = prismContext.deltaFactory().createDeltaSetTriple(); this.prismContext = prismContext; }
public <T extends ObjectType> QueryKey(Class<T> type, ObjectQuery query, PrismContext prismContext) { this.type = type; try { this.query = query != null ? prismContext.getQueryConverter().createQueryType(query) : null; } catch (SchemaException e) { throw new SystemException(e); } }
private Item parseItem(RootXNodeImpl root, QName itemName, ItemDefinition itemDefinition) throws SchemaException{ Item<?,?> item; item = prismContext.parserFor(root) .name(itemName) .definition(itemDefinition) .context(prismContext.createParsingContextForAllowMissingRefTypes()) .parseItem(); if (item.getValues().size() < 1 ) { throw new IllegalStateException("No values to search specified for item " + itemName); } return item; }
@Override protected ObjectQuery createQuery(AbstractScannerResultHandler<ShadowType> handler, TaskRunResult runResult, Task task, OperationResult opResult) throws SchemaException { ObjectQuery query = getPrismContext().queryFactory().createQuery(); ObjectFilter filter = prismContext.queryFor(ShadowType.class) .exists(ShadowType.F_PENDING_OPERATION) .buildFilter(); query.setFilter(filter); return query; }
PrismObjectDefinition<TaskType> getTaskObjectDefinition() { if (taskPrismDefinition == null) { taskPrismDefinition = prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(TaskType.class); } return taskPrismDefinition; }
private PropertyDelta<String> createUselessStringDelta(String newVal) { PropertyDelta<String> uselessStringDelta = prismContext.deltaFactory().property().createModificationReplaceProperty( ItemPath.create(ResourceType.F_CONNECTOR_CONFIGURATION, SchemaConstants.CONNECTOR_SCHEMA_CONFIGURATION_PROPERTIES_ELEMENT_QNAME, DummyResourceContoller.CONNECTOR_DUMMY_USELESS_STRING_QNAME), prismContext.definitionFactory().createPropertyDefinition(DummyResourceContoller.CONNECTOR_DUMMY_USELESS_STRING_QNAME, DOMUtil.XSD_STRING), newVal); return uselessStringDelta; }
public static <T> Collection<PrismPropertyValue<T>> createCollection(PrismContext prismContext, Collection<T> realValueCollection) { Collection<PrismPropertyValue<T>> pvalCol = new ArrayList<>(realValueCollection.size()); for (T realValue: realValueCollection) { pvalCol.add(prismContext.itemFactory().createPropertyValue(realValue)); } return pvalCol; }
public static ObjectQuery createResourceQuery(String resourceOid, PrismContext prismContext) throws SchemaException { Validate.notNull(resourceOid, "Resource where to search must not be null."); Validate.notNull(prismContext, "Prism context must not be null."); return prismContext.queryFactory().createQuery(createResourceFilter(resourceOid, prismContext)); }
public static ObjectQuery createAllShadowsQuery(ResourceType resourceType, PrismContext prismContext) throws SchemaException { return prismContext.queryFor(ShadowType.class) .item(ShadowType.F_RESOURCE_REF).ref(resourceType.getOid()) .build(); }
private PrismObject getCarla(OperationResult opResult) throws Exception { final String CARLA_NAME = "carla"; PrismObjectDefinition userObjectDef = prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(UserType.class); ObjectQuery query = prismContext.queryFor(UserType.class) .item(UserType.F_NAME).eq(CARLA_NAME) .build(); List<PrismObject<UserType>> users = repositoryService.searchObjects(UserType.class, query, null, opResult); AssertJUnit.assertEquals(1, users.size()); return users.get(0); }
private S_ValuesEntry getDeltaItemFragment(PrismContainerValue<AssignmentType> cval) throws SchemaException { PrismContainerDefinition<AssignmentType> definition = cval.getParent() != null ? cval.getParent().getDefinition() : null; if (definition == null) { // we use custom definition, if available; if not, we find the standard one definition = prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(AssignmentHolderType.class) .findItemDefinition(AssignmentHolderType.F_ASSIGNMENT); } definition = definition.clone(); definition.toMutable().setMaxOccurs(1); return prismContext.deltaFor(AssignmentHolderType.class) .item(AssignmentHolderType.F_ASSIGNMENT, definition); }
@PostConstruct private void initialize() { // this call must not be in the constructor, because prismContext is not yet initialized at that moment objectclassPropertyDefinition = prismContext.definitionFactory().createPropertyDefinition(ModelConstants.OBJECTCLASS_PROPERTY_NAME, DOMUtil.XSD_QNAME); taskManager.registerHandler(HANDLER_URI, this); }
public void adopt(PrismContext prismContext) throws SchemaException { for (ObjectDelta<O> thisWave: this.waves) { if (thisWave != null) { prismContext.adopt(thisWave); } } }
List<ItemDelta<?, ?>> createTriggerReplaceDelta(Collection<TriggerType> triggers) throws SchemaException { return prismContext.deltaFor(AccessCertificationCampaignType.class) .item(AccessCertificationCampaignType.F_TRIGGER).replaceRealValues(triggers) .asItemDeltas(); }
@Test public void testMatchEqualMultivalue() throws Exception { PrismObject<UserType> user = PrismTestUtil.parseObject(PrismInternalTestUtil.USER_JACK_FILE_XML); MutablePrismPropertyDefinition<?> def = getPrismContext().definitionFactory().createPropertyDefinition(new QName("indexedString"), DOMUtil.XSD_STRING); ObjectFilter filter = getPrismContext().queryFor(UserType.class) .item(ItemPath.create(UserType.F_EXTENSION, "indexedString"), def).eq("alpha") .buildFilter(); boolean match = ObjectQuery.match(user, filter, matchingRuleRegistry); AssertJUnit.assertTrue("filter does not match object", match); }
@Test public void testParseToXNode() throws Exception { PrismContext prismContext = PrismTestUtil.getPrismContext(); RootXNode node = prismContext.parserFor(getFile()).parseToXNode(); System.out.println("Parsed to XNode:"); System.out.println(node.debugDump()); System.out.println("XML -> XNode -> XML:\n" + prismContext.xmlSerializer().serialize(node)); System.out.println("XML -> XNode -> JSON:\n" + prismContext.jsonSerializer().serialize(node)); System.out.println("XML -> XNode -> YAML:\n" + prismContext.yamlSerializer().serialize(node)); }
protected void transplantGlobalPolicyRulesAdd(File configWithGlobalRulesFile, Task task, OperationResult parentResult) throws SchemaException, IOException, ObjectNotFoundException, ObjectAlreadyExistsException, ExpressionEvaluationException, CommunicationException, ConfigurationException, PolicyViolationException, SecurityViolationException { // copy rules from the file into live system config object PrismObject<SystemConfigurationType> rules = prismContext.parserFor(configWithGlobalRulesFile).parse(); ObjectDelta<SystemConfigurationType> delta = prismContext.deltaFor(SystemConfigurationType.class) .item(SystemConfigurationType.F_GLOBAL_POLICY_RULE).add( rules.asObjectable().getGlobalPolicyRule().stream() .map(r -> r.clone().asPrismContainerValue()) .collect(Collectors.toList())) .asObjectDeltaCast(SystemObjectsType.SYSTEM_CONFIGURATION.value()); modelService.executeChanges(MiscSchemaUtil.createCollection(delta), null, task, parentResult); }
public static ExpressionWrapper parseExpression(Map.Entry<QName, XNodeImpl> expressionEntry, PrismContext prismContext) throws SchemaException { if (expressionEntry == null) { return null; } RootXNodeImpl expressionRoot = new RootXNodeImpl(expressionEntry); PrismPropertyValue expressionPropertyValue = prismContext.parserFor(expressionRoot).parseItemValue(); ExpressionWrapper expressionWrapper = new ExpressionWrapper(expressionEntry.getKey(), expressionPropertyValue.getValue()); return expressionWrapper; }
@Test public void test310ParseXml() throws Exception { System.out.println("===[ test310ParseXml ]==="); PrismObject<UserType> jack = getJack(); String string = getPrismContext().xmlSerializer().serialize(jack); measure("parse XML (" + string.length() + " chars)", () -> getPrismContext().parserFor(string).xml().parse()); measure("parse XML to XNode (" + string.length() + " chars)", () -> getPrismContext().parserFor(string).xml().parseToXNode()); }