Example usage for org.springframework.util MultiValueMap add

List of usage examples for org.springframework.util MultiValueMap add

Introduction

In this page you can find the example usage for org.springframework.util MultiValueMap add.

Prototype

void add(K key, @Nullable V value);

Source Link

Document

Add the given single value to the current list of values for the given key.

Usage

From source file:org.kuali.rice.kew.doctype.service.impl.DocumentSecurityServiceImpl.java

protected MultiValueMap<String, ExtensionDefinition> loadExtensionDefinitions(DocumentTypeSecurity security,
        SecuritySession securitySession) {
    MultiValueMap<String, ExtensionDefinition> securityAttributeExtensionDefinitions = new LinkedMultiValueMap<String, ExtensionDefinition>();
    List<String> securityAttributeExtensionNames = security.getSecurityAttributeExtensionNames();
    for (String securityAttributeExtensionName : securityAttributeExtensionNames) {
        ExtensionDefinition extensionDefinition = extensionRepositoryService
                .getExtensionByName(securityAttributeExtensionName);
        securityAttributeExtensionDefinitions.add(extensionDefinition.getApplicationId(), extensionDefinition);
    }//w  ww .  j a  v  a2 s.  c o m
    return securityAttributeExtensionDefinitions;
}

From source file:org.kuali.rice.kim.impl.role.RoleServiceImpl.java

/**
 * Checks each of the result records to determine if there are potentially applicable delegation members for that
 * role membership.  If there are, applicable delegations and members will be linked to the RoleMemberships in the
 * given list.  An updated list will be returned from this method which includes the appropriate linked delegations.
 *///from www  .ja  v  a  2 s. com
protected List<RoleMembership.Builder> applyDelegationsToRoleMembers(List<RoleMembership> roleMemberships,
        Collection<DelegateTypeBo> delegations, Map<String, String> qualification) {
    MultiValueMap<String, String> roleIdToRoleMembershipIds = new LinkedMultiValueMap<String, String>();
    Map<String, RoleMembership.Builder> roleMembershipIdToBuilder = new HashMap<String, RoleMembership.Builder>();
    List<RoleMembership.Builder> roleMembershipBuilders = new ArrayList<RoleMembership.Builder>();
    // to make our algorithm less painful, let's do some indexing and load the given list of RoleMemberships into
    // builders
    for (RoleMembership roleMembership : roleMemberships) {
        roleIdToRoleMembershipIds.add(roleMembership.getRoleId(), roleMembership.getId());
        RoleMembership.Builder builder = RoleMembership.Builder.create(roleMembership);
        roleMembershipBuilders.add(builder);
        roleMembershipIdToBuilder.put(roleMembership.getId(), builder);
    }
    for (DelegateTypeBo delegation : delegations) {
        // determine the candidate role memberships where this delegation can be mapped
        List<String> candidateRoleMembershipIds = roleIdToRoleMembershipIds.get(delegation.getRoleId());
        if (CollectionUtils.isNotEmpty(candidateRoleMembershipIds)) {
            DelegationTypeService delegationTypeService = getDelegationTypeService(
                    delegation.getDelegationId());
            for (DelegateMemberBo delegationMember : delegation.getMembers()) {
                // Make sure that the delegation member is active
                if (delegationMember.isActive(DateTime.now()) && (delegationTypeService == null
                        || delegationTypeService.doesDelegationQualifierMatchQualification(qualification,
                                delegationMember.getQualifier()))) {
                    DelegateMember.Builder delegateMemberBuilder = DelegateMember.Builder
                            .create(delegationMember);
                    // if the member has no role member id, check qualifications and apply to all matching role memberships on the role
                    if (StringUtils.isBlank(delegationMember.getRoleMemberId())) {
                        RoleTypeService roleTypeService = getRoleTypeService(delegation.getRoleId());
                        for (String roleMembershipId : candidateRoleMembershipIds) {
                            RoleMembership.Builder roleMembershipBuilder = roleMembershipIdToBuilder
                                    .get(roleMembershipId);
                            if (roleTypeService == null || roleTypeService.doesRoleQualifierMatchQualification(
                                    roleMembershipBuilder.getQualifier(), delegationMember.getQualifier())) {
                                linkDelegateToRoleMembership(delegation, delegateMemberBuilder,
                                        roleMembershipBuilder);
                            }
                        }
                    } else if (candidateRoleMembershipIds.contains(delegationMember.getRoleMemberId())) {
                        RoleMembership.Builder roleMembershipBuilder = roleMembershipIdToBuilder
                                .get(delegationMember.getRoleMemberId());
                        linkDelegateToRoleMembership(delegation, delegateMemberBuilder, roleMembershipBuilder);
                    }
                }
            }
        }
    }
    return roleMembershipBuilders;
}

From source file:org.mitre.openid.connect.client.AbstractOIDCAuthenticationFilter.java

/**
 * Handles the authorization grant response
 * /*from   w  w w  .  j a v  a 2s .  c om*/
 * @param authorizationGrant
 *            The Authorization grant code
 * @param request
 *            The request from which to extract parameters and perform the
 *            authentication
 * @return The authenticated user token, or null if authentication is
 *         incomplete.
 * @throws Exception 
 * @throws UnsupportedEncodingException
 */
protected Authentication handleAuthorizationGrantResponse(String authorizationGrant, HttpServletRequest request,
        OIDCServerConfiguration serverConfig) {

    final boolean debug = logger.isDebugEnabled();

    // Handle Token Endpoint interaction
    HttpClient httpClient = new DefaultHttpClient();

    httpClient.getParams().setParameter("http.socket.timeout", new Integer(httpSocketTimeout));

    //
    // TODO: basic auth is untested (it wasn't working last I
    // tested)
    // UsernamePasswordCredentials credentials = new
    // UsernamePasswordCredentials(serverConfig.getClientId(),
    // serverConfig.getClientSecret());
    // ((DefaultHttpClient)
    // httpClient).getCredentialsProvider().setCredentials(AuthScope.ANY,
    // credentials);
    //

    HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory(httpClient);

    RestTemplate restTemplate = new RestTemplate(factory);

    MultiValueMap<String, String> form = new LinkedMultiValueMap<String, String>();
    form.add("grant_type", "authorization_code");
    form.add("code", authorizationGrant);
    form.add("redirect_uri", AbstractOIDCAuthenticationFilter.buildRedirectURI(request, null));

    // pass clientId and clientSecret in post of request
    form.add("client_id", serverConfig.getClientId());
    form.add("client_secret", serverConfig.getClientSecret());

    if (debug) {
        logger.debug("tokenEndpointURI = " + serverConfig.getTokenEndpointURI());
        logger.debug("form = " + form);
    }
    ;
    String jsonString = null;

    try {
        jsonString = restTemplate.postForObject(serverConfig.getTokenEndpointURI(), form, String.class);
    } catch (HttpClientErrorException httpClientErrorException) {

        // Handle error

        logger.error("Token Endpoint error response:  " + httpClientErrorException.getStatusText() + " : "
                + httpClientErrorException.getMessage());

        throw new AuthenticationServiceException("Unable to obtain Access Token.");
    }

    logger.debug("from TokenEndpoint jsonString = " + jsonString);

    JsonElement jsonRoot = new JsonParser().parse(jsonString);

    if (jsonRoot.getAsJsonObject().get("error") != null) {

        // Handle error

        String error = jsonRoot.getAsJsonObject().get("error").getAsString();

        logger.error("Token Endpoint returned: " + error);

        throw new AuthenticationServiceException(
                "Unable to obtain Access Token.  Token Endpoint returned: " + error);

    } else {

        // Extract the id_token to insert into the
        // OpenIdConnectAuthenticationToken

        IdToken idToken = null;
        JwtSigningAndValidationService jwtValidator = getValidatorForServer(serverConfig);

        if (jsonRoot.getAsJsonObject().get("id_token") != null) {

            try {
                idToken = IdToken.parse(jsonRoot.getAsJsonObject().get("id_token").getAsString());

            } catch (AuthenticationServiceException e) {

                // I suspect this could happen

                logger.error("Problem parsing id_token:  " + e);
                // e.printStackTrace();

                throw new AuthenticationServiceException(
                        "Problem parsing id_token return from Token endpoint: " + e);
            }

            if (jwtValidator
                    .validateSignature(jsonRoot.getAsJsonObject().get("id_token").getAsString()) == false) {
                throw new AuthenticationServiceException("Signature not validated");
            }
            if (idToken.getClaims().getIssuer() == null) {
                throw new AuthenticationServiceException("Issuer is null");
            }
            if (!idToken.getClaims().getIssuer().equals(serverConfig.getIssuer())) {
                throw new AuthenticationServiceException("Issuers do not match");
            }
            if (jwtValidator.isJwtExpired(idToken)) {
                throw new AuthenticationServiceException("Id Token is expired");
            }
            if (jwtValidator.validateIssuedAt(idToken) == false) {
                throw new AuthenticationServiceException("Id Token issuedAt failed");
            }

        } else {

            // An error is unlikely, but it good security to check

            logger.error("Token Endpoint did not return an id_token");

            throw new AuthenticationServiceException("Token Endpoint did not return an id_token");
        }

        // Clients are required to compare nonce claim in ID token to 
        // the nonce sent in the Authorization request.  The client 
        // stores this value as a signed session cookie to detect a 
        // replay by third parties.
        //
        // See: OpenID Connect Messages Section 2.1.1 entitled "ID Token"
        //
        // http://openid.net/specs/openid-connect-messages-1_0.html#id_token
        //

        //String nonce = idToken.getClaims().getClaimAsString("nonce");

        String nonce = idToken.getClaims().getNonce();

        if (StringUtils.isBlank(nonce)) {

            logger.error("ID token did not contain a nonce claim.");

            throw new AuthenticationServiceException("ID token did not contain a nonce claim.");
        }

        Cookie nonceSignatureCookie = WebUtils.getCookie(request, NONCE_SIGNATURE_COOKIE_NAME);

        if (nonceSignatureCookie != null) {

            String sigText = nonceSignatureCookie.getValue();

            if (sigText != null && !sigText.isEmpty()) {

                if (!verify(signer, publicKey, nonce, sigText)) {
                    logger.error("Possible replay attack detected! "
                            + "The comparison of the nonce in the returned " + "ID Token to the signed session "
                            + NONCE_SIGNATURE_COOKIE_NAME + " failed.");

                    throw new AuthenticationServiceException("Possible replay attack detected! "
                            + "The comparison of the nonce in the returned " + "ID Token to the signed session "
                            + NONCE_SIGNATURE_COOKIE_NAME + " failed.");
                }
            } else {
                logger.error(NONCE_SIGNATURE_COOKIE_NAME + " cookie was found but value was null or empty");
                throw new AuthenticationServiceException(
                        NONCE_SIGNATURE_COOKIE_NAME + " cookie was found but value was null or empty");
            }

        } else {

            logger.error(NONCE_SIGNATURE_COOKIE_NAME + " cookie was not found.");

            throw new AuthenticationServiceException(NONCE_SIGNATURE_COOKIE_NAME + " cookie was not found.");
        }

        // pull the user_id out as a claim on the id_token

        String userId = idToken.getTokenClaims().getUserId();

        // construct an OpenIdConnectAuthenticationToken and return 
        // a Authentication object w/the userId and the idToken

        OpenIdConnectAuthenticationToken token = new OpenIdConnectAuthenticationToken(userId, idToken);

        Authentication authentication = this.getAuthenticationManager().authenticate(token);

        return authentication;

    }
}

From source file:org.openlmis.upload.AuthService.java

/**
 * Retrieves access token from the auth service.
 *
 * @return token/*from  w  ww .j  a  v  a  2s.c o  m*/
 */
public String obtainAccessToken() {
    String plainCreds = configuration.getClientId() + ":" + configuration.getClientSecret();
    byte[] plainCredsBytes = plainCreds.getBytes();
    byte[] base64CredsBytes = Base64.encodeBase64(plainCredsBytes);
    String base64Creds = new String(base64CredsBytes);

    HttpHeaders headers = new HttpHeaders();
    headers.add("Authorization", "Basic " + base64Creds);
    headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);

    MultiValueMap<String, String> form = new LinkedMultiValueMap<>();
    form.add("username", configuration.getLogin());
    form.add("password", configuration.getPassword());

    HttpEntity<MultiValueMap<String, String>> request = new HttpEntity<>(form, headers);
    RequestParameters params = RequestParameters.init().set("grant_type", "password");

    try {
        ResponseEntity<?> response = restTemplate.exchange(
                createUri(configuration.getHost() + "/api/oauth/token", params), HttpMethod.POST, request,
                Object.class);
        return ((Map<String, String>) response.getBody()).get(ACCESS_TOKEN);
    } catch (RestClientException ex) {
        throw new AuthorizationException("Cannot obtain access token using the provided credentials. "
                + "Please verify they are correct.", ex);
    }
}

From source file:org.springframework.cloud.netflix.zuul.filters.ProxyRequestHelper.java

public MultiValueMap<String, String> buildZuulRequestQueryParams(HttpServletRequest request) {

    Map<String, List<String>> map = HTTPRequestUtils.getInstance().getQueryParams();

    MultiValueMap<String, String> params = new LinkedMultiValueMap<>();
    if (map == null)
        return params;

    for (String key : map.keySet()) {

        for (String value : map.get(key)) {
            params.add(key, value);
        }/* w  w  w .  j ava  2 s . co  m*/
    }
    return params;
}

From source file:org.springframework.cloud.netflix.zuul.filters.route.support.ZuulProxyTestBase.java

@SuppressWarnings("deprecation")
@Test/*from   w  w  w .  j  av  a  2  s. com*/
public void javascriptEncodedFormParams() {
    TestRestTemplate testRestTemplate = new TestRestTemplate();
    ArrayList<HttpMessageConverter<?>> converters = new ArrayList<>();
    converters
            .addAll(Arrays.asList(new StringHttpMessageConverter(), new NoEncodingFormHttpMessageConverter()));
    testRestTemplate.getRestTemplate().setMessageConverters(converters);

    MultiValueMap<String, String> map = new LinkedMultiValueMap<>();
    map.add("foo", "(bar)");
    ResponseEntity<String> result = testRestTemplate
            .postForEntity("http://localhost:" + this.port + "/simple/local", map, String.class);
    assertEquals(HttpStatus.OK, result.getStatusCode());
    assertEquals("Posted [(bar)] and Content-Length was: 13!", result.getBody());
}

From source file:org.springframework.cloud.stream.app.jdbc.sink.JdbcSinkConfiguration.java

@Bean
@ServiceActivator(autoStartup = "false", inputChannel = Sink.INPUT)
public JdbcMessageHandler jdbcMessageHandler(DataSource dataSource) {
    final MultiValueMap<String, Expression> columnExpressionVariations = new LinkedMultiValueMap<>();
    for (Map.Entry<String, String> entry : properties.getColumns().entrySet()) {
        String value = entry.getValue();
        columnExpressionVariations.add(entry.getKey(), spelExpressionParser.parseExpression(value));
        if (!value.startsWith("payload")) {
            columnExpressionVariations.add(entry.getKey(),
                    spelExpressionParser.parseExpression("payload." + value));
        }//from  w w  w . j a  v  a 2s  .c  o m
    }
    JdbcMessageHandler jdbcMessageHandler = new JdbcMessageHandler(dataSource,
            generateSql(properties.getTableName(), columnExpressionVariations.keySet()));
    jdbcMessageHandler.setSqlParameterSourceFactory(new SqlParameterSourceFactory() {
        @Override
        public SqlParameterSource createParameterSource(Object o) {
            if (!(o instanceof Message)) {
                throw new IllegalArgumentException("Unable to handle type " + o.getClass().getName());
            }
            Message<?> message = (Message<?>) o;
            MapSqlParameterSource parameterSource = new MapSqlParameterSource();
            for (String key : columnExpressionVariations.keySet()) {
                List<Expression> spels = columnExpressionVariations.get(key);
                Object value = NOT_SET;
                EvaluationException lastException = null;
                for (Expression spel : spels) {
                    try {
                        value = spel.getValue(evaluationContext, message);
                        break;
                    } catch (EvaluationException e) {
                        lastException = e;
                    }
                }
                if (value == NOT_SET) {
                    if (lastException != null) {
                        logger.info(
                                "Could not find value for column '" + key + "': " + lastException.getMessage());
                    }
                    parameterSource.addValue(key, null);
                } else {
                    if (value instanceof JsonPropertyAccessor.ToStringFriendlyJsonNode) {
                        // Need to do some reflection until we have a getter for the Node
                        DirectFieldAccessor dfa = new DirectFieldAccessor(value);
                        JsonNode node = (JsonNode) dfa.getPropertyValue("node");
                        Object valueToUse;
                        if (node == null || node.isNull()) {
                            valueToUse = null;
                        } else if (node.isNumber()) {
                            valueToUse = node.numberValue();
                        } else if (node.isBoolean()) {
                            valueToUse = node.booleanValue();
                        } else {
                            valueToUse = node.textValue();
                        }
                        parameterSource.addValue(key, valueToUse);
                    } else {
                        parameterSource.addValue(key, value);
                    }
                }
            }
            return parameterSource;
        }
    });
    return jdbcMessageHandler;
}

From source file:org.springframework.data.document.web.bind.annotation.support.HandlerMethodInvoker.java

private Map resolveRequestParamMap(Class<? extends Map> mapType, NativeWebRequest webRequest) {
    Map<String, String[]> parameterMap = webRequest.getParameterMap();
    if (MultiValueMap.class.isAssignableFrom(mapType)) {
        MultiValueMap<String, String> result = new LinkedMultiValueMap<String, String>(parameterMap.size());
        for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
            for (String value : entry.getValue()) {
                result.add(entry.getKey(), value);
            }//from w  w w .ja  va 2  s .co  m
        }
        return result;
    } else {
        Map<String, String> result = new LinkedHashMap<String, String>(parameterMap.size());
        for (Map.Entry<String, String[]> entry : parameterMap.entrySet()) {
            if (entry.getValue().length > 0) {
                result.put(entry.getKey(), entry.getValue()[0]);
            }
        }
        return result;
    }
}

From source file:org.springframework.data.document.web.bind.annotation.support.HandlerMethodInvoker.java

private Map resolveRequestHeaderMap(Class<? extends Map> mapType, NativeWebRequest webRequest) {
    if (MultiValueMap.class.isAssignableFrom(mapType)) {
        MultiValueMap<String, String> result;
        if (HttpHeaders.class.isAssignableFrom(mapType)) {
            result = new HttpHeaders();
        } else {/*  ww w.  j a  va  2  s.co m*/
            result = new LinkedMultiValueMap<String, String>();
        }
        for (Iterator<String> iterator = webRequest.getHeaderNames(); iterator.hasNext();) {
            String headerName = iterator.next();
            for (String headerValue : webRequest.getHeaderValues(headerName)) {
                result.add(headerName, headerValue);
            }
        }
        return result;
    } else {
        Map<String, String> result = new LinkedHashMap<String, String>();
        for (Iterator<String> iterator = webRequest.getHeaderNames(); iterator.hasNext();) {
            String headerName = iterator.next();
            String headerValue = webRequest.getHeader(headerName);
            result.put(headerName, headerValue);
        }
        return result;
    }
}

From source file:org.springframework.data.keyvalue.riak.client.RiakRestClient.java

private MultiValueMap<String, String> getHeadersMap(RiakParameter... parameters) {
    MultiValueMap<String, String> headerMap = new LinkedMultiValueMap<String, String>();
    headerMap.add(HttpHeaders.X_RIAK_CLIENT_ID, getClientId());
    if (parameters != null && parameters.length > 0) {
        for (RiakParameter param : parameters) {
            if (param.getType().equals(Type.HEADER))
                headerMap.add(param.getKey(), param.getValue());
        }/*  w w  w . jav  a2  s  .  c om*/
    }

    return headerMap;
}