Re: Untitled

From Sweltering Eider, 5 Years ago, written in Java 5.

This paste is a reply to Untitled from Reliable Curlew - view diff

URL http://geopaste.scratchbook.ch/view/c9f7cbae

Embed

/*

* Copyright 2019, Pearson Education, Learning Technology Group

*

* PlatformAuthenticationResponseService.java

*/

package com.pearson.ltg.rbs.ltitoolgateway.service.openidconnect;

import java.util.List;

import java.util.Objects;

import java.util.Set;

import java.util.stream.Collectors;

import javax.annotation.PostConstruct;

import org.apache.commons.collections.CollectionUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.stereotype.Service;

import com.pearson.ltg.rbs.ltitoolgateway.constant.Constants;

import com.pearson.ltg.rbs.ltitoolgateway.exception.InvalidDataException;

import com.pearson.ltg.rbs.ltitoolgateway.jwt.JwtHelper;

import com.pearson.ltg.rbs.ltitoolgateway.model.AuthenticationResponse;

import com.pearson.ltg.rbs.ltitoolgateway.model.IssuerResponse;

import com.pearson.ltg.rbs.ltitoolgateway.model.LTILaunchRequest;

import com.pearson.ltg.rbs.ltitoolgateway.model.LTILaunchRequestSettings;

import com.pearson.ltg.rbs.ltitoolgateway.model.PlatformConfiguration;

import com.pearson.ltg.rbs.ltitoolgateway.model.PublicKeyData;

import com.pearson.ltg.rbs.ltitoolgateway.model.RumbaRole;

import com.pearson.ltg.rbs.ltitoolgateway.service.IPlatformConfigurationService;

import com.pearson.ltg.rbs.ltitoolgateway.util.Encryption;

import com.pearson.ltg.samlutils.model.SamlResponseInputData;

import com.pearson.ltg.samlutils.service.ISamlResponseService;

import io.jsonwebtoken.Claims;

import reactor.core.publisher.Mono;

import reactor.util.function.Tuples;

@Service

public class PlatformAuthenticationResponseService implements IPlatformAuthenticationResponseService {

private static final Logger LOGGER = LoggerFactory.getLogger(PlatformAuthenticationResponseService.class);

@Value("${saml.issuerId}")

String issuerId;

@Value("${saml.rumbaSSOUrl}")

String rumbaSSOUrl;

@Value("${saml.externalIdp}")

String externalIdp;

@Value("${saml.nameIdentitifer}")

String nameIdentitifer;

@Value("${saml.nameQualifier}")

String nameQualifier;

@Value("${saml.certificatePath}")

String certificatePath;

@Value("${saml.privateKeyPkcs8Path}")

String privateKeyPkcs8Path;

@Autowired

JwtHelper jwtHelper;

@Autowired

Encryption encryption;

@Autowired

IAuthenticationService authenticationService;

@Autowired

IPlatformConfigurationService platformConfigurationService;

@Autowired

ILaunchRequestServiceLocator launchRequestServiceLocator;

@Autowired

ISamlResponseService samlResponseService;

@Value("${ims.roles.mapped.to.rumba.teacher}")

Set<String> imsRolesMappedToRumbaTeacher;

@Value("${ims.roles.mapped.to.rumba.student}")

Set<String> imsRolesMappedToRumbaStudent;

@PostConstruct

public void init() {

LOGGER.info("rolesMappedToRumbaTeacher {}", imsRolesMappedToRumbaTeacher);

LOGGER.info("rolesMappedToRumbaStudent {}", imsRolesMappedToRumbaStudent);

}

@Override

public Mono<LTILaunchRequest<LTILaunchRequestSettings>> handlePlatformAuthenticationResponse(AuthenticationResponse authenticationResponse) {

IssuerResponse issuerResponse= authenticationService.retrieveIssuerResponse(authenticationResponse.getState());

String jwtToken = authenticationResponse.getIdToken();

String issuerId = issuerResponse.getIssuerId();

return platformConfigurationService

.getByIssuerId(issuerId)

.flatMap(platformConfiguration -> getPublicKeyData(platformConfiguration)

.map(publicKeyData -> {

setPlatformConfigurationServicePublicKeyData(platformConfiguration, publicKeyData);

return Tuples.of(platformConfiguration, publicKeyData);

}))

.map(tuple -> jwtHelper.getClaimsFromJWTToken(jwtToken, tuple.getT2())

.map(claims -> {

RumbaRole rumbaRole = obtainRumbaRoleFromLTIRoles(claims);

String messageType = claims.get(Constants.CLAIM_PREFIX + "message_type", String.class);

LaunchRequestProviderType.getLaunchRequestProviderType(messageType)

.map(launchRequestProviderType -> launchRequestServiceLocator.getProvider(launchRequestProviderType)

.map(launchRequestService -> {

launchRequestService.validateLaunchRequest(claims);

launchRequestService.processRequest(claims)

.map(ltiLaunchRequest -> setLtiLaunchRequest(ltiLaunchRequest, tuple.getT1().getRumbaDistrictId(), rumbaRole));

}));

}))

.onErrorResume(InvalidDataException.class, exception -> Response.badRequest(exception.getMessage(), ResponseMediaType.JSON));

// if(Objects.nonNull(platformConfiguration)) {

// PublicKeyData publicKeyData = getPublicKeyData(platformConfiguration);

// Claims claims = jwtHelper.getClaimsFromJWTToken(jwtToken, publicKeyData);

// if (publicKeyData.getIsNewPublicKey()) {

// setPlatformConfigurationPublicKeyData(platformConfiguration, publicKeyData);

// platformConfigurationService.update(platformConfiguration, issuerId);

// LOGGER.debug("platform configuration has been updated issuerId {}, public key id {}", platformConfiguration.getIssuerId(), publicKeyData.getPublicKeyId());

// }

// String messageType = claims.get(Constants.CLAIM_PREFIX + "message_type", String.class);

// LaunchRequestProviderType launchRequestProviderType = LaunchRequestProviderType.getLaunchRequestProviderType(messageType);

// ILaunchRequestService<LTILaunchRequest<LTILaunchRequestSettings>> launchRequestService = launchRequestServiceLocator.getProvider(launchRequestProviderType);

// RumbaRole rumbaRole = obtainRumbaRoleFromLTIRoles(claims);

// launchRequestService.validateLaunchRequest(claims.getSubject(), rumbaRole);

// LTILaunchRequest<LTILaunchRequestSettings> ltiLaunchRequest = launchRequestService.processRequest(claims);

// ltiLaunchRequest.setIssuer(issuerId);

// ltiLaunchRequest.setOrganizationId(platformConfiguration.getRumbaDistrictId());

// ltiLaunchRequest.setRumbaRole(rumbaRole);

// return ltiLaunchRequest;

// }

// throw new InvalidDataException("platformConfiguration is null" + platformConfiguration);

}

@Override

public String getAutoSubmitForm(String redirectUrl, String rumbaUserId) {

SamlResponseInputData samlResponseInputData = new SamlResponseInputData();

samlResponseInputData.setIssuer(issuerId);

samlResponseInputData.setAuthTokenForSaml(rumbaUserId);

samlResponseInputData.setRumbaSSOUrl(rumbaSSOUrl);

samlResponseInputData.setExternalIdpUrl(externalIdp);

samlResponseInputData.setServiceUrl(redirectUrl);

samlResponseInputData.setTimeInSecondsTillValid(3000);

samlResponseInputData.setNameIdentifier(nameIdentitifer);

samlResponseInputData.setNameQualifier(nameQualifier);

samlResponseInputData.setCertificateFilePath(certificatePath);

samlResponseInputData.setPrivateKeyFilePath(privateKeyPkcs8Path);

LOGGER.info("Created auto submit form request {}", samlResponseInputData);

String autoSubmitForm = samlResponseService.getRumbaAutoSubmitForm(samlResponseInputData);

LOGGER.info("Created auto submit form {}", autoSubmitForm);

return autoSubmitForm;

}

@SuppressWarnings("unchecked")

private RumbaRole obtainRumbaRoleFromLTIRoles(Claims claims) {

List<String> roles = (List<String>) claims.get(Constants.CLAIM_PREFIX + "roles");

if (CollectionUtils.isNotEmpty(roles)) {

List<String> studentRoles = roles

.stream()

.filter(imsRolesMappedToRumbaStudent::contains)

.collect(Collectors.toList());

if(CollectionUtils.isNotEmpty(studentRoles)) {

return RumbaRole.S;

}

List<String> teacherRoles = roles

.stream()

.filter(imsRolesMappedToRumbaTeacher::contains)

.collect(Collectors.toList());

if (CollectionUtils.isNotEmpty(teacherRoles)) {

return RumbaRole.T;

}

}

return null;

}

private Mono<PublicKeyData> getPublicKeyData(PlatformConfiguration platformConfiguration) {

PublicKeyData publicKeyData = new PublicKeyData();

publicKeyData.setPublicKeyString(platformConfiguration.getPlatformPublicKey());

publicKeyData.setPublicKeyId(platformConfiguration.getPlatformPublicKeyId());

publicKeyData.setPublicKeySetUrl(platformConfiguration.getPlatformPublicKeySetUrl());

publicKeyData.setPublicKeyType(platformConfiguration.getPlatformPublicKeyType());

publicKeyData.setPublicKeyAlgorithm(platformConfiguration.getPlatformPublicKeyAlgorithm());

return Mono.just(publicKeyData);

}

private void setPlatformConfigurationPublicKeyData(PlatformConfiguration platformConfiguration, PublicKeyData publicKeyData) {

String platformPublicKey = encryption.keyToString(publicKeyData.getPublicKey());

platformConfiguration.setPlatformPublicKey(platformPublicKey);

platformConfiguration.setPlatformPublicKeyAlgorithm(publicKeyData.getPublicKeyAlgorithm());

platformConfiguration.setPlatformPublicKeyId(publicKeyData.getPublicKeyId());

platformConfiguration.setPlatformPublicKeyType(publicKeyData.getPublicKeyType());

}

private void setPlatformConfigurationServicePublicKeyData(PlatformConfiguration platformConfiguration, PublicKeyData publicKeyData) {

if (publicKeyData.getIsNewPublicKey()) {

setPlatformConfigurationPublicKeyData(platformConfiguration, publicKeyData);

platformConfigurationService.update(platformConfiguration, issuerId);

LOGGER.debug("platform configuration has been updated issuerId {}, public key id {}", platformConfiguration.getIssuerId(), publicKeyData.getPublicKeyId());

}

}

private Mono<LTILaunchRequest<LTILaunchRequestSettings>> setLtiLaunchRequest(LTILaunchRequest<LTILaunchRequestSettings> ltiLaunchRequest, String rumbaDistrictId, RumbaRole rumaRole) {

ltiLaunchRequest.setIssuer(issuerId);

ltiLaunchRequest.setOrganizationId(rumbaDistrictId);

ltiLaunchRequest.setRumbaRole(rumaRole);

return Mono.just(ltiLaunchRequest);

}

}

Author

Title

Language

Your paste - Paste your paste here

/*
 * Copyright 2019, Pearson Education, Learning Technology Group
 *
 * PlatformAuthenticationResponseService.java
 */
package com.pearson.ltg.rbs.ltitoolgateway.service.openidconnect;

import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;

import javax.annotation.PostConstruct;

import org.apache.commons.collections.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import com.pearson.ltg.rbs.ltitoolgateway.constant.Constants;
import com.pearson.ltg.rbs.ltitoolgateway.exception.InvalidDataException;
import com.pearson.ltg.rbs.ltitoolgateway.jwt.JwtHelper;
import com.pearson.ltg.rbs.ltitoolgateway.model.AuthenticationResponse;
import com.pearson.ltg.rbs.ltitoolgateway.model.IssuerResponse;
import com.pearson.ltg.rbs.ltitoolgateway.model.LTILaunchRequest;
import com.pearson.ltg.rbs.ltitoolgateway.model.LTILaunchRequestSettings;
import com.pearson.ltg.rbs.ltitoolgateway.model.PlatformConfiguration;
import com.pearson.ltg.rbs.ltitoolgateway.model.PublicKeyData;
import com.pearson.ltg.rbs.ltitoolgateway.model.RumbaRole;
import com.pearson.ltg.rbs.ltitoolgateway.service.IPlatformConfigurationService;
import com.pearson.ltg.rbs.ltitoolgateway.util.Encryption;
import com.pearson.ltg.samlutils.model.SamlResponseInputData;
import com.pearson.ltg.samlutils.service.ISamlResponseService;

import io.jsonwebtoken.Claims;
import reactor.core.publisher.Mono;
import reactor.util.function.Tuples;

@Service
public class PlatformAuthenticationResponseService implements IPlatformAuthenticationResponseService {
    private static final Logger LOGGER = LoggerFactory.getLogger(PlatformAuthenticationResponseService.class);

@Value(&quot;${saml.issuerId}&quot;)
    String issuerId;

@Value(&quot;${saml.rumbaSSOUrl}&quot;)
    String rumbaSSOUrl;

@Value(&quot;${saml.externalIdp}&quot;)
    String externalIdp;

@Value(&quot;${saml.nameIdentitifer}&quot;)
    String nameIdentitifer;

@Value(&quot;${saml.nameQualifier}&quot;)
    String nameQualifier;

@Value(&quot;${saml.certificatePath}&quot;)
    String certificatePath;

@Value(&quot;${saml.privateKeyPkcs8Path}&quot;)
    String privateKeyPkcs8Path;

@Autowired
    JwtHelper jwtHelper;

@Autowired
    Encryption encryption;

@Autowired
    IAuthenticationService authenticationService;

@Autowired
    IPlatformConfigurationService platformConfigurationService;

@Autowired
    ILaunchRequestServiceLocator launchRequestServiceLocator;

@Autowired
    ISamlResponseService samlResponseService;

@Value(&quot;${ims.roles.mapped.to.rumba.teacher}&quot;)
    Set&lt;String&gt; imsRolesMappedToRumbaTeacher;
    @Value(&quot;${ims.roles.mapped.to.rumba.student}&quot;)
    Set&lt;String&gt; imsRolesMappedToRumbaStudent;

@PostConstruct
    public void init() {
        LOGGER.info(&quot;rolesMappedToRumbaTeacher {}&quot;, imsRolesMappedToRumbaTeacher);
        LOGGER.info(&quot;rolesMappedToRumbaStudent {}&quot;, imsRolesMappedToRumbaStudent);
    }

@Override
    public Mono&lt;LTILaunchRequest&lt;LTILaunchRequestSettings&gt;&gt; handlePlatformAuthenticationResponse(AuthenticationResponse authenticationResponse) {
        IssuerResponse issuerResponse= authenticationService.retrieveIssuerResponse(authenticationResponse.getState());
        String jwtToken = authenticationResponse.getIdToken();
        String issuerId = issuerResponse.getIssuerId();
        return platformConfigurationService
                        .getByIssuerId(issuerId)
                        .flatMap(platformConfiguration -&gt; getPublicKeyData(platformConfiguration)
                            .map(publicKeyData -&gt; {
                                setPlatformConfigurationServicePublicKeyData(platformConfiguration, publicKeyData);
                                return Tuples.of(platformConfiguration, publicKeyData);
                             }))
                        .map(tuple -&gt; jwtHelper.getClaimsFromJWTToken(jwtToken, tuple.getT2())
                            .map(claims -&gt; {
                                 RumbaRole rumbaRole = obtainRumbaRoleFromLTIRoles(claims);
                                 String messageType = claims.get(Constants.CLAIM_PREFIX + &quot;message_type&quot;, String.class);
                                 LaunchRequestProviderType.getLaunchRequestProviderType(messageType)
                                     .map(launchRequestProviderType -&gt; launchRequestServiceLocator.getProvider(launchRequestProviderType)
                                     .map(launchRequestService -&gt;  {
                                         launchRequestService.validateLaunchRequest(claims);
                                         launchRequestService.processRequest(claims)
                                             .map(ltiLaunchRequest -&gt; setLtiLaunchRequest(ltiLaunchRequest, tuple.getT1().getRumbaDistrictId(), rumbaRole));
                                          }));
                            }))
                        .onErrorResume(InvalidDataException.class, exception -&gt; Response.badRequest(exception.getMessage(), ResponseMediaType.JSON));

//        if(Objects.nonNull(platformConfiguration)) {
//            PublicKeyData publicKeyData = getPublicKeyData(platformConfiguration);
//            Claims claims = jwtHelper.getClaimsFromJWTToken(jwtToken, publicKeyData);
//            if (publicKeyData.getIsNewPublicKey()) {
//                setPlatformConfigurationPublicKeyData(platformConfiguration, publicKeyData);
//                platformConfigurationService.update(platformConfiguration, issuerId);
//                LOGGER.debug(&quot;platform configuration has been updated issuerId {}, public key id {}&quot;, platformConfiguration.getIssuerId(), publicKeyData.getPublicKeyId());
//            }
//            String messageType = claims.get(Constants.CLAIM_PREFIX + &quot;message_type&quot;, String.class);
//            LaunchRequestProviderType launchRequestProviderType = LaunchRequestProviderType.getLaunchRequestProviderType(messageType);
//            ILaunchRequestService&lt;LTILaunchRequest&lt;LTILaunchRequestSettings&gt;&gt; launchRequestService = launchRequestServiceLocator.getProvider(launchRequestProviderType);
//            RumbaRole rumbaRole = obtainRumbaRoleFromLTIRoles(claims);
//            launchRequestService.validateLaunchRequest(claims.getSubject(), rumbaRole);
//            LTILaunchRequest&lt;LTILaunchRequestSettings&gt; ltiLaunchRequest = launchRequestService.processRequest(claims);
//            ltiLaunchRequest.setIssuer(issuerId);
//            ltiLaunchRequest.setOrganizationId(platformConfiguration.getRumbaDistrictId());
//            ltiLaunchRequest.setRumbaRole(rumbaRole);
//            return ltiLaunchRequest;
//        }
        // throw new InvalidDataException(&quot;platformConfiguration is null&quot; + platformConfiguration);
    }

@Override
    public String getAutoSubmitForm(String redirectUrl, String rumbaUserId) {
        SamlResponseInputData samlResponseInputData = new SamlResponseInputData();
        samlResponseInputData.setIssuer(issuerId);
        samlResponseInputData.setAuthTokenForSaml(rumbaUserId);
        samlResponseInputData.setRumbaSSOUrl(rumbaSSOUrl);
        samlResponseInputData.setExternalIdpUrl(externalIdp);
        samlResponseInputData.setServiceUrl(redirectUrl);
        samlResponseInputData.setTimeInSecondsTillValid(3000);
        samlResponseInputData.setNameIdentifier(nameIdentitifer);
        samlResponseInputData.setNameQualifier(nameQualifier);
        samlResponseInputData.setCertificateFilePath(certificatePath);
        samlResponseInputData.setPrivateKeyFilePath(privateKeyPkcs8Path);
        LOGGER.info(&quot;Created auto submit form request {}&quot;, samlResponseInputData);
        String autoSubmitForm = samlResponseService.getRumbaAutoSubmitForm(samlResponseInputData);
        LOGGER.info(&quot;Created auto submit form {}&quot;, autoSubmitForm);
        return autoSubmitForm;
    }

@SuppressWarnings(&quot;unchecked&quot;)
    private RumbaRole obtainRumbaRoleFromLTIRoles(Claims claims) {

List&lt;String&gt; roles = (List&lt;String&gt;) claims.get(Constants.CLAIM_PREFIX + &quot;roles&quot;);
        if (CollectionUtils.isNotEmpty(roles)) {
            List&lt;String&gt; studentRoles = roles
                    .stream()
                    .filter(imsRolesMappedToRumbaStudent::contains)
                    .collect(Collectors.toList());
            if(CollectionUtils.isNotEmpty(studentRoles)) {
                return RumbaRole.S;
            }
            List&lt;String&gt; teacherRoles = roles
                    .stream()
                    .filter(imsRolesMappedToRumbaTeacher::contains)
                    .collect(Collectors.toList());
            if (CollectionUtils.isNotEmpty(teacherRoles)) {
                return RumbaRole.T;
            }
        }
        return null;
    }

private Mono&lt;PublicKeyData&gt; getPublicKeyData(PlatformConfiguration platformConfiguration) {
        PublicKeyData publicKeyData = new PublicKeyData();
        publicKeyData.setPublicKeyString(platformConfiguration.getPlatformPublicKey());
        publicKeyData.setPublicKeyId(platformConfiguration.getPlatformPublicKeyId());
        publicKeyData.setPublicKeySetUrl(platformConfiguration.getPlatformPublicKeySetUrl());
        publicKeyData.setPublicKeyType(platformConfiguration.getPlatformPublicKeyType());
        publicKeyData.setPublicKeyAlgorithm(platformConfiguration.getPlatformPublicKeyAlgorithm());
        return Mono.just(publicKeyData);
    }

private void setPlatformConfigurationPublicKeyData(PlatformConfiguration platformConfiguration, PublicKeyData publicKeyData) {
        String platformPublicKey = encryption.keyToString(publicKeyData.getPublicKey());
        platformConfiguration.setPlatformPublicKey(platformPublicKey);
        platformConfiguration.setPlatformPublicKeyAlgorithm(publicKeyData.getPublicKeyAlgorithm());
        platformConfiguration.setPlatformPublicKeyId(publicKeyData.getPublicKeyId());
        platformConfiguration.setPlatformPublicKeyType(publicKeyData.getPublicKeyType());
    }
    
    private void setPlatformConfigurationServicePublicKeyData(PlatformConfiguration platformConfiguration, PublicKeyData publicKeyData) {
        if (publicKeyData.getIsNewPublicKey()) {
          setPlatformConfigurationPublicKeyData(platformConfiguration, publicKeyData);
          platformConfigurationService.update(platformConfiguration, issuerId);
          LOGGER.debug(&quot;platform configuration has been updated issuerId {}, public key id {}&quot;, platformConfiguration.getIssuerId(), publicKeyData.getPublicKeyId());
      }
    }
    
    private Mono&lt;LTILaunchRequest&lt;LTILaunchRequestSettings&gt;&gt; setLtiLaunchRequest(LTILaunchRequest&lt;LTILaunchRequestSettings&gt; ltiLaunchRequest, String rumbaDistrictId, RumbaRole rumaRole) {
      ltiLaunchRequest.setIssuer(issuerId);
      ltiLaunchRequest.setOrganizationId(rumbaDistrictId);
      ltiLaunchRequest.setRumbaRole(rumaRole);
      return Mono.just(ltiLaunchRequest);
    }
}

Create Shorturl - Create a shorter url that redirects to your paste?

Private - Private paste aren't shown in recent listings.

Delete After - When should we delete your paste?

A PHP Error was encountered

Reply to "Re: Untitled"