public static <O extends ObjectType> boolean hasSubtype(PrismObject<O> object, String subtype) { List<String> objectSubtypes = determineSubTypes(object); if (objectSubtypes == null) { return false; } return objectSubtypes.contains(subtype); }
@NotNull @Deprecated public static <O extends ObjectType> Collection<String> getSubtypeValues(@NotNull PrismObject<O> object) { return FocusTypeUtil.determineSubTypes(object); }
private boolean matchesForRecursion(OrgType thisOrg) { for (String recurseUpOrgType: evaluatorType.getRecurseUpOrgType()) { if (FocusTypeUtil.determineSubTypes(thisOrg).contains(recurseUpOrgType)) { return true; } } return false; }
@NotNull // to eliminate the need for extensive NPE avoidance public static <O extends ObjectType> List<String> determineSubTypes(O object) { return object != null ? determineSubTypes(object.asPrismObject()) : emptyList(); }
public static <O extends ObjectType> ObjectPolicyConfigurationType determineObjectPolicyConfiguration(PrismObject<O> object, SystemConfigurationType systemConfigurationType) throws ConfigurationException { List<String> subTypes = FocusTypeUtil.determineSubTypes(object); return determineObjectPolicyConfiguration(object.getCompileTimeClass(), subTypes, systemConfigurationType); }
@Override public boolean isManagerOfOrgType(UserType user, String orgType, boolean preAuthorized) throws SchemaException { for (ObjectReferenceType objectReferenceType : user.getParentOrgRef()) { if (relationRegistry.isManager(objectReferenceType.getRelation())) { OrgType org = getOrgByOid(objectReferenceType.getOid(), preAuthorized); if (determineSubTypes(org).contains(orgType)) { return true; } } } return false; }
@Experimental public boolean hasActiveAssignmentTargetSubtype(String roleSubtype) { LensContext<ObjectType> lensContext = ModelExpressionThreadLocalHolder.getLensContext(); if (lensContext == null) { throw new UnsupportedOperationException("hasActiveAssignmentRoleSubtype works only with model context"); } DeltaSetTriple<EvaluatedAssignmentImpl<?>> evaluatedAssignmentTriple = lensContext.getEvaluatedAssignmentTriple(); if (evaluatedAssignmentTriple == null) { throw new UnsupportedOperationException("hasActiveAssignmentRoleSubtype works only with evaluatedAssignmentTriple"); } Collection<EvaluatedAssignmentImpl<?>> nonNegativeEvaluatedAssignments = evaluatedAssignmentTriple.getNonNegativeValues(); if (nonNegativeEvaluatedAssignments == null) { return false; } for (EvaluatedAssignmentImpl<?> nonNegativeEvaluatedAssignment : nonNegativeEvaluatedAssignments) { PrismObject<?> target = nonNegativeEvaluatedAssignment.getTarget(); if (target == null) { continue; } Collection<String> targetSubtypes = FocusTypeUtil.determineSubTypes((PrismObject) target); if (targetSubtypes.contains(roleSubtype)) { return true; } } return false; }
private boolean personaMatches(FocusType persona, PersonaKey key) { PrismObject<? extends FocusType> personaObj = persona.asPrismObject(); QName personaType = personaObj.getDefinition().getTypeName(); if (!QNameUtil.match(personaType, key.getType())) { return false; } List<String> objectSubtypes = FocusTypeUtil.determineSubTypes(personaObj); for (String keySubtype: key.getSubtypes()) { if (!objectSubtypes.contains(keySubtype)) { return false; } } return true; }
continue; if (!determineSubTypes(org).contains(orgType)) { continue; } else {
@Override protected ResultHandler<OrgType> getOrgSanityCheckHandler() { return (org, parentResult) -> { OrgType orgBean = org.asObjectable(); List<String> orgType = FocusTypeUtil.determineSubTypes(orgBean); if (orgType.contains("functional")) { assertAssigned(org, ROLE_META_FUNCTIONAL_ORG_OID, RoleType.COMPLEX_TYPE); } else if (orgType.contains("project")) { // Nothing to check (yet) } else if (orgType.contains("fictional")) { // Nothing to check (yet) } else { AssertJUnit.fail("Unexpected orgType in "+org); } return true; }; }
@Override public Collection<OrgType> getParentOrgs(ObjectType object, QName relation, String orgType, boolean preAuthorized) throws SchemaException, SecurityViolationException { List<ObjectReferenceType> parentOrgRefs = object.getParentOrgRef(); List<OrgType> parentOrgs = new ArrayList<>(parentOrgRefs.size()); for (ObjectReferenceType parentOrgRef: parentOrgRefs) { if (!prismContext.relationMatches(relation, parentOrgRef.getRelation())) { continue; } OrgType parentOrg; try { parentOrg = getObject(OrgType.class, parentOrgRef.getOid(), preAuthorized); } catch (ObjectNotFoundException e) { LOGGER.warn("Org "+parentOrgRef.getOid()+" specified in parentOrgRef in "+object+" was not found: "+e.getMessage(), e); // but do not rethrow, just skip this continue; } catch (CommunicationException | ConfigurationException | ExpressionEvaluationException e) { // This should not happen. throw new SystemException(e.getMessage(), e); } if (orgType == null || determineSubTypes(parentOrg).contains(orgType)) { parentOrgs.add(parentOrg); } } return parentOrgs; }
@NotNull public static <F extends ObjectType> List<ObjectPolicyConfigurationType> getApplicablePolicies(LensContext<F> context) { PrismObject<SystemConfigurationType> config = context.getSystemConfiguration(); if (config == null) { return Collections.emptyList(); } PrismObject<F> object = context.getFocusContext() != null ? context.getFocusContext().getObjectAny() : null; List<String> subTypes = FocusTypeUtil.determineSubTypes(object); List<ObjectPolicyConfigurationType> relevantPolicies; try { relevantPolicies = ModelImplUtils.getApplicablePolicies(context.getFocusContext().getObjectTypeClass(), subTypes, config.asObjectable()); } catch (ConfigurationException e) { throw new SystemException("Couldn't get relevant object policies", e); } LOGGER.trace("Relevant policies: {}", relevantPolicies); return relevantPolicies; }
@Override protected void assertUserOrg(PrismObject<UserType> user, String... orgOids) throws Exception { super.assertUserOrg(user, orgOids); List<PolyStringType> userOrganizations = user.asObjectable().getOrganization(); List<PolyStringType> expextedOrgs = new ArrayList<>(); for (String orgOid: orgOids) { PrismObject<OrgType> org = getObject(OrgType.class, orgOid); List<String> orgType = FocusTypeUtil.determineSubTypes(org); if (orgType.contains("functional")) { PolyStringType orgName = org.asObjectable().getName(); assertTrue("Value "+orgName+" not found in user organization property: "+userOrganizations, userOrganizations.contains(orgName)); if (!expextedOrgs.contains(orgName)) { expextedOrgs.add(orgName); } } } assertEquals("Wrong number of user organization property values: "+userOrganizations, expextedOrgs.size(), userOrganizations.size()); }
private ObjectPolicyConfigurationType determineObjectPolicyConfiguration(PrismObject<UserType> user, PrismObject<SystemConfigurationType> systemConfiguration) throws SchemaException { ObjectPolicyConfigurationType policyConfigurationType; try { policyConfigurationType = ModelUtils.determineObjectPolicyConfiguration(user, systemConfiguration.asObjectable()); } catch (ConfigurationException e) { throw new SchemaException(e.getMessage(), e); } if (LOGGER.isTraceEnabled()) { LOGGER.trace("Selected policy configuration from subtypes {}:\n{}", FocusTypeUtil.determineSubTypes(user), policyConfigurationType==null?null:policyConfigurationType.asPrismContainerValue().debugDump(1)); } return policyConfigurationType; }
private void updateObjectPolicy() throws ConfigurationException { PrismObject<SystemConfigurationType> systemConfiguration = getLensContext().getSystemConfiguration(); if (systemConfiguration == null) { return; } PrismObject<O> object = getObjectAny(); ObjectPolicyConfigurationType policyConfigurationType = ModelUtils.determineObjectPolicyConfiguration(object, systemConfiguration.asObjectable()); if (policyConfigurationType != getObjectPolicyConfigurationType()) { if (LOGGER.isTraceEnabled()) { LOGGER.trace("Changed policy configuration because of changed subtypes {}:\n{}", FocusTypeUtil.determineSubTypes(object), policyConfigurationType==null?null:policyConfigurationType.asPrismContainerValue().debugDump(1)); } setObjectPolicyConfigurationType(policyConfigurationType); } }
Collection<String> actualSubtypeValues = FocusTypeUtil.determineSubTypes(object); if (!actualSubtypeValues.contains(specSubtype)) { logger.trace("{} subtype mismatch, expected {}, was {}", logMessagePrefix, specSubtype, actualSubtypeValues);
if (LOGGER.isTraceEnabled()) { LOGGER.trace("Selected policy configuration from subtypes {}:\n{}", FocusTypeUtil.determineSubTypes(object), policyConfigurationType==null?null:policyConfigurationType.asPrismContainerValue().debugDump(1));