public void computeEffective(String lifecycleStatus, ActivationType activationType, LifecycleStateModelType stateModel) { computeEffective(lifecycleStatus, activationType, clock.currentTimeXMLGregorianCalendar(), stateModel); }
@Override public ActivationStatusType getAssignmentEffectiveStatus(String lifecycleStatus, ActivationType activationType) { return activationComputer.getEffectiveStatus(lifecycleStatus, activationType, null); }
private static boolean isValid(String lifecycleState, ActivationType activationType, XMLGregorianCalendar now, ActivationComputer activationComputer, LifecycleStateModelType focusStateModel) { TimeIntervalStatusType validityStatus = activationComputer.getValidityStatus(activationType, now); ActivationStatusType effectiveStatus = activationComputer.getEffectiveStatus(lifecycleState, activationType, validityStatus, focusStateModel); return effectiveStatus == ActivationStatusType.ENABLED; }
public void computeEffective(String lifecycleStatus, ActivationType activationType, XMLGregorianCalendar referenceTime, LifecycleStateModelType stateModel) { ActivationStatusType effectiveStatus = getForcedLifecycleActivationStatus(lifecycleStatus, stateModel); ActivationStatusType administrativeStatus = activationType.getAdministrativeStatus(); if (effectiveStatus == null && administrativeStatus != null) { // Explicit administrative status overrides everything effectiveStatus = administrativeStatus; } TimeIntervalStatusType validityStatus = getValidityStatus(activationType); if (effectiveStatus == null) { if (validityStatus == null) { // No administrative status, no validity. Defaults to enabled. effectiveStatus = ActivationStatusType.ENABLED; } else { switch (validityStatus) { case AFTER: case BEFORE: effectiveStatus = ActivationStatusType.DISABLED; break; case IN: effectiveStatus = ActivationStatusType.ENABLED; break; } } } activationType.setEffectiveStatus(effectiveStatus); activationType.setValidityStatus(validityStatus); }
public TimeIntervalStatusType getValidityStatus(ActivationType activationType) { return getValidityStatus(activationType, clock.currentTimeXMLGregorianCalendar()); }
private boolean defaultLifecycleHasActiveAssignments(String lifecycleStatus, LifecycleStateModelType stateModel) { ActivationStatusType forcedLifecycleActivationStatus = getForcedLifecycleActivationStatus(lifecycleStatus, stateModel); if (forcedLifecycleActivationStatus == null) { return true; } switch (forcedLifecycleActivationStatus) { case ENABLED: return true; case DISABLED: return false; case ARCHIVED: return false; default: throw new IllegalStateException("Unknown forced activation "+forcedLifecycleActivationStatus); } }
public boolean lifecycleHasActiveAssignments(String lifecycleStatus, LifecycleStateModelType stateModel) { LifecycleStateType stateDefinition = LifecycleUtil.findStateDefinition(stateModel, lifecycleStatus); if (stateDefinition == null) { return defaultLifecycleHasActiveAssignments(lifecycleStatus, stateModel); } Boolean activeAssignments = stateDefinition.isActiveAssignments(); if (activeAssignments == null) { return defaultLifecycleHasActiveAssignments(lifecycleStatus, stateModel); } return activeAssignments; }
protected ActivationComputer createActivationComputer(Clock clock) { ActivationComputer activationComputer = new ActivationComputer(clock); return activationComputer; }
public ActivationStatusType getForcedLifecycleActivationStatus(String lifecycleStatus, LifecycleStateModelType stateModel) { LifecycleStateType stateDefinition = LifecycleUtil.findStateDefinition(stateModel, lifecycleStatus); if (stateDefinition == null) { return getHardcodedForcedLifecycleActivationStatus(lifecycleStatus); } return stateDefinition.getForcedActivationStatus(); }
public ActivationStatusType getEffectiveStatus(String lifecycleStatus, ActivationType activationType, TimeIntervalStatusType validityStatus, LifecycleStateModelType stateModel) { ActivationStatusType forcedLifecycleActivationStatus = getForcedLifecycleActivationStatus(lifecycleStatus, stateModel); if (forcedLifecycleActivationStatus != null) { return forcedLifecycleActivationStatus; } if (activationType == null) { return ActivationStatusType.ENABLED; } ActivationStatusType administrativeStatus = activationType.getAdministrativeStatus(); if (administrativeStatus != null) { // Explicit administrative status overrides everything return administrativeStatus; } if (validityStatus == null) { // No administrative status, no validity. Return default. return ActivationStatusType.ENABLED; } switch (validityStatus) { case AFTER: case BEFORE: return ActivationStatusType.DISABLED; case IN: return ActivationStatusType.ENABLED; } // This should not happen return null; }
@Test public void testGetLimboAdministrativeEnabled() throws Exception { System.out.println("\n===[ testGetLimboAdministrativeEnabled ]===\n"); // GIVEN Clock clock = createClock(YEAR_START); ActivationComputer activationComputer = createActivationComputer(clock); ActivationType activationType = createActivationType(ActivationStatusType.ENABLED, SPRING_EQUINOX, AUTUMN_EQUINOX); // WHEN ActivationStatusType effectiveStatus = activationComputer.getEffectiveStatus(LIFECYCLE_STATE_LIMBO, activationType, null); // THEN assertEquals("Unexpected effective status", ActivationStatusType.DISABLED, effectiveStatus); }
public ActivationStatusType getEffectiveStatus(String lifecycleStatus, ActivationType activationType, LifecycleStateModelType stateModel) { return getEffectiveStatus(lifecycleStatus, activationType, getValidityStatus(activationType), stateModel); }
public void recompute(PrismObject<UserType> user, LifecycleStateModelType lifecycleModel) { UserType userType = user.asObjectable(); ActivationType activationType = userType.getActivation(); if (activationType != null) { activationComputer.computeEffective(userType.getLifecycleState(), activationType, lifecycleModel); } }
@Test public void testGetActiveAdministrativeDisabled() throws Exception { System.out.println("\n===[ testGetActiveAdministrativeDisabled ]===\n"); // GIVEN Clock clock = createClock(YEAR_START); ActivationComputer activationComputer = createActivationComputer(clock); ActivationType activationType = createActivationType(ActivationStatusType.DISABLED, SPRING_EQUINOX, AUTUMN_EQUINOX); // WHEN ActivationStatusType effectiveStatus = activationComputer.getEffectiveStatus(SchemaConstants.LIFECYCLE_ACTIVE, activationType, createLifecycleModel()); // THEN assertEquals("Unexpected effective status", ActivationStatusType.DISABLED, effectiveStatus); }
activationNew = focusTypeNew.getActivation(); if (activationNew != null) { validityStatusNew = activationComputer.getValidityStatus(activationNew, now); validityChangeTimestamp = activationNew.getValidityChangeTimestamp(); activationCurrent = focusCurrentType.getActivation(); if (activationCurrent != null) { validityStatusCurrent = activationComputer.getValidityStatus(activationCurrent, validityChangeTimestamp); ActivationStatusType effectiveStatusNew = activationComputer.getEffectiveStatus(lifecycleStateNew, activationNew, validityStatusNew, lifecycleModel); ActivationStatusType effectiveStatusCurrent = activationComputer.getEffectiveStatus(lifecycleStateCurrent, activationCurrent, validityStatusCurrent, lifecycleModel);
private void initializePrincipalFromAssignments(MidPointPrincipal principal, PrismObject<SystemConfigurationType> systemConfiguration) { OperationResult result = new OperationResult(MidPointPrincipalManagerMock.class.getName() + ".addAuthorizations"); principal.setApplicableSecurityPolicy(locateSecurityPolicy(principal, systemConfiguration, result)); // if (systemConfiguration != null) { // principal.setAdminGuiConfiguration(systemConfiguration.asObjectable().getAdminGuiConfiguration()); // } AuthorizationType authorizationType = new AuthorizationType(); authorizationType.getAction().add("FAKE"); principal.getAuthorities().add(new Authorization(authorizationType)); ActivationType activation = principal.getUser().getActivation(); if (activation != null) { activationComputer.computeEffective(principal.getUser().getLifecycleState(), activation, null); } }
@Test public void testGetDeprecatedAdministrativeEnabled() throws Exception { System.out.println("\n===[ testGetDeprecatedAdministrativeEnabled ]===\n"); // GIVEN Clock clock = createClock(SUMMER_SOLSTICE); ActivationComputer activationComputer = createActivationComputer(clock); ActivationType activationType = createActivationType(ActivationStatusType.ENABLED, SPRING_EQUINOX, AUTUMN_EQUINOX); // WHEN ActivationStatusType effectiveStatus = activationComputer.getEffectiveStatus(SchemaConstants.LIFECYCLE_DEPRECATED, activationType, createLifecycleModel()); // THEN assertEquals("Unexpected effective status", ActivationStatusType.ENABLED, effectiveStatus); }
protected void testCompute(final String TEST_NAME, String lifecycleState, XMLGregorianCalendar now, ActivationStatusType administrativeStatus, XMLGregorianCalendar validFrom, XMLGregorianCalendar validTo, ActivationStatusType expectedEffective, TimeIntervalStatusType expectedValidity) throws SchemaException, IOException { // GIVEN Clock clock = createClock(now); ActivationComputer activationComputer = createActivationComputer(clock); ActivationType activationType = createActivationType(administrativeStatus, validFrom, validTo); // WHEN activationComputer.computeEffective(lifecycleState, activationType, createLifecycleModel()); // THEN assertEquals("Unexpected effective status", expectedEffective, activationType.getEffectiveStatus()); assertEquals("Unexpected validity status", expectedValidity, activationType.getValidityStatus()); }
@Test public void testGetActiveAdministrativeArchived() throws Exception { System.out.println("\n===[ testGetAdministrativeArchived ]===\n"); // GIVEN Clock clock = createClock(SUMMER_SOLSTICE); ActivationComputer activationComputer = createActivationComputer(clock); ActivationType activationType = createActivationType(ActivationStatusType.ARCHIVED, SPRING_EQUINOX, AUTUMN_EQUINOX); // WHEN ActivationStatusType effectiveStatus = activationComputer.getEffectiveStatus(SchemaConstants.LIFECYCLE_ACTIVE, activationType, createLifecycleModel()); // THEN assertEquals("Unexpected effective status", ActivationStatusType.ARCHIVED, effectiveStatus); }
@Test public void testGetDeprecatedAdministrativeDisabled() throws Exception { System.out.println("\n===[ testGetDeprecatedAdministrativeDisabled ]===\n"); // GIVEN Clock clock = createClock(SUMMER_SOLSTICE); ActivationComputer activationComputer = createActivationComputer(clock); ActivationType activationType = createActivationType(ActivationStatusType.DISABLED, SPRING_EQUINOX, AUTUMN_EQUINOX); // WHEN ActivationStatusType effectiveStatus = activationComputer.getEffectiveStatus(SchemaConstants.LIFECYCLE_DEPRECATED, activationType, createLifecycleModel()); // THEN assertEquals("Unexpected effective status", ActivationStatusType.DISABLED, effectiveStatus); }