Java MimeType类代码示例

import org.eclipse.che.ide.MimeType; //导入依赖的package包/类
@Override
public Promise<List<FactoryDto>> findFactory(
    @Nullable Integer skipCount,
    @Nullable Integer maxItems,
    @Nullable List<Pair<String, String>> params) {
  final List<Pair<String, String>> allParams = new LinkedList<>();
  if (params != null) {
    allParams.addAll(params);
  }
  if (maxItems != null) {
    allParams.add(Pair.of("maxItems", maxItems.toString()));
  }
  if (skipCount != null) {
    allParams.add(Pair.of("skipCount", skipCount.toString()));
  }
  return asyncRequestFactory
      .createGetRequest(API_FACTORY_BASE_URL + "find" + queryString(allParams))
      .header(HTTPHeader.ACCEPT, MimeType.APPLICATION_JSON)
      .header(HTTPHeader.CONTENT_TYPE, MimeType.APPLICATION_JSON)
      .loader(loaderFactory.newLoader("Searching factory..."))
      .send(unmarshallerFactory.newListUnmarshaller(FactoryDto.class));
}
 

import org.eclipse.che.ide.MimeType; //导入依赖的package包/类
@Override
public Promise<List<MethodParameters>> getMethodParametersHints(
    String projectPath, String fqn, int offset, int lineStartOffset) {
  String url =
      appContext.getWsAgentServerApiEndpoint()
          + "/java/navigation/parameters"
          + "?projectpath="
          + projectPath
          + "&fqn="
          + fqn
          + "&offset="
          + offset
          + "&lineStart="
          + lineStartOffset;

  return requestFactory
      .createGetRequest(url)
      .header(ACCEPT, MimeType.APPLICATION_JSON)
      .loader(loaderFactory.newLoader("Getting parameters..."))
      .send(unmarshallerFactory.newListUnmarshaller(MethodParameters.class));
}
 

import org.eclipse.che.ide.MimeType; //导入依赖的package包/类
/**
 * Organizes the imports of a compilation unit.
 *
 * @param projectPath path to the project
 * @param fqn fully qualified name of the java file
 */
public Promise<List<Change>> applyChosenImports(
    String projectPath, String fqn, ConflictImportDTO chosen) {
  String url =
      appContext.getWsAgentServerApiEndpoint()
          + CODE_ASSIST_URL_PREFIX
          + "/apply-imports?projectpath="
          + projectPath
          + "&fqn="
          + fqn;
  return asyncRequestFactory
      .createPostRequest(url, chosen)
      .loader(loader)
      .header(CONTENT_TYPE, MimeType.APPLICATION_JSON)
      .send(unmarshallerFactory.newListUnmarshaller(Change.class));
}
 

import org.eclipse.che.ide.MimeType; //导入依赖的package包/类
@Override
protected AsyncRequest doCreateRequest(
    RequestBuilder.Method method, String url, Object dtoBody, boolean async) {
  AsyncRequest request = super.doCreateRequest(method, url, dtoBody, async);
  if (!isWsAgentRequest(url) && !keycloakProvider.isKeycloakDisabled()) {
    AsyncRequest asyncRequest = new KeycloakAsyncRequest(keycloakProvider, method, url, async);
    if (dtoBody != null) {
      if (dtoBody instanceof List<?>) {
        asyncRequest.data(dtoFactory.toJson((List<?>) dtoBody));
      } else if (dtoBody instanceof String) {
        asyncRequest.data((String) dtoBody);
      } else {
        asyncRequest.data(dtoFactory.toJson(dtoBody));
      }
      asyncRequest.header(HTTPHeader.CONTENT_TYPE, MimeType.APPLICATION_JSON);
    } else if (method.equals(RequestBuilder.POST) || method.equals(RequestBuilder.PUT)) {

      /*
        Here we need to setup wildcard mime type in content-type header, because CORS filter
        responses with 403 error in case if user makes POST/PUT request with null body and without
        content-type header. Setting content-type header with wildcard mime type solves this problem.
        Note, this issue need to be investigated, because the problem may be occurred as a bug in
        CORS filter.
      */

      asyncRequest.header(HTTPHeader.CONTENT_TYPE, MimeType.WILDCARD);
    }
    return asyncRequest;
  }
  return request;
}
 

import org.eclipse.che.ide.MimeType; //导入依赖的package包/类
/**
 * Creates new HTTP request to the specified {@code url}.
 *
 * @param method request method
 * @param url request URL
 * @param dtoBody the DTO to send as body of the request. Must implement {@link JsonSerializable}
 *     interface or contain objects that implement it. May be {@code null}.
 * @param async if <b>true</b> - request will be sent in asynchronous mode
 * @return new {@link AsyncRequest} instance to send POST request
 * @throws NullPointerException in case if request {@code method} is {@code null}, reason
 *     includes:
 *     <ul>
 *       <li>Request method should not be a null
 *     </ul>
 */
protected AsyncRequest doCreateRequest(
    RequestBuilder.Method method, String url, Object dtoBody, boolean async) {
  Preconditions.checkNotNull(method, "Request method should not be a null");

  AsyncRequest asyncRequest = newAsyncRequest(method, url, async);
  if (dtoBody != null) {
    if (dtoBody instanceof List) {
      asyncRequest.data(dtoFactory.toJson((List) dtoBody));
    } else if (dtoBody instanceof String) {
      asyncRequest.data((String) dtoBody);
    } else {
      asyncRequest.data(dtoFactory.toJson(dtoBody));
    }
    asyncRequest.header(HTTPHeader.CONTENT_TYPE, DTO_CONTENT_TYPE);
  } else if (method.equals(RequestBuilder.POST) || method.equals(RequestBuilder.PUT)) {

    /*
      Here we need to setup wildcard mime type in content-type header, because CORS filter
      responses with 403 error in case if user makes POST/PUT request with null body and without
      content-type header. Setting content-type header with wildcard mime type solves this problem.

      Note, this issue need to be investigated, because the problem may be occurred as a bug in
      CORS filter.
    */

    asyncRequest.header(HTTPHeader.CONTENT_TYPE, MimeType.WILDCARD);
  }
  return asyncRequest;
}
 

import org.eclipse.che.ide.MimeType; //导入依赖的package包/类
@Inject
public ClipboardButtonBuilderImpl(ZeroClipboardResources res, ZeroClipboardConstant locale) {
  this.res = res;
  promptReadyToCopy = locale.promptReadyToCopy();
  promptAfterCopy = locale.promptAfterCopy();
  promptCopyError = locale.promptCopyError();
  promptReadyToSelect = locale.promptReadyToSelect();
  mimeType = MimeType.TEXT_PLAIN;
}
 

import org.eclipse.che.ide.MimeType; //导入依赖的package包/类
/**
 * Returns the projects list. If there is no projects were found on server, empty list is
 * returned.
 *
 * @return {@link Promise} with list of project configuration
 * @see ProjectConfigDto
 * @since 4.4.0
 */
public Promise<List<ProjectConfigDto>> getProjects() {
  final String url = getBaseUrl();

  return reqFactory
      .createGetRequest(url)
      .header(ACCEPT, MimeType.APPLICATION_JSON)
      .send(unmarshaller.newListUnmarshaller(ProjectConfigDto.class));
}
 

import org.eclipse.che.ide.MimeType; //导入依赖的package包/类
/** Fetch project importers from the server. */
private void fetchProjectImporters(AsyncRequestCallback<ProjectImporterData> callback) {
  asyncRequestFactory
      .createGetRequest(appContext.getWsAgentServerApiEndpoint() + "/project-importers")
      .header(HTTPHeader.CONTENT_TYPE, MimeType.APPLICATION_JSON)
      .send(callback);
}
 

import org.eclipse.che.ide.MimeType; //导入依赖的package包/类
/**
 * Get valid JSON factory object based on input factory ID
 *
 * @param factoryId factory ID to retrieve
 * @param validate indicates whether or not factory should be validated by accept validator
 * @return Factory through a Promise
 */
@Override
public Promise<FactoryDto> getFactory(@NotNull String factoryId, boolean validate) {
  StringBuilder url = new StringBuilder(API_FACTORY_BASE_URL).append(factoryId);
  if (validate) {
    url.append("?").append("validate=true");
  }
  return asyncRequestFactory
      .createGetRequest(url.toString())
      .header(HTTPHeader.ACCEPT, MimeType.APPLICATION_JSON)
      .send(unmarshallerFactory.newUnmarshaller(FactoryDto.class));
}
 

import org.eclipse.che.ide.MimeType; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public void getFactoryJson(
    String workspaceId, String path, AsyncRequestCallback<FactoryDto> callback) {
  final StringBuilder url =
      new StringBuilder(API_FACTORY_BASE_URL + "workspace/").append(workspaceId);
  if (path != null) {
    url.append("?path=").append(path);
  }
  asyncRequestFactory
      .createGetRequest(url.toString())
      .header(HTTPHeader.ACCEPT, MimeType.APPLICATION_JSON)
      .loader(loaderFactory.newLoader("Getting info about factory..."))
      .send(callback);
}
 

import org.eclipse.che.ide.MimeType; //导入依赖的package包/类
@Override
public Promise<FactoryDto> saveFactory(@NotNull FactoryDto factory) {
  return asyncRequestFactory
      .createPostRequest(API_FACTORY_BASE_URL, factory)
      .header(HTTPHeader.ACCEPT, MimeType.APPLICATION_JSON)
      .header(HTTPHeader.CONTENT_TYPE, MimeType.APPLICATION_JSON)
      .loader(loaderFactory.newLoader("Creating factory..."))
      .send(unmarshallerFactory.newUnmarshaller(FactoryDto.class));
}
 

import org.eclipse.che.ide.MimeType; //导入依赖的package包/类
@Override
public Promise<FactoryDto> updateFactory(String id, FactoryDto factory) {
  return asyncRequestFactory
      .createRequest(RequestBuilder.PUT, API_FACTORY_BASE_URL + id, factory, false)
      .header(HTTPHeader.CONTENT_TYPE, MimeType.APPLICATION_JSON)
      .loader(loaderFactory.newLoader("Updating factory..."))
      .send(unmarshallerFactory.newUnmarshaller(FactoryDto.class));
}
 

import org.eclipse.che.ide.MimeType; //导入依赖的package包/类
/**
 * Gets ssh pair of given service and specific name
 *
 * @param service the service name
 * @param name the identifier of one the pair
 */
@Override
public Promise<SshPairDto> getPair(String service, String name) {
  return asyncRequestFactory
      .createGetRequest(sshApi + "/" + service + FIND + "?name=" + name)
      .header(HTTPHeader.ACCEPT, MimeType.APPLICATION_JSON)
      .send(unmarshallerFactory.newUnmarshaller(SshPairDto.class));
}
 

import org.eclipse.che.ide.MimeType; //导入依赖的package包/类
@Override
public Promise<List<SshPairDto>> getPairs(String service) {
  return asyncRequestFactory
      .createGetRequest(sshApi + "/" + service)
      .header(HTTPHeader.ACCEPT, MimeType.APPLICATION_JSON)
      .send(unmarshallerFactory.newListUnmarshaller(SshPairDto.class));
}
 

import org.eclipse.che.ide.MimeType; //导入依赖的package包/类
@Override
public Promise<SshPairDto> generatePair(String service, String name) {
  return asyncRequestFactory
      .createPostRequest(
          sshApi + "/generate",
          dtoFactory.createDto(GenerateSshPairRequest.class).withService(service).withName(name))
      .header(HTTPHeader.ACCEPT, MimeType.APPLICATION_JSON)
      .send(unmarshallerFactory.newUnmarshaller(SshPairDto.class));
}