@Override public void assertObjects(String message, List<PrismObject<O>> objects) throws Exception { if (!MiscUtil.unorderedCollectionEquals(objects, Arrays.asList(expectedOids), (object,expectedOid) -> expectedOid.equals(object.getOid()))) { failAllow(message, type, (query==null?"null":query.toString())+", expected "+Arrays.toString(expectedOids)+", actual "+objects, null); } }
public void deleteConflictedShadowFromRepo(PrismObject<ShadowType> shadow, OperationResult parentResult){ try{ repositoryService.deleteObject(shadow.getCompileTimeClass(), shadow.getOid(), parentResult); } catch (Exception ex){ throw new SystemException(ex.getMessage(), ex); } }
protected <F extends FocusType> ObjectDelta<F> createAssignmentFocusEmptyDeleteDelta(PrismObject<F> existingFocus, String roleOid, QName relation) throws SchemaException { Collection<ItemDelta<?,?>> modifications = new ArrayList<>(); modifications.add((createAssignmentEmptyDeleteModification(existingFocus, roleOid, relation))); return prismContext.deltaFactory().object() .createModifyDelta(existingFocus.getOid(), modifications, existingFocus.getCompileTimeClass() ); }
private <T extends ObjectType> void cacheObject(Cache cache, PrismObject<T> object, boolean readOnly) { if (cache != null) { PrismObject<ObjectType> objectToCache; if (readOnly) { object.setImmutable(true); objectToCache = (PrismObject<ObjectType>) object; } else { objectToCache = (PrismObject<ObjectType>) object.clone(); } cache.putObject(object.getOid(), objectToCache); } }
private static String formatObject(PrismObject<? extends ObjectType> object) { if (object == null) { return "null"; } return object.asObjectable().toDebugType()+":"+object.getOid()+"("+object.getElementName()+")"; }
@Override public void initSystem(Task initTask, OperationResult initResult) throws Exception { super.initSystem(initTask, initResult); roleRole50aOid = repoAddObjectFromFile(ROLE_ROLE50A_FILE, initResult).getOid(); roleRole51aOid = repoAddObjectFromFile(ROLE_ROLE51A_FILE, initResult).getOid(); roleRole52aOid = repoAddObjectFromFile(ROLE_ROLE52A_FILE, initResult).getOid(); roleRole53aOid = repoAddObjectFromFile(ROLE_ROLE53A_FILE, initResult).getOid(); DebugUtil.setPrettyPrintBeansAs(PrismContext.LANG_YAML); }
protected void assertEvaluatedRole(Collection<? extends EvaluatedAssignmentTarget> evaluatedRoles, String expectedRoleOid) { for (EvaluatedAssignmentTarget evalRole: evaluatedRoles) { if (expectedRoleOid.equals(evalRole.getTarget().getOid())) { return; } } AssertJUnit.fail("Role "+expectedRoleOid+" no present in evaluated roles "+evaluatedRoles); }
/** * Creates unassign delta by removing each assignment individually by id. */ protected <F extends FocusType> ObjectDelta<F> createUnassignAllDelta(PrismObject<F> focusBefore) throws SchemaException { Collection<ItemDelta<?,?>> modifications = new ArrayList<>(); for (AssignmentType assignmentType: focusBefore.asObjectable().getAssignment()) { modifications.add((createAssignmentModification(assignmentType.getId(), false))); } return prismContext.deltaFactory().object() .createModifyDelta(focusBefore.getOid(), modifications, focusBefore.getCompileTimeClass() ); }
public PrismObject<ResourceType> getResource(PrismObject<ResourceType> repositoryObject, GetOperationOptions options, Task task, OperationResult parentResult) throws ObjectNotFoundException, SchemaException, CommunicationException, ConfigurationException, ExpressionEvaluationException{ InternalMonitor.getResourceCacheStats().recordRequest(); PrismObject<ResourceType> cachedResource = resourceCache.get(repositoryObject, options); if (cachedResource != null) { InternalMonitor.getResourceCacheStats().recordHit(); return cachedResource; } LOGGER.debug("Storing fetched resource {}, version {} to cache (previously cached version {})", repositoryObject.getOid(), repositoryObject.getVersion(), resourceCache.getVersion(repositoryObject.getOid())); return loadAndCacheResource(repositoryObject, options, task, parentResult); }
protected <O extends ObjectType> void assertCreateMetadata(PrismObject<O> object, XMLGregorianCalendar start, XMLGregorianCalendar end) { MetadataType metadataType = object.asObjectable().getMetadata(); PrismObject<UserType> defaultActor = getDefaultActor(); assertMetadata(object.toString(), metadataType, true, true, start, end, defaultActor==null?null:defaultActor.getOid(), DEFAULT_CHANNEL); }
public <F extends FocusType> void personaDelete(LensContext<F> context, PersonaKey key, FocusType existingPersona, Task task, OperationResult result) throws ObjectAlreadyExistsException, ObjectNotFoundException, SchemaException, ExpressionEvaluationException, CommunicationException, ConfigurationException, PolicyViolationException, SecurityViolationException, PreconditionViolationException { PrismObject<F> focus = context.getFocusContext().getObjectOld(); LOGGER.debug("Deleting persona {} for {}: {}", key, focus, existingPersona); ObjectDelta<? extends FocusType> targetDelta = existingPersona.asPrismObject().createDeleteDelta(); executePersonaDelta(targetDelta, focus.getOid(), task, result); unlink(context, existingPersona, result); }
@Override public ObjectQuery getOwnerQuery() { return getObject().getPrismContext() .queryFor(UserType.class) .item(UserType.F_LINK_REF).ref(getObject().getOid()) .build(); } }
protected void forEvaluatedTargetPolicyRule(LensContext<? extends FocusType> context, String targetOid, Consumer<EvaluatedPolicyRule> handler) { DeltaSetTriple<EvaluatedAssignmentImpl<? extends FocusType>> evaluatedAssignmentTriple = (DeltaSetTriple)context.getEvaluatedAssignmentTriple(); evaluatedAssignmentTriple.simpleAccept(assignment -> { if (targetOid == null || assignment.getTarget() != null && targetOid.equals(assignment.getTarget().getOid())) { assignment.getAllTargetsPolicyRules().forEach(handler::accept); } }); }
private ObjectType convert(Class clazz, PrismObject<? extends ObjectType> o, OperationResultType result) { ObjectType objType = null; try { objType = (ObjectType) prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(clazz).instantiate().asObjectable(); objType.setOid(o.getOid()); objType.setName(o.asObjectable().getName()); return objType; } catch (SchemaException e) { // TODO Auto-generated catch block return objType; } }
public void update(ItemDelta<?, ?> itemDelta) throws SchemaException { if (delta == null) { delta = getAnyObject().getPrismContext().deltaFactory().object() .createModifyDelta(getAnyObject().getOid(), itemDelta, getAnyObject().getCompileTimeClass() ); } else { delta.swallow(itemDelta); itemDelta.applyTo(newObject); } }
@Override protected ObjectQuery createQuery(PropagationResultHandler handler, TaskRunResult runResult, Task coordinatorTask, OperationResult opResult) { ObjectQuery query = prismContext.queryFactory().createQuery(); ObjectFilter filter = prismContext.queryFor(ShadowType.class) .item(ShadowType.F_RESOURCE_REF).ref(handler.getResource().getOid()) .and() .exists(ShadowType.F_PENDING_OPERATION) .buildFilter(); query.setFilter(filter); return query; }
protected ObjectQuery createShadowQueryByAttribute(ObjectClassComplexTypeDefinition rAccount, String attributeName, String attributeValue, PrismObject<ResourceType> resource) throws SchemaException { ResourceAttributeDefinition<Object> attrDef = rAccount.findAttributeDefinition(attributeName); return prismContext.queryFor(ShadowType.class) .itemWithDef(attrDef, ShadowType.F_ATTRIBUTES, attrDef.getName()).eq(attributeValue) .and().item(ShadowType.F_OBJECT_CLASS).eq(rAccount.getTypeName()) .and().item(ShadowType.F_RESOURCE_REF).ref(resource.getOid()) .build(); }
@Test public void testReplaceModelOperationContext() throws Exception { PrismObject prismObject = PrismTestUtil.parseObject(new File(TEST_DIR, "task-modelOperationContext-before.xml")); ObjectDelta delta = getPrismContext().deltaFactory().object().createEmptyModifyDelta(TaskType.class, prismObject.getOid() ); delta.addModificationReplaceContainer(TaskType.F_MODEL_OPERATION_CONTEXT); PrismObject changed = prismObject.clone(); ItemDeltaCollectionsUtil.applyTo(delta.getModifications(), changed); Collection<? extends ItemDelta> processedModifications = prismObject.diffModifications(changed, EquivalenceStrategy.LITERAL_IGNORE_METADATA); ItemDeltaCollectionsUtil.applyTo(processedModifications, prismObject); assertNull(prismObject.findContainer(TaskType.F_MODEL_OPERATION_CONTEXT)); }
protected void waitForCampaignTasks(String campaignOid, int timeout, OperationResult result) throws CommonException { ObjectQuery query = prismContext.queryFor(TaskType.class) .item(TaskType.F_OBJECT_REF).ref(campaignOid) .build(); SearchResultList<PrismObject<TaskType>> campaignTasks = repositoryService.searchObjects(TaskType.class, query, null, result); for (PrismObject<TaskType> campaignTask : campaignTasks) { if (campaignTask.asObjectable().getExecutionStatus() != TaskExecutionStatusType.CLOSED && campaignTask.asObjectable().getExecutionStatus() != TaskExecutionStatusType.SUSPENDED) { waitForTaskFinish(campaignTask.getOid(), false, timeout); } } }