Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
package com.seeq.api;
import com.seeq.ApiException;
import com.seeq.ApiClient;
import com.seeq.Configuration;
import com.seeq.model.*;
import com.seeq.Pair;
import javax.ws.rs.core.GenericType;
import javax.ws.rs.ProcessingException;
import com.seeq.model.AddOnToolInputV1;
import com.seeq.model.AddOnToolOutputV1;
import com.seeq.model.AdministratorContactInformationV1;
import com.seeq.model.AgentKeyOutputV1;
import com.seeq.model.ConfigurationInputV1;
import com.seeq.model.ConfigurationOutputV1;
import com.seeq.model.GetAddOnToolsOutputV1;
import com.seeq.model.LicenseImporterOutputV1;
import com.seeq.model.LicenseStatusOutputV1;
import com.seeq.model.SentEmailsListOutputV1;
import com.seeq.model.ServerBuildInfoOutputV1;
import com.seeq.model.ServerLoadOutputV1;
import com.seeq.model.ServerStatusOutputV1;
import com.seeq.model.StatusMessageBase;
import com.seeq.model.SupportedUnitsOutputV1;
import com.seeq.model.UnitsOfMeasureBatchInputV1;
import com.seeq.model.UnitsOfMeasureOutputV1;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class SystemApi {
private ApiClient apiClient;
private long retryTimeout = 5_000; // Default of 5 seconds
public SystemApi() {
this(Configuration.getDefaultApiClient());
}
public SystemApi(ApiClient apiClient) {
this.apiClient = apiClient;
}
public void setRetryTimeout(long retryTimeout) {
this.retryTimeout = retryTimeout;
}
public long getRetryTimeout() {
return this.retryTimeout;
}
public ApiClient getApiClient() {
return apiClient;
}
public void setApiClient(ApiClient apiClient) {
this.apiClient = apiClient;
}
/**
* Create an add-on tool
*
* @param body Add-on tool information (required)
* @return AddOnToolOutputV1
* @throws ApiException if fails to make API call
*/
public AddOnToolOutputV1 createAddOnTool(AddOnToolInputV1 body) throws ApiException {
ApiClient.ApiResponse localVarResponse = createAddOnToolWithHttpInfo(body);
return localVarResponse != null ? localVarResponse.getData() : null;
}
/**
* Create an add-on tool
*
* @param body Add-on tool information (required)
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse createAddOnToolWithHttpInfo(AddOnToolInputV1 body) throws ApiException {
Map localVarHeaderParams = new HashMap();
return createAddOnToolWithHeadersAndHttpInfo(body, localVarHeaderParams);
}
/**
* Create an add-on tool
*
* @param body Add-on tool information (required)
* @param customHeaders a map with custom headers for the HTTP request (required)
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse createAddOnToolWithHeadersAndHttpInfo(AddOnToolInputV1 body, Map customHeaders) throws ApiException {
List localVarQueryParams = new ArrayList();
Map localVarHeaderParams = new HashMap();
localVarHeaderParams.putAll(customHeaders);
return createAddOnToolInternal(body, localVarQueryParams, localVarHeaderParams);
}
private ApiClient.ApiResponse createAddOnToolInternal(AddOnToolInputV1 body, List queryParams, Map headerParams) throws ApiException {
Object localVarPostBody = body;
// verify the required body parameter 'body' is set
if (body == null) {
throw new ApiException(400, "Missing the required body parameter 'body' when calling createAddOnTool");
}
// create path and map variables
String localVarPath = "/system/configuration/addOnTools";
// query params
Map localVarFormParams = new HashMap();
final String[] localVarAccepts = {
"application/vnd.seeq.v1+json"
};
final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);
final String[] localVarContentTypes = {
"application/vnd.seeq.v1+json"
};
final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);
String[] localVarAuthNames = new String[] { "api_key" };
long apiClientInvocationTime = System.currentTimeMillis();
while(true) {
try {
GenericType localVarReturnType = new GenericType() {};
return apiClient.invokeAPIWithHttpInfo(localVarPath, "POST", queryParams, localVarPostBody, headerParams, localVarFormParams, localVarAccept, localVarContentType, localVarAuthNames, localVarReturnType);
// Possible exceptions:
// ===================
// * ResponseProcessingException - in case processing of a received HTTP response fails (e.g. in a filter or
// during conversion of the response entity data to an instance of a particular Java type).
// * ProcessingException - in case the request processing or subsequent I/O operation fails.
// * WebApplicationException - in case the response status code of the response returned by the server is not
// successful and the specified response type is not Response.
// * ApiException for exceptions wrapped by ApiClient. Most likely all WebApplicationException are wrapped
// in ApiException(s)
} catch (ApiException | ProcessingException e) {
if (e instanceof ProcessingException || e instanceof ApiException && ((ApiException) e).getCode() == 504) {
long elapsedTime = System.currentTimeMillis() - apiClientInvocationTime;
if (elapsedTime <= this.retryTimeout && this.retryTimeout != 0) {
continue;
}
}
throw e;
}
} // while
}
/**
* Delete an add-on tool
*
* @param id ID of the add-on to delete (required)
* @return StatusMessageBase
* @throws ApiException if fails to make API call
*/
public StatusMessageBase deleteAddOnTool(String id) throws ApiException {
ApiClient.ApiResponse localVarResponse = deleteAddOnToolWithHttpInfo(id);
return localVarResponse != null ? localVarResponse.getData() : null;
}
/**
* Delete an add-on tool
*
* @param id ID of the add-on to delete (required)
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse deleteAddOnToolWithHttpInfo(String id) throws ApiException {
Map localVarHeaderParams = new HashMap();
return deleteAddOnToolWithHeadersAndHttpInfo(id, localVarHeaderParams);
}
/**
* Delete an add-on tool
*
* @param id ID of the add-on to delete (required)
* @param customHeaders a map with custom headers for the HTTP request (required)
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse deleteAddOnToolWithHeadersAndHttpInfo(String id, Map customHeaders) throws ApiException {
List localVarQueryParams = new ArrayList();
Map localVarHeaderParams = new HashMap();
localVarHeaderParams.putAll(customHeaders);
return deleteAddOnToolInternal(id, localVarQueryParams, localVarHeaderParams);
}
private ApiClient.ApiResponse deleteAddOnToolInternal(String id, List queryParams, Map headerParams) throws ApiException {
Object localVarPostBody = null;
// verify the required path parameter 'id' is set
if (id == null) {
throw new ApiException(400, "Missing the required path parameter 'id' when calling deleteAddOnTool");
}
// create path and map variables
String localVarPath = "/system/configuration/addOnTools/{id}"
.replaceAll("\\{" + "id" + "\\}", apiClient.escapeString(id.toString()));
// query params
Map localVarFormParams = new HashMap();
final String[] localVarAccepts = {
"application/vnd.seeq.v1+json"
};
final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);
final String[] localVarContentTypes = {
};
final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);
String[] localVarAuthNames = new String[] { "api_key" };
long apiClientInvocationTime = System.currentTimeMillis();
while(true) {
try {
GenericType localVarReturnType = new GenericType() {};
return apiClient.invokeAPIWithHttpInfo(localVarPath, "DELETE", queryParams, localVarPostBody, headerParams, localVarFormParams, localVarAccept, localVarContentType, localVarAuthNames, localVarReturnType);
// Possible exceptions:
// ===================
// * ResponseProcessingException - in case processing of a received HTTP response fails (e.g. in a filter or
// during conversion of the response entity data to an instance of a particular Java type).
// * ProcessingException - in case the request processing or subsequent I/O operation fails.
// * WebApplicationException - in case the response status code of the response returned by the server is not
// successful and the specified response type is not Response.
// * ApiException for exceptions wrapped by ApiClient. Most likely all WebApplicationException are wrapped
// in ApiException(s)
} catch (ApiException | ProcessingException e) {
if (e instanceof ProcessingException || e instanceof ApiException && ((ApiException) e).getCode() == 504) {
long elapsedTime = System.currentTimeMillis() - apiClientInvocationTime;
if (elapsedTime <= this.retryTimeout && this.retryTimeout != 0) {
continue;
}
}
throw e;
}
} // while
}
/**
* Disable a licensed feature until the next server shutdown.
*
* @param name The name of the licensed feature (required)
* @throws ApiException if fails to make API call
*/
public void disableLicensedFeature(String name) throws ApiException {
disableLicensedFeatureWithHttpInfo(name);
}
/**
* Disable a licensed feature until the next server shutdown.
*
* @param name The name of the licensed feature (required)
* @throws ApiException if fails to make API call
*/
public void disableLicensedFeatureWithHttpInfo(String name) throws ApiException {
Map localVarHeaderParams = new HashMap();
disableLicensedFeatureWithHeadersAndHttpInfo(name, localVarHeaderParams);
}
/**
* Disable a licensed feature until the next server shutdown.
*
* @param name The name of the licensed feature (required)
* @param customHeaders a map with custom headers for the HTTP request (required)
* @throws ApiException if fails to make API call
*/
public void disableLicensedFeatureWithHeadersAndHttpInfo(String name, Map customHeaders) throws ApiException {
List localVarQueryParams = new ArrayList();
Map localVarHeaderParams = new HashMap();
localVarHeaderParams.putAll(customHeaders);
disableLicensedFeatureInternal(name, localVarQueryParams, localVarHeaderParams);
}
private void disableLicensedFeatureInternal(String name, List queryParams, Map headerParams) throws ApiException {
Object localVarPostBody = null;
// verify the required path parameter 'name' is set
if (name == null) {
throw new ApiException(400, "Missing the required path parameter 'name' when calling disableLicensedFeature");
}
// create path and map variables
String localVarPath = "/system/license/features/{name}"
.replaceAll("\\{" + "name" + "\\}", apiClient.escapeString(name.toString()));
// query params
Map localVarFormParams = new HashMap();
final String[] localVarAccepts = {
"application/vnd.seeq.v1+json"
};
final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);
final String[] localVarContentTypes = {
};
final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);
String[] localVarAuthNames = new String[] { "api_key" };
long apiClientInvocationTime = System.currentTimeMillis();
while(true) {
try {
apiClient.invokeAPIWithHttpInfo(localVarPath, "DELETE", queryParams, localVarPostBody, headerParams, localVarFormParams, localVarAccept, localVarContentType, localVarAuthNames, null);
return;
// Possible exceptions:
// ===================
// * ResponseProcessingException - in case processing of a received HTTP response fails (e.g. in a filter or
// during conversion of the response entity data to an instance of a particular Java type).
// * ProcessingException - in case the request processing or subsequent I/O operation fails.
// * WebApplicationException - in case the response status code of the response returned by the server is not
// successful and the specified response type is not Response.
// * ApiException for exceptions wrapped by ApiClient. Most likely all WebApplicationException are wrapped
// in ApiException(s)
} catch (ApiException | ProcessingException e) {
if (e instanceof ProcessingException || e instanceof ApiException && ((ApiException) e).getCode() == 504) {
long elapsedTime = System.currentTimeMillis() - apiClientInvocationTime;
if (elapsedTime <= this.retryTimeout && this.retryTimeout != 0) {
continue;
}
}
throw e;
}
} // while
}
/**
* Re-enable a licensed feature that was previously disabled. If the feature does not have a valid license or was not previously disabled, this will do nothing.
*
* @param name The name of the licensed feature (required)
* @throws ApiException if fails to make API call
*/
public void enableLicensedFeature(String name) throws ApiException {
enableLicensedFeatureWithHttpInfo(name);
}
/**
* Re-enable a licensed feature that was previously disabled. If the feature does not have a valid license or was not previously disabled, this will do nothing.
*
* @param name The name of the licensed feature (required)
* @throws ApiException if fails to make API call
*/
public void enableLicensedFeatureWithHttpInfo(String name) throws ApiException {
Map localVarHeaderParams = new HashMap();
enableLicensedFeatureWithHeadersAndHttpInfo(name, localVarHeaderParams);
}
/**
* Re-enable a licensed feature that was previously disabled. If the feature does not have a valid license or was not previously disabled, this will do nothing.
*
* @param name The name of the licensed feature (required)
* @param customHeaders a map with custom headers for the HTTP request (required)
* @throws ApiException if fails to make API call
*/
public void enableLicensedFeatureWithHeadersAndHttpInfo(String name, Map customHeaders) throws ApiException {
List localVarQueryParams = new ArrayList();
Map localVarHeaderParams = new HashMap();
localVarHeaderParams.putAll(customHeaders);
enableLicensedFeatureInternal(name, localVarQueryParams, localVarHeaderParams);
}
private void enableLicensedFeatureInternal(String name, List queryParams, Map headerParams) throws ApiException {
Object localVarPostBody = null;
// verify the required path parameter 'name' is set
if (name == null) {
throw new ApiException(400, "Missing the required path parameter 'name' when calling enableLicensedFeature");
}
// create path and map variables
String localVarPath = "/system/license/features/{name}"
.replaceAll("\\{" + "name" + "\\}", apiClient.escapeString(name.toString()));
// query params
Map localVarFormParams = new HashMap();
final String[] localVarAccepts = {
"application/vnd.seeq.v1+json"
};
final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);
final String[] localVarContentTypes = {
"application/vnd.seeq.v1+json"
};
final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);
String[] localVarAuthNames = new String[] { "api_key" };
long apiClientInvocationTime = System.currentTimeMillis();
while(true) {
try {
apiClient.invokeAPIWithHttpInfo(localVarPath, "POST", queryParams, localVarPostBody, headerParams, localVarFormParams, localVarAccept, localVarContentType, localVarAuthNames, null);
return;
// Possible exceptions:
// ===================
// * ResponseProcessingException - in case processing of a received HTTP response fails (e.g. in a filter or
// during conversion of the response entity data to an instance of a particular Java type).
// * ProcessingException - in case the request processing or subsequent I/O operation fails.
// * WebApplicationException - in case the response status code of the response returned by the server is not
// successful and the specified response type is not Response.
// * ApiException for exceptions wrapped by ApiClient. Most likely all WebApplicationException are wrapped
// in ApiException(s)
} catch (ApiException | ProcessingException e) {
if (e instanceof ProcessingException || e instanceof ApiException && ((ApiException) e).getCode() == 504) {
long elapsedTime = System.currentTimeMillis() - apiClientInvocationTime;
if (elapsedTime <= this.retryTimeout && this.retryTimeout != 0) {
continue;
}
}
throw e;
}
} // while
}
/**
* Gets a list of all add-on tools.
*
* @return GetAddOnToolsOutputV1
* @throws ApiException if fails to make API call
*/
public GetAddOnToolsOutputV1 getAddOnTools() throws ApiException {
ApiClient.ApiResponse localVarResponse = getAddOnToolsWithHttpInfo();
return localVarResponse != null ? localVarResponse.getData() : null;
}
/**
* Gets a list of all add-on tools.
*
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getAddOnToolsWithHttpInfo() throws ApiException {
Map localVarHeaderParams = new HashMap();
return getAddOnToolsWithHeadersAndHttpInfo(localVarHeaderParams);
}
/**
* Gets a list of all add-on tools.
*
* @param customHeaders a map with custom headers for the HTTP request (required)
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getAddOnToolsWithHeadersAndHttpInfo(Map customHeaders) throws ApiException {
List localVarQueryParams = new ArrayList();
Map localVarHeaderParams = new HashMap();
localVarHeaderParams.putAll(customHeaders);
return getAddOnToolsInternal(localVarQueryParams, localVarHeaderParams);
}
private ApiClient.ApiResponse getAddOnToolsInternal(List queryParams, Map headerParams) throws ApiException {
Object localVarPostBody = null;
// create path and map variables
String localVarPath = "/system/configuration/addOnTools";
// query params
Map localVarFormParams = new HashMap();
final String[] localVarAccepts = {
"application/vnd.seeq.v1+json"
};
final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);
final String[] localVarContentTypes = {
};
final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);
String[] localVarAuthNames = new String[] { "api_key" };
long apiClientInvocationTime = System.currentTimeMillis();
while(true) {
try {
GenericType localVarReturnType = new GenericType() {};
return apiClient.invokeAPIWithHttpInfo(localVarPath, "GET", queryParams, localVarPostBody, headerParams, localVarFormParams, localVarAccept, localVarContentType, localVarAuthNames, localVarReturnType);
// Possible exceptions:
// ===================
// * ResponseProcessingException - in case processing of a received HTTP response fails (e.g. in a filter or
// during conversion of the response entity data to an instance of a particular Java type).
// * ProcessingException - in case the request processing or subsequent I/O operation fails.
// * WebApplicationException - in case the response status code of the response returned by the server is not
// successful and the specified response type is not Response.
// * ApiException for exceptions wrapped by ApiClient. Most likely all WebApplicationException are wrapped
// in ApiException(s)
} catch (ApiException | ProcessingException e) {
if (e instanceof ProcessingException || e instanceof ApiException && ((ApiException) e).getCode() == 504) {
long elapsedTime = System.currentTimeMillis() - apiClientInvocationTime;
if (elapsedTime <= this.retryTimeout && this.retryTimeout != 0) {
continue;
}
}
throw e;
}
} // while
}
/**
* Get the system administrator's contact information
*
* @return AdministratorContactInformationV1
* @throws ApiException if fails to make API call
*/
public AdministratorContactInformationV1 getAdministratorContactInformation() throws ApiException {
ApiClient.ApiResponse localVarResponse = getAdministratorContactInformationWithHttpInfo();
return localVarResponse != null ? localVarResponse.getData() : null;
}
/**
* Get the system administrator's contact information
*
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getAdministratorContactInformationWithHttpInfo() throws ApiException {
Map localVarHeaderParams = new HashMap();
return getAdministratorContactInformationWithHeadersAndHttpInfo(localVarHeaderParams);
}
/**
* Get the system administrator's contact information
*
* @param customHeaders a map with custom headers for the HTTP request (required)
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getAdministratorContactInformationWithHeadersAndHttpInfo(Map customHeaders) throws ApiException {
List localVarQueryParams = new ArrayList();
Map localVarHeaderParams = new HashMap();
localVarHeaderParams.putAll(customHeaders);
return getAdministratorContactInformationInternal(localVarQueryParams, localVarHeaderParams);
}
private ApiClient.ApiResponse getAdministratorContactInformationInternal(List queryParams, Map headerParams) throws ApiException {
Object localVarPostBody = null;
// create path and map variables
String localVarPath = "/system/contactInformation";
// query params
Map localVarFormParams = new HashMap();
final String[] localVarAccepts = {
"application/vnd.seeq.v1+json"
};
final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);
final String[] localVarContentTypes = {
};
final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);
String[] localVarAuthNames = new String[] { "api_key" };
long apiClientInvocationTime = System.currentTimeMillis();
while(true) {
try {
GenericType localVarReturnType = new GenericType() {};
return apiClient.invokeAPIWithHttpInfo(localVarPath, "GET", queryParams, localVarPostBody, headerParams, localVarFormParams, localVarAccept, localVarContentType, localVarAuthNames, localVarReturnType);
// Possible exceptions:
// ===================
// * ResponseProcessingException - in case processing of a received HTTP response fails (e.g. in a filter or
// during conversion of the response entity data to an instance of a particular Java type).
// * ProcessingException - in case the request processing or subsequent I/O operation fails.
// * WebApplicationException - in case the response status code of the response returned by the server is not
// successful and the specified response type is not Response.
// * ApiException for exceptions wrapped by ApiClient. Most likely all WebApplicationException are wrapped
// in ApiException(s)
} catch (ApiException | ProcessingException e) {
if (e instanceof ProcessingException || e instanceof ApiException && ((ApiException) e).getCode() == 504) {
long elapsedTime = System.currentTimeMillis() - apiClientInvocationTime;
if (elapsedTime <= this.retryTimeout && this.retryTimeout != 0) {
continue;
}
}
throw e;
}
} // while
}
/**
* Used to retrieve the value of the Seeq server agent.key
*
* @return AgentKeyOutputV1
* @throws ApiException if fails to make API call
*/
public AgentKeyOutputV1 getAgentKey() throws ApiException {
ApiClient.ApiResponse localVarResponse = getAgentKeyWithHttpInfo();
return localVarResponse != null ? localVarResponse.getData() : null;
}
/**
* Used to retrieve the value of the Seeq server agent.key
*
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getAgentKeyWithHttpInfo() throws ApiException {
Map localVarHeaderParams = new HashMap();
return getAgentKeyWithHeadersAndHttpInfo(localVarHeaderParams);
}
/**
* Used to retrieve the value of the Seeq server agent.key
*
* @param customHeaders a map with custom headers for the HTTP request (required)
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getAgentKeyWithHeadersAndHttpInfo(Map customHeaders) throws ApiException {
List localVarQueryParams = new ArrayList();
Map localVarHeaderParams = new HashMap();
localVarHeaderParams.putAll(customHeaders);
return getAgentKeyInternal(localVarQueryParams, localVarHeaderParams);
}
private ApiClient.ApiResponse getAgentKeyInternal(List queryParams, Map headerParams) throws ApiException {
Object localVarPostBody = null;
// create path and map variables
String localVarPath = "/system/agentKey";
// query params
Map localVarFormParams = new HashMap();
final String[] localVarAccepts = {
"application/vnd.seeq.v1+json"
};
final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);
final String[] localVarContentTypes = {
};
final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);
String[] localVarAuthNames = new String[] { "api_key" };
long apiClientInvocationTime = System.currentTimeMillis();
while(true) {
try {
GenericType localVarReturnType = new GenericType() {};
return apiClient.invokeAPIWithHttpInfo(localVarPath, "GET", queryParams, localVarPostBody, headerParams, localVarFormParams, localVarAccept, localVarContentType, localVarAuthNames, localVarReturnType);
// Possible exceptions:
// ===================
// * ResponseProcessingException - in case processing of a received HTTP response fails (e.g. in a filter or
// during conversion of the response entity data to an instance of a particular Java type).
// * ProcessingException - in case the request processing or subsequent I/O operation fails.
// * WebApplicationException - in case the response status code of the response returned by the server is not
// successful and the specified response type is not Response.
// * ApiException for exceptions wrapped by ApiClient. Most likely all WebApplicationException are wrapped
// in ApiException(s)
} catch (ApiException | ProcessingException e) {
if (e instanceof ProcessingException || e instanceof ApiException && ((ApiException) e).getCode() == 504) {
long elapsedTime = System.currentTimeMillis() - apiClientInvocationTime;
if (elapsedTime <= this.retryTimeout && this.retryTimeout != 0) {
continue;
}
}
throw e;
}
} // while
}
/**
* Used to determine the precise revision of this Seeq build
*
* @return ServerBuildInfoOutputV1
* @throws ApiException if fails to make API call
*/
public ServerBuildInfoOutputV1 getBuildInfo() throws ApiException {
ApiClient.ApiResponse localVarResponse = getBuildInfoWithHttpInfo();
return localVarResponse != null ? localVarResponse.getData() : null;
}
/**
* Used to determine the precise revision of this Seeq build
*
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getBuildInfoWithHttpInfo() throws ApiException {
Map localVarHeaderParams = new HashMap();
return getBuildInfoWithHeadersAndHttpInfo(localVarHeaderParams);
}
/**
* Used to determine the precise revision of this Seeq build
*
* @param customHeaders a map with custom headers for the HTTP request (required)
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getBuildInfoWithHeadersAndHttpInfo(Map customHeaders) throws ApiException {
List localVarQueryParams = new ArrayList();
Map localVarHeaderParams = new HashMap();
localVarHeaderParams.putAll(customHeaders);
return getBuildInfoInternal(localVarQueryParams, localVarHeaderParams);
}
private ApiClient.ApiResponse getBuildInfoInternal(List queryParams, Map headerParams) throws ApiException {
Object localVarPostBody = null;
// create path and map variables
String localVarPath = "/system/build-info";
// query params
Map localVarFormParams = new HashMap();
final String[] localVarAccepts = {
"application/vnd.seeq.v1+json"
};
final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);
final String[] localVarContentTypes = {
};
final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);
String[] localVarAuthNames = new String[] { "api_key" };
long apiClientInvocationTime = System.currentTimeMillis();
while(true) {
try {
GenericType localVarReturnType = new GenericType() {};
return apiClient.invokeAPIWithHttpInfo(localVarPath, "GET", queryParams, localVarPostBody, headerParams, localVarFormParams, localVarAccept, localVarContentType, localVarAuthNames, localVarReturnType);
// Possible exceptions:
// ===================
// * ResponseProcessingException - in case processing of a received HTTP response fails (e.g. in a filter or
// during conversion of the response entity data to an instance of a particular Java type).
// * ProcessingException - in case the request processing or subsequent I/O operation fails.
// * WebApplicationException - in case the response status code of the response returned by the server is not
// successful and the specified response type is not Response.
// * ApiException for exceptions wrapped by ApiClient. Most likely all WebApplicationException are wrapped
// in ApiException(s)
} catch (ApiException | ProcessingException e) {
if (e instanceof ProcessingException || e instanceof ApiException && ((ApiException) e).getCode() == 504) {
long elapsedTime = System.currentTimeMillis() - apiClientInvocationTime;
if (elapsedTime <= this.retryTimeout && this.retryTimeout != 0) {
continue;
}
}
throw e;
}
} // while
}
/**
* Get the list of configuration options and their details, including the current and default value
*
* @param offset The pagination offset, the index of the first collection item that will be returned in this page of results (optional, default to 0)
* @param limit The pagination limit, the total number of collection items that will be returned in this page of results (optional, default to 40)
* @return ConfigurationOutputV1
* @throws ApiException if fails to make API call
*/
public ConfigurationOutputV1 getConfigurationOptions(Integer offset, Integer limit) throws ApiException {
ApiClient.ApiResponse localVarResponse = getConfigurationOptionsWithHttpInfo(offset, limit);
return localVarResponse != null ? localVarResponse.getData() : null;
}
/**
* Get the list of configuration options and their details, including the current and default value
*
* @param offset The pagination offset, the index of the first collection item that will be returned in this page of results (optional, default to 0)
* @param limit The pagination limit, the total number of collection items that will be returned in this page of results (optional, default to 40)
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getConfigurationOptionsWithHttpInfo(Integer offset, Integer limit) throws ApiException {
Map localVarHeaderParams = new HashMap();
return getConfigurationOptionsWithHeadersAndHttpInfo(offset, limit, localVarHeaderParams);
}
/**
* Get the list of configuration options and their details, including the current and default value
*
* @param offset The pagination offset, the index of the first collection item that will be returned in this page of results (optional, default to 0)
* @param limit The pagination limit, the total number of collection items that will be returned in this page of results (optional, default to 40)
* @param customHeaders a map with custom headers for the HTTP request (required)
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getConfigurationOptionsWithHeadersAndHttpInfo(Integer offset, Integer limit, Map customHeaders) throws ApiException {
List localVarQueryParams = new ArrayList();
Map localVarHeaderParams = new HashMap();
localVarQueryParams.addAll(apiClient.parameterToPairs("", "offset", offset));
localVarQueryParams.addAll(apiClient.parameterToPairs("", "limit", limit));
localVarHeaderParams.putAll(customHeaders);
return getConfigurationOptionsInternal(localVarQueryParams, localVarHeaderParams);
}
private ApiClient.ApiResponse getConfigurationOptionsInternal(List queryParams, Map headerParams) throws ApiException {
Object localVarPostBody = null;
// create path and map variables
String localVarPath = "/system/configuration/options";
// query params
Map localVarFormParams = new HashMap();
final String[] localVarAccepts = {
"application/vnd.seeq.v1+json"
};
final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);
final String[] localVarContentTypes = {
};
final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);
String[] localVarAuthNames = new String[] { "api_key" };
long apiClientInvocationTime = System.currentTimeMillis();
while(true) {
try {
GenericType localVarReturnType = new GenericType() {};
return apiClient.invokeAPIWithHttpInfo(localVarPath, "GET", queryParams, localVarPostBody, headerParams, localVarFormParams, localVarAccept, localVarContentType, localVarAuthNames, localVarReturnType);
// Possible exceptions:
// ===================
// * ResponseProcessingException - in case processing of a received HTTP response fails (e.g. in a filter or
// during conversion of the response entity data to an instance of a particular Java type).
// * ProcessingException - in case the request processing or subsequent I/O operation fails.
// * WebApplicationException - in case the response status code of the response returned by the server is not
// successful and the specified response type is not Response.
// * ApiException for exceptions wrapped by ApiClient. Most likely all WebApplicationException are wrapped
// in ApiException(s)
} catch (ApiException | ProcessingException e) {
if (e instanceof ProcessingException || e instanceof ApiException && ((ApiException) e).getCode() == 504) {
long elapsedTime = System.currentTimeMillis() - apiClientInvocationTime;
if (elapsedTime <= this.retryTimeout && this.retryTimeout != 0) {
continue;
}
}
throw e;
}
} // while
}
/**
* Download installer images
*
* @param fileName The name of the installation image (required)
* @return byte[]
* @throws ApiException if fails to make API call
*/
public byte[] getInstallerFile(String fileName) throws ApiException {
ApiClient.ApiResponse localVarResponse = getInstallerFileWithHttpInfo(fileName);
return localVarResponse != null ? localVarResponse.getData() : null;
}
/**
* Download installer images
*
* @param fileName The name of the installation image (required)
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getInstallerFileWithHttpInfo(String fileName) throws ApiException {
Map localVarHeaderParams = new HashMap();
return getInstallerFileWithHeadersAndHttpInfo(fileName, localVarHeaderParams);
}
/**
* Download installer images
*
* @param fileName The name of the installation image (required)
* @param customHeaders a map with custom headers for the HTTP request (required)
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getInstallerFileWithHeadersAndHttpInfo(String fileName, Map customHeaders) throws ApiException {
List localVarQueryParams = new ArrayList();
Map localVarHeaderParams = new HashMap();
localVarHeaderParams.putAll(customHeaders);
return getInstallerFileInternal(fileName, localVarQueryParams, localVarHeaderParams);
}
private ApiClient.ApiResponse getInstallerFileInternal(String fileName, List queryParams, Map headerParams) throws ApiException {
Object localVarPostBody = null;
// verify the required path parameter 'fileName' is set
if (fileName == null) {
throw new ApiException(400, "Missing the required path parameter 'fileName' when calling getInstallerFile");
}
// create path and map variables
String localVarPath = "/system/installer/{fileName}"
.replaceAll("\\{" + "fileName" + "\\}", apiClient.escapeString(fileName.toString()));
// query params
Map localVarFormParams = new HashMap();
final String[] localVarAccepts = {
"application/gzip", "application/octet-stream", "application/vnd.seeq.v1+json", "application/x-7z-compressed"
};
final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);
final String[] localVarContentTypes = {
};
final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);
String[] localVarAuthNames = new String[] { "api_key" };
long apiClientInvocationTime = System.currentTimeMillis();
while(true) {
try {
GenericType localVarReturnType = new GenericType() {};
return apiClient.invokeAPIWithHttpInfo(localVarPath, "GET", queryParams, localVarPostBody, headerParams, localVarFormParams, localVarAccept, localVarContentType, localVarAuthNames, localVarReturnType);
// Possible exceptions:
// ===================
// * ResponseProcessingException - in case processing of a received HTTP response fails (e.g. in a filter or
// during conversion of the response entity data to an instance of a particular Java type).
// * ProcessingException - in case the request processing or subsequent I/O operation fails.
// * WebApplicationException - in case the response status code of the response returned by the server is not
// successful and the specified response type is not Response.
// * ApiException for exceptions wrapped by ApiClient. Most likely all WebApplicationException are wrapped
// in ApiException(s)
} catch (ApiException | ProcessingException e) {
if (e instanceof ProcessingException || e instanceof ApiException && ((ApiException) e).getCode() == 504) {
long elapsedTime = System.currentTimeMillis() - apiClientInvocationTime;
if (elapsedTime <= this.retryTimeout && this.retryTimeout != 0) {
continue;
}
}
throw e;
}
} // while
}
/**
* Get the current server license, if any
*
* @return LicenseStatusOutputV1
* @throws ApiException if fails to make API call
*/
public LicenseStatusOutputV1 getLicense() throws ApiException {
ApiClient.ApiResponse localVarResponse = getLicenseWithHttpInfo();
return localVarResponse != null ? localVarResponse.getData() : null;
}
/**
* Get the current server license, if any
*
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getLicenseWithHttpInfo() throws ApiException {
Map localVarHeaderParams = new HashMap();
return getLicenseWithHeadersAndHttpInfo(localVarHeaderParams);
}
/**
* Get the current server license, if any
*
* @param customHeaders a map with custom headers for the HTTP request (required)
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getLicenseWithHeadersAndHttpInfo(Map customHeaders) throws ApiException {
List localVarQueryParams = new ArrayList();
Map localVarHeaderParams = new HashMap();
localVarHeaderParams.putAll(customHeaders);
return getLicenseInternal(localVarQueryParams, localVarHeaderParams);
}
private ApiClient.ApiResponse getLicenseInternal(List queryParams, Map headerParams) throws ApiException {
Object localVarPostBody = null;
// create path and map variables
String localVarPath = "/system/license";
// query params
Map localVarFormParams = new HashMap();
final String[] localVarAccepts = {
"application/vnd.seeq.v1+json"
};
final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);
final String[] localVarContentTypes = {
};
final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);
String[] localVarAuthNames = new String[] { "api_key" };
long apiClientInvocationTime = System.currentTimeMillis();
while(true) {
try {
GenericType localVarReturnType = new GenericType() {};
return apiClient.invokeAPIWithHttpInfo(localVarPath, "GET", queryParams, localVarPostBody, headerParams, localVarFormParams, localVarAccept, localVarContentType, localVarAuthNames, localVarReturnType);
// Possible exceptions:
// ===================
// * ResponseProcessingException - in case processing of a received HTTP response fails (e.g. in a filter or
// during conversion of the response entity data to an instance of a particular Java type).
// * ProcessingException - in case the request processing or subsequent I/O operation fails.
// * WebApplicationException - in case the response status code of the response returned by the server is not
// successful and the specified response type is not Response.
// * ApiException for exceptions wrapped by ApiClient. Most likely all WebApplicationException are wrapped
// in ApiException(s)
} catch (ApiException | ProcessingException e) {
if (e instanceof ProcessingException || e instanceof ApiException && ((ApiException) e).getCode() == 504) {
long elapsedTime = System.currentTimeMillis() - apiClientInvocationTime;
if (elapsedTime <= this.retryTimeout && this.retryTimeout != 0) {
continue;
}
}
throw e;
}
} // while
}
/**
* Used to determine server readiness; available without authentication
*
* @return StatusMessageBase
* @throws ApiException if fails to make API call
*/
public StatusMessageBase getOpenPing() throws ApiException {
ApiClient.ApiResponse localVarResponse = getOpenPingWithHttpInfo();
return localVarResponse != null ? localVarResponse.getData() : null;
}
/**
* Used to determine server readiness; available without authentication
*
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getOpenPingWithHttpInfo() throws ApiException {
Map localVarHeaderParams = new HashMap();
return getOpenPingWithHeadersAndHttpInfo(localVarHeaderParams);
}
/**
* Used to determine server readiness; available without authentication
*
* @param customHeaders a map with custom headers for the HTTP request (required)
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getOpenPingWithHeadersAndHttpInfo(Map customHeaders) throws ApiException {
List localVarQueryParams = new ArrayList();
Map localVarHeaderParams = new HashMap();
localVarHeaderParams.putAll(customHeaders);
return getOpenPingInternal(localVarQueryParams, localVarHeaderParams);
}
private ApiClient.ApiResponse getOpenPingInternal(List queryParams, Map headerParams) throws ApiException {
Object localVarPostBody = null;
// create path and map variables
String localVarPath = "/system/open-ping";
// query params
Map localVarFormParams = new HashMap();
final String[] localVarAccepts = {
"application/vnd.seeq.v1+json"
};
final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);
final String[] localVarContentTypes = {
};
final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);
String[] localVarAuthNames = new String[] { "api_key" };
long apiClientInvocationTime = System.currentTimeMillis();
while(true) {
try {
GenericType localVarReturnType = new GenericType() {};
return apiClient.invokeAPIWithHttpInfo(localVarPath, "GET", queryParams, localVarPostBody, headerParams, localVarFormParams, localVarAccept, localVarContentType, localVarAuthNames, localVarReturnType);
// Possible exceptions:
// ===================
// * ResponseProcessingException - in case processing of a received HTTP response fails (e.g. in a filter or
// during conversion of the response entity data to an instance of a particular Java type).
// * ProcessingException - in case the request processing or subsequent I/O operation fails.
// * WebApplicationException - in case the response status code of the response returned by the server is not
// successful and the specified response type is not Response.
// * ApiException for exceptions wrapped by ApiClient. Most likely all WebApplicationException are wrapped
// in ApiException(s)
} catch (ApiException | ProcessingException e) {
if (e instanceof ProcessingException || e instanceof ApiException && ((ApiException) e).getCode() == 504) {
long elapsedTime = System.currentTimeMillis() - apiClientInvocationTime;
if (elapsedTime <= this.retryTimeout && this.retryTimeout != 0) {
continue;
}
}
throw e;
}
} // while
}
/**
* Used to determine server readiness, but only available with authentication
*
* @return StatusMessageBase
* @throws ApiException if fails to make API call
*/
public StatusMessageBase getPing() throws ApiException {
ApiClient.ApiResponse localVarResponse = getPingWithHttpInfo();
return localVarResponse != null ? localVarResponse.getData() : null;
}
/**
* Used to determine server readiness, but only available with authentication
*
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getPingWithHttpInfo() throws ApiException {
Map localVarHeaderParams = new HashMap();
return getPingWithHeadersAndHttpInfo(localVarHeaderParams);
}
/**
* Used to determine server readiness, but only available with authentication
*
* @param customHeaders a map with custom headers for the HTTP request (required)
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getPingWithHeadersAndHttpInfo(Map customHeaders) throws ApiException {
List localVarQueryParams = new ArrayList();
Map localVarHeaderParams = new HashMap();
localVarHeaderParams.putAll(customHeaders);
return getPingInternal(localVarQueryParams, localVarHeaderParams);
}
private ApiClient.ApiResponse getPingInternal(List queryParams, Map headerParams) throws ApiException {
Object localVarPostBody = null;
// create path and map variables
String localVarPath = "/system/ping";
// query params
Map localVarFormParams = new HashMap();
final String[] localVarAccepts = {
"application/vnd.seeq.v1+json"
};
final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);
final String[] localVarContentTypes = {
};
final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);
String[] localVarAuthNames = new String[] { "api_key" };
long apiClientInvocationTime = System.currentTimeMillis();
while(true) {
try {
GenericType localVarReturnType = new GenericType() {};
return apiClient.invokeAPIWithHttpInfo(localVarPath, "GET", queryParams, localVarPostBody, headerParams, localVarFormParams, localVarAccept, localVarContentType, localVarAuthNames, localVarReturnType);
// Possible exceptions:
// ===================
// * ResponseProcessingException - in case processing of a received HTTP response fails (e.g. in a filter or
// during conversion of the response entity data to an instance of a particular Java type).
// * ProcessingException - in case the request processing or subsequent I/O operation fails.
// * WebApplicationException - in case the response status code of the response returned by the server is not
// successful and the specified response type is not Response.
// * ApiException for exceptions wrapped by ApiClient. Most likely all WebApplicationException are wrapped
// in ApiException(s)
} catch (ApiException | ProcessingException e) {
if (e instanceof ProcessingException || e instanceof ApiException && ((ApiException) e).getCode() == 504) {
long elapsedTime = System.currentTimeMillis() - apiClientInvocationTime;
if (elapsedTime <= this.retryTimeout && this.retryTimeout != 0) {
continue;
}
}
throw e;
}
} // while
}
/**
* Get a list of the emails that have been sent by the server in the past 7 days, up to a maximum of 10,000. Note that non-administrators will only see emails from notifications they manage.
*
* @return SentEmailsListOutputV1
* @throws ApiException if fails to make API call
*/
public SentEmailsListOutputV1 getSentEmails() throws ApiException {
ApiClient.ApiResponse localVarResponse = getSentEmailsWithHttpInfo();
return localVarResponse != null ? localVarResponse.getData() : null;
}
/**
* Get a list of the emails that have been sent by the server in the past 7 days, up to a maximum of 10,000. Note that non-administrators will only see emails from notifications they manage.
*
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getSentEmailsWithHttpInfo() throws ApiException {
Map localVarHeaderParams = new HashMap();
return getSentEmailsWithHeadersAndHttpInfo(localVarHeaderParams);
}
/**
* Get a list of the emails that have been sent by the server in the past 7 days, up to a maximum of 10,000. Note that non-administrators will only see emails from notifications they manage.
*
* @param customHeaders a map with custom headers for the HTTP request (required)
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getSentEmailsWithHeadersAndHttpInfo(Map customHeaders) throws ApiException {
List localVarQueryParams = new ArrayList();
Map localVarHeaderParams = new HashMap();
localVarHeaderParams.putAll(customHeaders);
return getSentEmailsInternal(localVarQueryParams, localVarHeaderParams);
}
private ApiClient.ApiResponse getSentEmailsInternal(List queryParams, Map headerParams) throws ApiException {
Object localVarPostBody = null;
// create path and map variables
String localVarPath = "/system/sent-emails";
// query params
Map localVarFormParams = new HashMap();
final String[] localVarAccepts = {
"application/vnd.seeq.v1+json"
};
final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);
final String[] localVarContentTypes = {
};
final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);
String[] localVarAuthNames = new String[] { "api_key" };
long apiClientInvocationTime = System.currentTimeMillis();
while(true) {
try {
GenericType localVarReturnType = new GenericType() {};
return apiClient.invokeAPIWithHttpInfo(localVarPath, "GET", queryParams, localVarPostBody, headerParams, localVarFormParams, localVarAccept, localVarContentType, localVarAuthNames, localVarReturnType);
// Possible exceptions:
// ===================
// * ResponseProcessingException - in case processing of a received HTTP response fails (e.g. in a filter or
// during conversion of the response entity data to an instance of a particular Java type).
// * ProcessingException - in case the request processing or subsequent I/O operation fails.
// * WebApplicationException - in case the response status code of the response returned by the server is not
// successful and the specified response type is not Response.
// * ApiException for exceptions wrapped by ApiClient. Most likely all WebApplicationException are wrapped
// in ApiException(s)
} catch (ApiException | ProcessingException e) {
if (e instanceof ProcessingException || e instanceof ApiException && ((ApiException) e).getCode() == 504) {
long elapsedTime = System.currentTimeMillis() - apiClientInvocationTime;
if (elapsedTime <= this.retryTimeout && this.retryTimeout != 0) {
continue;
}
}
throw e;
}
} // while
}
/**
* Used to determine the current load the server is experiencing, where a high load indicates a lot of concurrent activity within the server.
*
* @return ServerLoadOutputV1
* @throws ApiException if fails to make API call
*/
public ServerLoadOutputV1 getServerLoad() throws ApiException {
ApiClient.ApiResponse localVarResponse = getServerLoadWithHttpInfo();
return localVarResponse != null ? localVarResponse.getData() : null;
}
/**
* Used to determine the current load the server is experiencing, where a high load indicates a lot of concurrent activity within the server.
*
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getServerLoadWithHttpInfo() throws ApiException {
Map localVarHeaderParams = new HashMap();
return getServerLoadWithHeadersAndHttpInfo(localVarHeaderParams);
}
/**
* Used to determine the current load the server is experiencing, where a high load indicates a lot of concurrent activity within the server.
*
* @param customHeaders a map with custom headers for the HTTP request (required)
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getServerLoadWithHeadersAndHttpInfo(Map customHeaders) throws ApiException {
List localVarQueryParams = new ArrayList();
Map localVarHeaderParams = new HashMap();
localVarHeaderParams.putAll(customHeaders);
return getServerLoadInternal(localVarQueryParams, localVarHeaderParams);
}
private ApiClient.ApiResponse getServerLoadInternal(List queryParams, Map headerParams) throws ApiException {
Object localVarPostBody = null;
// create path and map variables
String localVarPath = "/system/server-load";
// query params
Map localVarFormParams = new HashMap();
final String[] localVarAccepts = {
"application/vnd.seeq.v1+json"
};
final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);
final String[] localVarContentTypes = {
};
final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);
String[] localVarAuthNames = new String[] { "api_key" };
long apiClientInvocationTime = System.currentTimeMillis();
while(true) {
try {
GenericType localVarReturnType = new GenericType() {};
return apiClient.invokeAPIWithHttpInfo(localVarPath, "GET", queryParams, localVarPostBody, headerParams, localVarFormParams, localVarAccept, localVarContentType, localVarAuthNames, localVarReturnType);
// Possible exceptions:
// ===================
// * ResponseProcessingException - in case processing of a received HTTP response fails (e.g. in a filter or
// during conversion of the response entity data to an instance of a particular Java type).
// * ProcessingException - in case the request processing or subsequent I/O operation fails.
// * WebApplicationException - in case the response status code of the response returned by the server is not
// successful and the specified response type is not Response.
// * ApiException for exceptions wrapped by ApiClient. Most likely all WebApplicationException are wrapped
// in ApiException(s)
} catch (ApiException | ProcessingException e) {
if (e instanceof ProcessingException || e instanceof ApiException && ((ApiException) e).getCode() == 504) {
long elapsedTime = System.currentTimeMillis() - apiClientInvocationTime;
if (elapsedTime <= this.retryTimeout && this.retryTimeout != 0) {
continue;
}
}
throw e;
}
} // while
}
/**
* Used to determine server readiness, telemetry configuration, and other server variables
*
* @param includeInternal whether to include internal statuses (optional, default to false)
* @return ServerStatusOutputV1
* @throws ApiException if fails to make API call
*/
public ServerStatusOutputV1 getServerStatus(Boolean includeInternal) throws ApiException {
ApiClient.ApiResponse localVarResponse = getServerStatusWithHttpInfo(includeInternal);
return localVarResponse != null ? localVarResponse.getData() : null;
}
/**
* Used to determine server readiness, telemetry configuration, and other server variables
*
* @param includeInternal whether to include internal statuses (optional, default to false)
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getServerStatusWithHttpInfo(Boolean includeInternal) throws ApiException {
Map localVarHeaderParams = new HashMap();
return getServerStatusWithHeadersAndHttpInfo(includeInternal, localVarHeaderParams);
}
/**
* Used to determine server readiness, telemetry configuration, and other server variables
*
* @param includeInternal whether to include internal statuses (optional, default to false)
* @param customHeaders a map with custom headers for the HTTP request (required)
* @throws ApiException if fails to make API call
*/
public ApiClient.ApiResponse getServerStatusWithHeadersAndHttpInfo(Boolean includeInternal, Map customHeaders) throws ApiException {
List localVarQueryParams = new ArrayList
