Untitled

From Diminutive Peafowl, 5 Years ago, written in Java.

URL http://geopaste.scratchbook.ch/view/6c003b32

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.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 -> Tuples.of(platformConfiguration, publicKeyData)))

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

.map(claims -> {

updatePlatformConfigurationWithPulicKey(tuple.getT1(), tuple.getT2());

return Tuples.of(platformConfiguration, claims);

}))

.flatMap(claimsKeyConfigTuple -> {

RumbaRole rumbaRole = obtainRumbaRoleFromLTIRoles(claimsKeyConfigTuple.getT2());

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

LaunchRequestProviderType launchRequestProviderType = LaunchRequestProviderType.getLaunchRequestProviderType(messageType);

return Mono.just(launchRequestProviderType)

.map(launchRequestServiceLocator::getProvider)

.flatMap(launchRequestService -> {

launchRequestService.validateLaunchRequest(claimsKeyConfigTuple.getT2().getSubject(), rumbaRole);

LTILaunchRequest<LTILaunchRequestSettings> ltiLaunchRequest = launchRequestService.processRequest(claimsKeyConfigTuple.getT3());

setLtiLaunchRequest(ltiLaunchRequest, claimsKeyConfigTuple.getT1().getRumbaDistrictId(), rumbaRole);

return Mono.just(ltiLaunchRequest);

});

});

}

@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 updatePlatformConfigurationWithPulicKey(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 void setLtiLaunchRequest(LTILaunchRequest<LTILaunchRequestSettings> ltiLaunchRequest, String rumbaDistrictId, RumbaRole rumaRole) {

ltiLaunchRequest.setIssuer(issuerId);

ltiLaunchRequest.setOrganizationId(rumbaDistrictId);

ltiLaunchRequest.setRumbaRole(rumaRole);

}

}

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.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; Tuples.of(platformConfiguration, publicKeyData)))
                        .flatMap(tuple -&gt; jwtHelper.getClaimsFromJWTToken(jwtToken, tuple.getT2())
                            .map(claims -&gt; {
                                updatePlatformConfigurationWithPulicKey(tuple.getT1(), tuple.getT2());
                                return Tuples.of(platformConfiguration, claims);
                             }))
                        .flatMap(claimsKeyConfigTuple -&gt; {
                             RumbaRole rumbaRole = obtainRumbaRoleFromLTIRoles(claimsKeyConfigTuple.getT2());
                             String messageType = claims.get(Constants.CLAIM_PREFIX + &quot;message_type&quot;, String.class);
                             LaunchRequestProviderType launchRequestProviderType = LaunchRequestProviderType.getLaunchRequestProviderType(messageType);
                             return Mono.just(launchRequestProviderType)
                                 .map(launchRequestServiceLocator::getProvider)
                                 .flatMap(launchRequestService -&gt;  {
                                     launchRequestService.validateLaunchRequest(claimsKeyConfigTuple.getT2().getSubject(), rumbaRole);
                                     LTILaunchRequest&lt;LTILaunchRequestSettings&gt; ltiLaunchRequest = launchRequestService.processRequest(claimsKeyConfigTuple.getT3());
                                     setLtiLaunchRequest(ltiLaunchRequest, claimsKeyConfigTuple.getT1().getRumbaDistrictId(), rumbaRole);
                                     return Mono.just(ltiLaunchRequest);
                                 });
                        });
    }

@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 updatePlatformConfigurationWithPulicKey(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 void setLtiLaunchRequest(LTILaunchRequest&lt;LTILaunchRequestSettings&gt; ltiLaunchRequest, String rumbaDistrictId, RumbaRole rumaRole) {
      ltiLaunchRequest.setIssuer(issuerId);
      ltiLaunchRequest.setOrganizationId(rumbaDistrictId);
      ltiLaunchRequest.setRumbaRole(rumaRole);
    }
}

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 "Untitled"