Java 类org.springframework.util.MultiValueMap 实例源码

private void send(String subject, String to, String toEmail, String body) {
    final String url = "https://api.mailgun.net/v3/" +
        env.getProperty("mailgun.domain") + "/messages";

    final MultiValueMap<String, String> args = new LinkedMultiValueMap<>();
    args.put("subject", singletonList(subject));
    args.put("from",  singletonList(env.getProperty("service.email.sitename") +
              " <" +  env.getProperty("service.email.sender") + ">"));
    args.put("to", singletonList(to + " <" + toEmail + ">"));
    args.put("html", singletonList(body));

    final ResponseEntity<MailGunResponse> response =
        mailgun.postForEntity(url, args, MailGunResponse.class);

    if (!response.getStatusCode().is2xxSuccessful()) {
        throw new RuntimeException(
            "Error delivering mail. Message: " +
            response.getBody().getMessage()
        );
    }
}

/**
 * Gets the HTTP request entity encapsulating the headers and body of the HTTP message. The body
 * of the HTTP request message will consist of an URL encoded application form (a mapping of
 * key-value pairs) for POST/PUT HTTP requests.
 * <p/>
 * 
 * @return an HttpEntity with the headers and body for the HTTP request message.
 * @see #getParameters()
 * @see org.springframework.http.HttpEntity
 * @see org.springframework.http.HttpHeaders
 */
public HttpEntity<?> createRequestEntity() {
  if (isPost() || isPut()) {
    // NOTE HTTP request parameters take precedence over HTTP message body content/media
    if (!getParameters().isEmpty()) {
      getHeaders().setContentType(determineContentType(MediaType.APPLICATION_FORM_URLENCODED));
      return new HttpEntity<MultiValueMap<String, Object>>(getParameters(), getHeaders());
    } else {
      // NOTE the HTTP "Content-Type" header will be determined and set by the appropriate
      // HttpMessageConverter
      // based on the Class type of the "content".
      return new HttpEntity<Object>(getContent(), getHeaders());
    }
  } else {
    return new HttpEntity<Object>(getHeaders());
  }
}

public static String getAnswer(RestTemplate restTemplate, String question) {
    String url = "http://www.tuling123.com/openapi/api";
    HttpHeaders headers = new HttpHeaders();
    headers.add("Ocp-Apim-Subscription-Key", "3f5a37d9698744f3b40c89e2f0c94fb1");
    headers.add("Content-Type", "application/x-www-form-urlencoded");


    MultiValueMap<String, String> bodyMap = new LinkedMultiValueMap<>();
    bodyMap.add("key", "e2e33efb4efb4e5794b48a18578384ee");
    bodyMap.add("info", question);


    HttpEntity<MultiValueMap<String, String>> requestEntity = new HttpEntity<>(bodyMap, headers);
    String result = restTemplate.postForObject(url, requestEntity, String.class);
    return JsonPath.read(result, "$.text");
}

private HttpEntity<MultiValueMap<String, String>> buildResponseEntity(
    Submission submission, HttpHeaders headers) {
  logger.debug("Building response entity");
  MultiValueMap<String, String> map = new LinkedMultiValueMap<>();

  try {
    map.add("test_output", new ObjectMapper().writeValueAsString(
        submission.getTestOutput()));
  } catch (JsonProcessingException ex) {
    logger.debug("POJO deserialization failed");
  }
  map.add("stdout", submission.getStdout());
  map.add("stderr", submission.getStderr());
  map.add("validations", submission.getValidations());
  map.add("vm_log", submission.getVmLog());
  map.add("token", submission.getId().toString());
  map.add("status", submission.getStatus().toString());
  map.add("exit_code", submission.getExitCode().toString());

  return new HttpEntity<>(map, headers);
}

@Test
@SuppressWarnings("unchecked")
public void findConnectionsToUsers() {
    connectionFactoryRegistry.addConnectionFactory(new TestTwitterConnectionFactory());
    insertTwitterConnection();
    insertFacebookConnection();
    insertFacebookConnection2();
    MultiValueMap<String, String> providerUsers = new LinkedMultiValueMap<>();
    providerUsers.add("facebook", "10");
    providerUsers.add("facebook", "9");
    providerUsers.add("twitter", "1");
    MultiValueMap<String, Connection<?>> connectionsForUsers = connectionRepository.findConnectionsToUsers(providerUsers);
    assertEquals(2, connectionsForUsers.size());
    String providerId=connectionsForUsers.getFirst("facebook").getKey().getProviderUserId();
    assertTrue("10".equals(providerId) || "9".equals(providerId) );
    assertFacebookConnection((Connection<TestFacebookApi>) connectionRepository.getConnection(new ConnectionKey("facebook", "9")));
    assertTwitterConnection((Connection<TestTwitterApi>) connectionsForUsers.getFirst("twitter"));
}

@Override
public void handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {

    if (returnValue == null) {
        mavContainer.setRequestHandled(true);
        return;
    }

    final AsyncResponseEntity<?> asyncResponseEntity = AsyncResponseEntity.class.cast(returnValue);

    Observable<?> observable = asyncResponseEntity.getObservable();
    Single<?> single = asyncResponseEntity.getSingle();
    MultiValueMap<String, String> headers =  asyncResponseEntity.getHeaders();
    HttpStatus status = asyncResponseEntity.getStatus();

    if(observable != null)
        WebAsyncUtils.getAsyncManager(webRequest).startDeferredResultProcessing(new ObservableDeferredResult<>(observable, headers, status), mavContainer);
    else if(single != null)
        WebAsyncUtils.getAsyncManager(webRequest).startDeferredResultProcessing(new SingleDeferredResult<>(single, headers, status), mavContainer);

}

@Test
@SuppressWarnings("unchecked")
public void findConnectionsToUsers() {
    connectionFactoryRegistry.addConnectionFactory(new TestTwitterConnectionFactory());
    insertTwitterConnection();
    insertFacebookConnection();
    insertFacebookConnection2();
    MultiValueMap<String, String> providerUsers = new LinkedMultiValueMap<>();
    providerUsers.add("facebook", "10");
    providerUsers.add("facebook", "9");
    providerUsers.add("twitter", "1");
    MultiValueMap<String, Connection<?>> connectionsForUsers = connectionRepository.findConnectionsToUsers(providerUsers);
    assertEquals(2, connectionsForUsers.size());
    String providerId=connectionsForUsers.getFirst("facebook").getKey().getProviderUserId();
    assertTrue("10".equals(providerId) || "9".equals(providerId) );
    assertFacebookConnection((Connection<TestFacebookApi>) connectionRepository.getConnection(new ConnectionKey("facebook", "9")));
    assertTwitterConnection((Connection<TestTwitterApi>) connectionsForUsers.getFirst("twitter"));
}

private void notifyRocketChat(String callbackUrl, Conversation conversation, String token) {
    if (StringUtils.isBlank(callbackUrl)) return;

    try (CloseableHttpClient httpClient = httpClientBuilder.build()) {
        final HttpPost post = new HttpPost(callbackUrl);
        final MultiValueMap<String, String> props = CollectionUtils.toMultiValueMap(conversation.getMeta().getProperties());
        post.setEntity(new StringEntity(
                toJsonString(new SmartiUpdatePing(conversation.getId(), props.getFirst(ConversationMeta.PROP_CHANNEL_ID), token)),
                ContentType.APPLICATION_JSON
        ));
        httpClient.execute(post, response -> null);
    } catch (IOException e) {
        if (log.isDebugEnabled()) {
            log.error("Callback to Rocket.Chat <{}> failed: {}", callbackUrl, e.getMessage(), e);
        } else {
            log.error("Callback to Rocket.Chat <{}> failed: {}", callbackUrl, e.getMessage());
        }
    }
}

@Test
public void ableToUploadFileWithoutAnnotation() throws IOException {
  String file1Content = "hello world";
  String file2Content = "bonjour";
  String username = "mike";

  MultiValueMap<String, Object> map = new LinkedMultiValueMap<>();
  map.add("file1", new FileSystemResource(newFile(file1Content).getAbsolutePath()));
  map.add("file2", new FileSystemResource(newFile(file2Content).getAbsolutePath()));
  map.add("name", username);

  HttpHeaders headers = new HttpHeaders();
  headers.setContentType(MediaType.MULTIPART_FORM_DATA);
  String result = restTemplate.postForObject(
      codeFirstUrl + "uploadWithoutAnnotation",
      new HttpEntity<>(map, headers),
      String.class);

  assertThat(result, is(file1Content + file2Content + username));
}

@Test
public void ableToPostDate() throws Exception {
  ZonedDateTime date = ZonedDateTime.now().truncatedTo(SECONDS);
  MultiValueMap<String, String> body = new LinkedMultiValueMap<>();
  body.add("date", RestObjectMapper.INSTANCE.convertToString(Date.from(date.toInstant())));

  HttpHeaders headers = new HttpHeaders();
  headers.add(CONTENT_TYPE, APPLICATION_FORM_URLENCODED_VALUE);

  int seconds = 1;
  Date result = restTemplate.postForObject(codeFirstUrl + "addDate?seconds={seconds}",
      new HttpEntity<>(body, headers),
      Date.class,
      seconds);

  assertThat(result, is(Date.from(date.plusSeconds(seconds).toInstant())));
}

public static void main(String[] args) throws Exception {
  RestTemplate template = new RestTemplate();
  template.getMessageConverters().add(new MappingJackson2HttpMessageConverter());
  MultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
  headers.add("X-Tenant-Name", "default");

  RequestEntity<String> requestEntity = new RequestEntity<String>(headers, HttpMethod.GET,
      new URI("http://127.0.0.1:9980/registry/v3/microservices"));
  ResponseEntity<String> stringResponseEntity = template.exchange(requestEntity, String.class);
  System.out.println(stringResponseEntity.getBody());
  ResponseEntity<MicroserviceArray> microseriveResponseEntity = template
      .exchange(requestEntity, MicroserviceArray.class);
  MicroserviceArray microserives = microseriveResponseEntity.getBody();
  System.out.println(microserives.getServices().get(1).getServiceId());

  // instance
  headers.add("X-ConsumerId", microserives.getServices().get(1).getServiceId());
  requestEntity = new RequestEntity<String>(headers, HttpMethod.GET,
      new URI("http://127.0.0.1:9980/registry/v3/microservices/" + microserives.getServices().get(1).getServiceId()
          + "/instances"));
  ResponseEntity<String> microserviceInstanceResponseEntity = template.exchange(requestEntity, String.class);
  System.out.println(microserviceInstanceResponseEntity.getBody());
}

@Override
protected QueryRequest buildSolrRequest(ComponentConfiguration conf, Template intent, Conversation conversation, long offset, int pageSize, MultiValueMap<String, String> queryParams) {
    final ConversationMltQuery mltQuery = buildQuery(conf, intent, conversation);
    if (mltQuery == null) {
        return null;
    }

    final SolrQuery solrQuery = new SolrQuery();
    solrQuery.addField("*").addField("score");
    solrQuery.addFilterQuery(String.format("%s:%s", FIELD_TYPE, TYPE_MESSAGE));
    solrQuery.addFilterQuery(String.format("%s:0",FIELD_MESSAGE_IDX));
    solrQuery.addSort("score", SolrQuery.ORDER.desc).addSort(FIELD_VOTE, SolrQuery.ORDER.desc);

    // #39 - paging
    solrQuery.setStart((int) offset);
    solrQuery.setRows(pageSize);

    //since #46 the client field is used to filter for the current user
    addClientFilter(solrQuery, conversation);

    addPropertyFilters(solrQuery, conversation, conf);

    return new ConversationMltRequest(solrQuery, mltQuery.getContent());

}

/**
 * 
 * 
 * <p><b>200</b> - Success
 * @param model The model parameter
 * @throws RestClientException if an error occurs while attempting to invoke the API
 */
public void apiAuthorizationLoginPost(LoginModel model) throws RestClientException {
    Object postBody = model;

    String path = UriComponentsBuilder.fromPath("/api/authorization/login").build().toUriString();

    final MultiValueMap<String, String> queryParams = new LinkedMultiValueMap<String, String>();
    final HttpHeaders headerParams = new HttpHeaders();
    final MultiValueMap<String, Object> formParams = new LinkedMultiValueMap<String, Object>();

    final String[] accepts = { };
    final List<MediaType> accept = apiClient.selectHeaderAccept(accepts);
    final String[] contentTypes = { 
        "application/json-patch+json", "application/json", "text/json", "application/_*+json"
    };
    final MediaType contentType = apiClient.selectHeaderContentType(contentTypes);

    String[] authNames = new String[] {  };

    ParameterizedTypeReference<Void> returnType = new ParameterizedTypeReference<Void>() {};
    apiClient.invokeAPI(path, HttpMethod.POST, queryParams, postBody, headerParams, formParams, accept, contentType, authNames, returnType);
}

/**
 * Invoke API by sending HTTP request with the given options.
 *
 * @param <T> the return type to use
 * @param path The sub-path of the HTTP URL
 * @param method The request method
 * @param queryParams The query parameters
 * @param body The request body object
 * @param headerParams The header parameters
 * @param formParams The form parameters
 * @param accept The request's Accept header
 * @param contentType The request's Content-Type header
 * @param authNames The authentications to apply
 * @param returnType The return type into which to deserialize the response
 * @return The response body in chosen type
 */
public <T> T invokeAPI(String path, HttpMethod method, MultiValueMap<String, String> queryParams, Object body, HttpHeaders headerParams, MultiValueMap<String, Object> formParams, List<MediaType> accept, MediaType contentType, String[] authNames, ParameterizedTypeReference<T> returnType) throws RestClientException {
    updateParamsForAuth(authNames, queryParams, headerParams);

    final UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(basePath).path(path);
    if (queryParams != null) {
        builder.queryParams(queryParams);
    }

    final BodyBuilder requestBuilder = RequestEntity.method(method, builder.build().toUri());
    if(accept != null) {
        requestBuilder.accept(accept.toArray(new MediaType[accept.size()]));
    }
    if(contentType != null) {
        requestBuilder.contentType(contentType);
    }

    addHeadersToRequest(headerParams, requestBuilder);
    addHeadersToRequest(defaultHeaders, requestBuilder);

    RequestEntity<Object> requestEntity = requestBuilder.body(selectBody(body, formParams, contentType));

    ResponseEntity<T> responseEntity = restTemplate.exchange(requestEntity, returnType);

    statusCode = responseEntity.getStatusCode();
    responseHeaders = responseEntity.getHeaders();

    if (responseEntity.getStatusCode() == HttpStatus.NO_CONTENT) {
        return null;
    } else if (responseEntity.getStatusCode().is2xxSuccessful()) {
        if (returnType == null) {
            return null;
        }
        return responseEntity.getBody();
    } else {
        // The error handler built into the RestTemplate should handle 400 and 500 series errors.
        throw new RestClientException("API returned " + statusCode + " and it wasn't handled by the RestTemplate error handler");
    }
}

@Override
public void applyToParams(MultiValueMap<String, String> queryParams, HttpHeaders headerParams) {
    if (apiKey == null) {
        return;
    }
    String value;
    if (apiKeyPrefix != null) {
        value = apiKeyPrefix + " " + apiKey;
    } else {
        value = apiKey;
    }
    if (location.equals("query")) {
        queryParams.add(paramName, value);
    } else if (location.equals("header")) {
        headerParams.add(paramName, value);
   }
}

@Test
public void shouldRetrieveNewStories() throws Exception{
    Story story = generateStory();
    Geolocation geolocation = new Geolocation();
    geolocation.setLatitude(0);
    geolocation.setLongitude(0);
    MultiValueMap<String,String> params = new LinkedMultiValueMap<>();
    params.add("latitude",String.valueOf(geolocation.getLatitude()));
    params.add("longitude",String.valueOf(geolocation.getLongitude()));

    when(homepageService.retrieveNewStories(anyString(),any(Geolocation.class))).thenReturn(ImmutableList.of(story));

    mockMvc.perform(get("/homepage/retrieveNewStories").params(params).principal(new UserPrincipal("testUserId")))
            .andExpect(status().isOk())
            .andExpect(jsonPath("$[0].id").value(story.getId()));
}

/**
 * Create occurrence.
 *
 * @param occurrence the occurrence
 * @return the occurrence
 */
public Occurrence create(Occurrence occurrence) {
    HttpHeaders headers = new HttpHeaders();
    headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);

    MultiValueMap<String, String> map = new LinkedMultiValueMap<>();
    map.add("message", createMessage(occurrence));
    map.add("link", occurrence.getUrl());
    map.add("place", occurrence.getEvent().flatMap(Event::getLocation).map(Location::getFacebookId).map(String::valueOf).orElse(""));
    map.add("published", "false");
    map.add("scheduled_publish_time", String.valueOf(occurrence.getStartTime().minusHours((int) (Math.random() * 6 + 1)).getMillis() / 1000));

    HttpEntity<MultiValueMap<String, String>> request = new HttpEntity<>(map, headers);

    RestTemplate restTemplate = new RestTemplate();
    ResponseEntity<FacebookPost> response = restTemplate.postForEntity(generateRequestUrl(), request, FacebookPost.class);

    occurrence.setFacebookPostId(response.getBody().getId());
    return occurrence;
}

@Override
public VaultServiceInfo createServiceInfo(String id, String uri) {

    UriComponents uriInfo = UriComponentsBuilder.fromUriString(uri).build();

    String address = UriComponentsBuilder.newInstance() //
            .scheme(uriInfo.getScheme()) //
            .host(uriInfo.getHost()) //
            .port(uriInfo.getPort()) //
            .build().toString();

    MultiValueMap<String, String> queryParams = uriInfo.getQueryParams();

    String token = queryParams.getFirst("token");
    Assert.hasText(token, "Token (token=…) must not be empty");

    Map<String, String> backends = getBackends(queryParams, backendPattern);
    Map<String, String> sharedBackends = getBackends(queryParams,
            sharedBackendPattern);

    return new VaultServiceInfo(id, address, token.toCharArray(), backends,
            sharedBackends);
}

private Map<String, String> getBackends(MultiValueMap<String, String> queryParams,
        Pattern pattern) {

    Map<String, String> backends = new HashMap<String, String>();

    for (Entry<String, List<String>> entry : queryParams.entrySet()) {

        Matcher matcher = pattern.matcher(entry.getKey());
        if (!matcher.find()) {
            continue;
        }

        backends.put(matcher.group(1), queryParams.getFirst(entry.getKey()));
    }

    return backends;
}

@Test
public void validateRecaptcha() throws Exception {
    String url = "http://someurl.com";
    String secret = "shhhhhh";
    String secretFromClient = "SSSSSSSSSSSSHHHH!!!";
    ReflectionTestUtils.setField(sut, "recaptchaUrl", url);
    ReflectionTestUtils.setField(sut, "recaptchaRes", secret);

    ResponseEntity<RecaptchaResponseDTO> responseEntity = mock(ResponseEntity.class);
    RecaptchaResponseDTO dto = mock(RecaptchaResponseDTO.class);

    when(rest.postForEntity(eq(url), any(MultiValueMap.class), eq(RecaptchaResponseDTO.class)))
            .thenReturn(responseEntity);
    when(responseEntity.getBody()).thenReturn(dto);

    RecaptchaResponseDTO response = sut.validateRecaptcha(secretFromClient);

    assertEquals(dto, response);

    ArgumentCaptor<MultiValueMap> captor = ArgumentCaptor.forClass(MultiValueMap.class);
    verify(rest, times(1)).postForEntity(eq(url), captor.capture(), eq(RecaptchaResponseDTO.class));
    MultiValueMap<String, String> body = captor.getValue();

    assertEquals(secretFromClient, body.getFirst("secret"));
    assertEquals(secret, body.getFirst("response"));
}

@Override
public MultiValueMap<String, Connection<?>> findAllConnections() {
    List<SocialConnectionEntity> socialConnections = connectionRepository.findByUserIdOrderByRankAsc(userId);
    MultiValueMap<String, Connection<?>> connections = new LinkedMultiValueMap<>();
    socialConnections.forEach(socialConnection -> {
        Connection<?> connection = connectionMapper.mapRow(socialConnection);
        String providerId = connection.getKey().getProviderId();
        connections.add(providerId, connection);
    });
    return connections;
}

@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public <P extends EasyTransRequest<R, ?>, R extends Serializable> R call(String appId, String busCode, String innerMethod, Map<String,Object> header, P params) {

    String context = properties.getConsumer().get(appId).getContext();
    if(context == null){
        context = "";
    }

    Class<? extends EasyTransRequest> paramsClass = params.getClass();
    Class<?> resultClass = ReflectUtil.getResultClass(paramsClass);


    MultiValueMap<String, String> headers = new HttpHeaders();
    headers.set(RestRibbonEasyTransConstants.HttpHeaderKey.EASYTRANS_HEADER_KEY, encodeEasyTransHeader(header));
    HttpEntity<P> requestEntity = new HttpEntity<>(params, headers);

    ResponseEntity<?> exchangeResult = loadBalancedRestTemplate.exchange("http://" + appId + "/" + context + "/" + busCode + "/" + innerMethod, HttpMethod.POST, requestEntity, resultClass);
    if(!exchangeResult.getStatusCode().is2xxSuccessful()){
        throw new RuntimeException("远程请求发生错误:" + exchangeResult);
    }

    return (R) exchangeResult.getBody();
}

@PostMapping(value = "/signin/{providerId}")
public RedirectView signIn(@PathVariable String providerId, NativeWebRequest request) {
    try {
        ConnectionFactory<?> connectionFactory = connectionFactoryLocator.getConnectionFactory(providerId);
        MultiValueMap<String, String> parameters = new LinkedMultiValueMap<>();
        return redirectAbsolute(connectSupport.buildOAuthUrl(connectionFactory, request, parameters));
    } catch (Exception e) {
        log.error("Exception while building authorization URL: ", e);
        return redirectOnError(providerId);
    }
}

private HttpEntity<String> getRequestEntity(String method, List<Object> params) {
    MultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
    headers.add("Content-Type", "text/plain");

    BitcoinRpcRequest bitcoinRpcRequest = bitcoinRpcRequestFactory.create(method, params);
    String body = objectMapper.writeValueAsString(bitcoinRpcRequest);

    return new HttpEntity<>(body, headers);
}

private String buildOAuth2Url(OAuth2ConnectionFactory<?> connectionFactory, NativeWebRequest request,
    MultiValueMap<String, String> additionalParameters) {
    OAuth2Operations oauthOperations = connectionFactory.getOAuthOperations();
    String defaultScope = connectionFactory.getScope();
    OAuth2Parameters parameters = getOAuth2Parameters(request, defaultScope, additionalParameters);
    String state = connectionFactory.generateState();
    parameters.add("state", state);
    sessionStrategy.setAttribute(request, OAUTH2_STATE_ATTRIBUTE, state);
    return oauthOperations.buildAuthenticateUrl(parameters);
}

public MultiValueMap<String, String> getBody(String authorizationCode) {
    MultiValueMap<String, String> formData = new LinkedMultiValueMap<>();
    formData.add("grant_type", "authorization_code");
    formData.add("scope", "read_profile");
    formData.add("code", authorizationCode);
    formData.add("redirect_uri", "http://localhost:9000/callback");
    return formData;
}

private MultiValueMap<String, BuildArtifact> getBuildArtifactsById(
        List<DeployableArtifact> deployableArtifacts) {
    MultiValueMap<String, BuildArtifact> buildArtifacts = new LinkedMultiValueMap<>();
    deployableArtifacts.forEach((deployableArtifact) -> {
        try {
            String id = getArtifactId(deployableArtifact);
            getBuildArtifact(deployableArtifact).ifPresent(
                    (buildArtifact) -> buildArtifacts.add(id, buildArtifact));
        }
        catch (Exception ex) {
            // Ignore and don't add as a module
        }
    });
    return buildArtifacts;
}

private void writeParts(OutputStream os, MultiValueMap<String, Object> parts, byte[] boundary) throws IOException {
    for (Map.Entry<String, List<Object>> entry : parts.entrySet()) {
        String name = entry.getKey();
        for (Object part : entry.getValue()) {
            if (part != null) {
                writeBoundary(boundary, os);
                HttpEntity<?> entity = getEntity(part);
                writePart(name, entity, os);
                writeNewLine(os);
            }
        }
    }
}

private void download(ArtifactoryServer artifactoryServer,
        MultiValueMap<String, DeployedArtifact> artifactsByRepo, File destination) {
    artifactsByRepo.forEach((repo, artifacts) -> artifacts.forEach((artifact) -> {
        console.log("Downloading {} from {}", artifact.getPath(), repo);
        artifactoryServer.repository(repo).download(artifact, destination);
    }));
}

public void doPost(HttpServletRequest request, HttpServletResponse response)
    throws ServletException, java.io.IOException {
  // Check that we have a file upload request
  boolean isMultipart = ServletFileUpload.isMultipartContent(request);
  if (!isMultipart) {
    return;
  }
  try {
    MultipartHttpServletRequest
        multiRequest =
        new CommonsMultipartResolver().resolveMultipart(request);
    MultiValueMap<String, MultipartFile> fileMap = multiRequest.getMultiFileMap();
    BlobstoreService blobstoreService = AppFactory.get().getBlobstoreService();
    Map<String, String> names = new HashMap<>(1);
    for (String fieldName : fileMap.keySet()) {
      MultipartFile file = fileMap.getFirst(fieldName);
      String fileName = file.getOriginalFilename();
      String contentType = file.getContentType();
      long sizeInBytes = file.getSize();
      String
          blobKey =
          blobstoreService.store(fileName, contentType, sizeInBytes, file.getInputStream());
      names.put(fieldName, blobKey);

    }
    request.getSession().setAttribute("blobs", names);
    RequestDispatcher
        dispatcher =
        getServletContext().getRequestDispatcher(request.getParameter("ru"));
    dispatcher.forward(multiRequest, response);
  } catch (Exception ex) {
    _logger.severe("Upload failed", ex);
  }
}

public AsyncResponseEntity(
        Observable<T> observable
        , MultiValueMap<String
        , String> headers,
        HttpStatus status
        ) {
    this.observable = observable;
    this.headers = headers;
    this.status = status;
}

private void writeMultipart(MultiValueMap<String, Object> parts, HttpOutputMessage outputMessage)
        throws IOException {
    byte[] boundary = generateMultipartBoundary();

    Map<String, String> parameters = Collections.singletonMap("boundary", new String(boundary, "US-ASCII"));
    MediaType contentType = new MediaType(MediaType.MULTIPART_FORM_DATA, parameters);
    outputMessage.getHeaders().setContentType(contentType);

    writeParts(outputMessage.getBody(), parts, boundary);
    writeEnd(boundary, outputMessage.getBody());
}

public void testingOnlyPostEvent ( MultiValueMap<String, String> formParams )
        throws Exception {

    // Support for LT. do not blow through queue
    if ( numSent++ % 1000 == 0 ) {
        logger.info( "Messages sent: " + numSent + " backlog: " + eventPostQueue.size() );
    }

    ThreadPoolExecutor pool = (ThreadPoolExecutor) eventPostPool;
    if ( eventPostQueue.size() > 100 && pool.getCorePoolSize() == 1 ) {
        pool.setCorePoolSize( 6 );
        pool.setMaximumPoolSize( 6 );
    }

    // blocking for testing
    logger.info( "eventPostPool terminated: {}", eventPostPool.isTerminated() );
    Future<String> futureResult = eventPostPool.submit( new EventPostRunnable( lifecycleSettings.getEventUrl(),
        formParams, "test", "test" ) );

    // Non Blocking to test event caching/pooling
    // futureResult.get() ;
}

public AccessToken getAccessToken(){

        MultiValueMap<String,String> params = new LinkedMultiValueMap<>();
        String clientId = graphApiClientProperties.getClientId();
        String clientSecret = graphApiClientProperties.getClientSecret();
        String baseUrl = graphApiClientProperties.getBaseUrl();

        params.add("client_id", clientId);
        params.add("client_secret", clientSecret);
        params.add("resource", baseUrl);
        params.add("grant_type", "client_credentials");
        params.add("scope", "Directory.AccessAsUser.All");

        return restTemplate.postForObject(accessTokenUrl(), params, AccessToken.class);
    }

private void generate(Directory root, File pomFile) {
    String name = StringUtils.getFilename(pomFile.getName());
    String extension = StringUtils.getFilenameExtension(pomFile.getName());
    String prefix = name.substring(0, name.length() - extension.length() - 1);
    File[] files = pomFile.getParentFile().listFiles((f) -> include(f, prefix));
    MultiValueMap<File, MavenCoordinates> coordinates = new LinkedMultiValueMap<>();
    for (File file : files) {
        String rootPath = StringUtils.cleanPath(root.getFile().getPath());
        String relativePath = StringUtils.cleanPath(file.getPath())
                .substring(rootPath.length() + 1);
        coordinates.add(file.getParentFile(),
                MavenCoordinates.fromPath(relativePath));
    }
    coordinates.forEach(this::writeMetadata);
}

private MultiValueMap<String, Object> getBody() {
    MultiValueMap<String, Object> body = new LinkedMultiValueMap<>();
    body.set("grant_type", "password");
    body.set("username", "foo");
    body.set("password", "bar");
    body.set("scope", "read");
    return body;
}

protected void collect(MultiValueMap<String, Object> attributes, String key, List<String> destination) {
    List<?> values = attributes.get(key);
    if (values != null) {
        for (Object value : values) {
            if (value instanceof String[]) {
                Collections.addAll(destination, (String[]) value);
            } else {
                destination.add((String) value);
            }
        }
    }
}

@Test
@SuppressWarnings("unchecked")
public void findAllConnections() {
    connectionFactoryRegistry.addConnectionFactory(new TestTwitterConnectionFactory());
    insertTwitterConnection();
    insertFacebookConnection();
    MultiValueMap<String, Connection<?>> connections = connectionRepository.findAllConnections();
    assertEquals(2, connections.size());
    Connection<TestFacebookApi> facebook = (Connection<TestFacebookApi>) connections.getFirst("facebook");
    assertFacebookConnection(facebook);
    Connection<TestTwitterApi> twitter = (Connection<TestTwitterApi>) connections.getFirst("twitter");
    assertTwitterConnection(twitter);
}

@Test
public void findAllConnectionsMultipleConnectionResults() {
    connectionFactoryRegistry.addConnectionFactory(new TestTwitterConnectionFactory());
    insertTwitterConnection();
    insertFacebookConnection();
    insertFacebookConnection2();
    MultiValueMap<String, Connection<?>> connections = connectionRepository.findAllConnections();
    assertEquals(2, connections.size());
    assertEquals(2, connections.get("facebook").size());
    assertEquals(1, connections.get("twitter").size());
}