@Bean public Credentials credentials(final CredentialProviderLocator connectionProviderLocator) { return new Credentials(connectionProviderLocator); } }
@GET @Produces(MediaType.APPLICATION_JSON) public AcquisitionMethod get() { return credentials.acquisitionMethodFor(connectorId); }
protected Stream<CredentialFlowState> tryToFinishAcquisition(final HttpServletRequest request, final CredentialFlowState flowState) { try { return Stream.of(credentials.finishAcquisition(flowState, Urls.apiBase(request))); } catch (@SuppressWarnings("PMD.AvoidCatchingGenericException") final RuntimeException e) { LOG.debug("Unable to perform OAuth callback on flow state: {}", flowState, e); return Stream.empty(); } }
public AcquisitionMethod acquisitionMethodFor(final String providerId) { try { return providerFor(providerId).acquisitionMethod(); } catch (final IllegalArgumentException ignored) { return AcquisitionMethod.NONE; } }
public CredentialFlowState finishAcquisition(final CredentialFlowState flowState, final URI baseUrl) { final CredentialProvider credentialProvider = providerFrom(flowState); return credentialProvider.finish(flowState, baseUrl); }
@POST @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) public Response create(@NotNull @Valid final AcquisitionRequest request, @Context final HttpServletRequest httpRequest) { final AcquisitionFlow acquisitionFlow = credentials.acquire(connectorId, apiBase(httpRequest), absoluteTo(httpRequest, request.getReturnUrl())); final CredentialFlowState flowState = acquisitionFlow.state().get(); final NewCookie cookie = state.persist(flowState.persistenceKey(), "/", flowState); final AcquisitionResponse acquisitionResponse = AcquisitionResponse.Builder.from(acquisitionFlow) .state(State.Builder.cookie(cookie.toString())).build(); return Response.accepted().entity(acquisitionResponse).build(); }
@Override public Connection create(@Context SecurityContext sec, @ConvertGroup(from = Default.class, to = AllValidations.class) final Connection connection) { final Date rightNow = new Date(); // Lets make sure we store encrypt secrets. Map<String, String> configuredProperties =connection.getConfiguredProperties(); if( connection.getConnectorId().isPresent() ) { Map<String, ConfigurationProperty> connectorProperties = getConnectorProperties(connection.getConnectorId().get()); configuredProperties = encryptionComponent.encryptPropertyValues(configuredProperties, connectorProperties); } final Connection updatedConnection = new Connection.Builder() .createFrom(connection) .createdDate(rightNow) .lastUpdated(rightNow) .configuredProperties(configuredProperties) .userId(sec.getUserPrincipal().getName()) .build(); final Set<CredentialFlowState> flowStates = CredentialFlowState.Builder.restoreFrom(state::restoreFrom, request); final Connection connectionToCreate = flowStates.stream().map(s -> { final Cookie removal = new Cookie(s.persistenceKey(), ""); removal.setPath("/"); removal.setMaxAge(0); response.addCookie(removal); return credentials.apply(updatedConnection, s); }).findFirst().orElse(updatedConnection); return Creator.super.create(sec, connectionToCreate); }
/* default */ CredentialProvider providerFrom(final CredentialFlowState flowState) { final String connectorId = flowState.getConnectorId(); return providerFor(connectorId); }
public Connection apply(final Connection updatedConnection, final CredentialFlowState flowState) { final CredentialProvider credentialProvider = providerFrom(flowState); final Connection withDerivedFlag = new Connection.Builder().createFrom(updatedConnection).isDerived(true).build(); return credentialProvider.applyTo(withDerivedFlag, flowState); }
public AcquisitionFlow acquire(final String providerId, final URI baseUrl, final URI returnUrl) { final CredentialProvider credentialProvider = providerFor(providerId); final CredentialFlowState flowState = credentialProvider.prepare(providerId, baseUrl, returnUrl); return new AcquisitionFlow.Builder().type(flowState.type()).redirectUrl(flowState.getRedirectUrl()).state(flowState).build(); }