/** * Should skip interrupt for registered service. * * @param registeredService the registered service * @return the boolean */ protected boolean shouldSkipInterruptForRegisteredService(final RegisteredService registeredService) { if (registeredService != null) { LOGGER.debug("Checking interrupt rules for service [{}]", registeredService.getName()); if (RegisteredServiceProperties.SKIP_INTERRUPT_NOTIFICATIONS.isAssignedTo(registeredService)) { LOGGER.debug("Service [{}] is set to skip interrupt notifications", registeredService.getName()); return true; } LOGGER.debug("Service [{}] is set to not skip interrupt notifications", registeredService.getName()); } else { LOGGER.debug("No service was found in the request context. Proceeding as usual..."); } return false; }
/** * Gets property value. * * @param service the service * @return the property value */ public RegisteredServiceProperty getPropertyValue(final RegisteredService service) { if (isAssignedTo(service)) { val property = service.getProperties().entrySet() .stream().filter(entry -> entry.getKey().equalsIgnoreCase(getPropertyName()) && StringUtils.isNotBlank(entry.getValue().getValue())) .distinct().findFirst(); if (property.isPresent()) { return property.get().getValue(); } } return null; }
RegisteredServiceProperty.RegisteredServiceProperties.TOKEN_SECRET_SIGNING.getPropertyName()); return null;
/** * Get the relying party id for a service. * * @param service the service to get an id for * @param configuration the configuration * @return relying party id */ public String getRelyingPartyIdentifier(final Service service, final WsFederationConfiguration configuration) { val relyingPartyIdentifier = configuration.getRelyingPartyIdentifier(); if (service != null) { val registeredService = this.servicesManager.findServiceBy(service); RegisteredServiceAccessStrategyUtils.ensureServiceAccessIsAllowed(service, registeredService); if (RegisteredServiceProperty.RegisteredServiceProperties.WSFED_RELYING_PARTY_ID.isAssignedTo(registeredService)) { LOGGER.debug("Determined relying party identifier from service [{}] to be [{}]", service, relyingPartyIdentifier); return RegisteredServiceProperty.RegisteredServiceProperties.WSFED_RELYING_PARTY_ID.getPropertyValue(registeredService).getValue(); } } LOGGER.debug("Determined relying party identifier to be [{}]", relyingPartyIdentifier); return relyingPartyIdentifier; } }
/** * Gets property value. * * @param <T> the type parameter * @param service the service * @param clazz the clazz * @return the property value */ public <T> T getPropertyValue(final RegisteredService service, final Class<T> clazz) { if (isAssignedTo(service)) { val prop = getPropertyValue(service); if (prop != null) { return clazz.cast(prop.getValue()); } } return null; }
/** * Is assigned to value. * * @param service the service * @param valueFilter the filter * @return true/false */ public boolean isAssignedTo(final RegisteredService service, final Predicate<String> valueFilter) { return service.getProperties().entrySet() .stream() .anyMatch(entry -> entry.getKey().equalsIgnoreCase(getPropertyName()) && StringUtils.isNotBlank(entry.getValue().getValue()) && valueFilter.test(entry.getValue().getValue())); } }
/** * Gets registered service jwt secret. * * @param service the service * @param propName the prop name * @return the registered service jwt secret */ protected String getRegisteredServiceJwtProperty(final RegisteredService service, final RegisteredServiceProperty.RegisteredServiceProperties propName) { if (service == null || !service.getAccessStrategy().isServiceAccessAllowed()) { LOGGER.debug("Service is not defined/found or its access is disabled in the registry"); throw new UnauthorizedServiceException(UnauthorizedServiceException.CODE_UNAUTHZ_SERVICE); } if (propName.isAssignedTo(service)) { return propName.getPropertyValue(service).getValue(); } LOGGER.warn("Service [{}] does not define a property [{}] in the registry", service.getServiceId(), propName); return null; }
/** * Gets encryption key. * * @param registeredService the registered service * @return the encryption key */ public Optional<String> getEncryptionKey(final RegisteredService registeredService) { if (RegisteredServiceProperties.TOKEN_AS_SERVICE_TICKET_ENCRYPTION_KEY.isAssignedTo(registeredService)) { val key = RegisteredServiceProperties.TOKEN_AS_SERVICE_TICKET_ENCRYPTION_KEY.getPropertyValue(registeredService).getValue(); return Optional.of(key); } return Optional.empty(); } }
/** * Gets signing key. * * @param registeredService the registered service * @return the signing key */ public Optional<String> getSigningKey(final RegisteredService registeredService) { if (RegisteredServiceProperties.TOKEN_AS_SERVICE_TICKET_SIGNING_KEY.isAssignedTo(registeredService)) { val signingKey = RegisteredServiceProperties.TOKEN_AS_SERVICE_TICKET_SIGNING_KEY.getPropertyValue(registeredService).getValue(); return Optional.of(signingKey); } return Optional.empty(); }
/** * Check to see if the property is assigned to this service and is defined with a value. * * @param service registered service * @return true/false */ public boolean isAssignedTo(final RegisteredService service) { return isAssignedTo(service, Predicates.alwaysTrue()); }
private boolean shouldHttpHeaderBeInjectedIntoResponse(final HttpServletRequest request, final RegisteredServiceProperties property) { val result = getRegisteredServiceFromRequest(request); return result.filter(registeredService -> property.isAssignedTo(registeredService, BooleanUtils::toBoolean)).isPresent(); }
private String getStringProperty(final HttpServletRequest request, final RegisteredServiceProperties property) { val result = getRegisteredServiceFromRequest(request); if (result.isPresent()) { val properties = result.get().getProperties(); if (properties.containsKey(property.getPropertyName())) { val prop = properties.get(property.getPropertyName()); return prop.getValue(); } } return null; }