/// <summary>
/// Get PA groups This endpoint lists all the PA groups that can be applied to a PA calculation.
/// </summary>
/// <exception cref="FactSet.AnalyticsAPI.Engines.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="cancellationToken">Cancellation Token to cancel the request.</param>
/// <returns>Task of ApiResponse of GroupRoot</returns>
public async System.Threading.Tasks.Task <FactSet.AnalyticsAPI.Engines.Client.ApiResponse <GroupRoot> > GetPAGroupsWithHttpInfoAsync(System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken))
{
FactSet.AnalyticsAPI.Engines.Client.RequestOptions localVarRequestOptions = new FactSet.AnalyticsAPI.Engines.Client.RequestOptions();
String[] _contentTypes = new String[] {
};
// to determine the Accept header
String[] _accepts = new String[] {
"application/json"
};
localVarRequestOptions.ResponseReturnTypes = new Dictionary <int, Type>
{
{ 200, typeof(GroupRoot) },
};
var localVarContentType = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
if (localVarContentType != null)
{
localVarRequestOptions.HeaderParameters.Add("Content-Type", localVarContentType);
}
var localVarAccept = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderAccept(_accepts);
if (localVarAccept != null)
{
localVarRequestOptions.HeaderParameters.Add("Accept", localVarAccept);
}
// authentication (Basic) required
// http basic authentication required
if (!String.IsNullOrEmpty(this.Configuration.Username) || !String.IsNullOrEmpty(this.Configuration.Password))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Basic " + FactSet.AnalyticsAPI.Engines.Client.ClientUtils.Base64Encode(this.Configuration.Username + ":" + this.Configuration.Password));
}
// authentication (Bearer) required
// bearer authentication required
if (!String.IsNullOrEmpty(this.Configuration.AccessToken))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Bearer " + this.Configuration.AccessToken);
}
// make the HTTP request
var localVarResponse = await this.AsynchronousClient.GetAsync <GroupRoot>("/analytics/engines/pa/v3/groups", localVarRequestOptions, this.Configuration, cancellationToken).ConfigureAwait(false);
if (this.ExceptionFactory != null)
{
Exception _exception = this.ExceptionFactory("GetPAGroups", localVarResponse);
if (_exception != null)
{
throw _exception;
}
}
return(localVarResponse);
}
/// <summary>
/// Get PA columns This endpoint lists all the PA columns that can be applied to a calculation.
/// </summary>
/// <exception cref="FactSet.AnalyticsAPI.Engines.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="name">Column name (optional, default to "")</param>
/// <param name="category">Column category (optional, default to "")</param>
/// <param name="directory">The directory to get the columns in (optional, default to "")</param>
/// <returns>ApiResponse of Dictionary<string, ColumnSummary></returns>
public FactSet.AnalyticsAPI.Engines.Client.ApiResponse <Dictionary <string, ColumnSummary> > GetPAColumnsWithHttpInfo(string name = default(string), string category = default(string), string directory = default(string))
{
FactSet.AnalyticsAPI.Engines.Client.RequestOptions localVarRequestOptions = new FactSet.AnalyticsAPI.Engines.Client.RequestOptions();
String[] _contentTypes = new String[] {
};
// to determine the Accept header
String[] _accepts = new String[] {
"application/json"
};
var localVarContentType = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
if (localVarContentType != null)
{
localVarRequestOptions.HeaderParameters.Add("Content-Type", localVarContentType);
}
var localVarAccept = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderAccept(_accepts);
if (localVarAccept != null)
{
localVarRequestOptions.HeaderParameters.Add("Accept", localVarAccept);
}
if (name != null)
{
localVarRequestOptions.QueryParameters.Add(FactSet.AnalyticsAPI.Engines.Client.ClientUtils.ParameterToMultiMap("", "name", name));
}
if (category != null)
{
localVarRequestOptions.QueryParameters.Add(FactSet.AnalyticsAPI.Engines.Client.ClientUtils.ParameterToMultiMap("", "category", category));
}
if (directory != null)
{
localVarRequestOptions.QueryParameters.Add(FactSet.AnalyticsAPI.Engines.Client.ClientUtils.ParameterToMultiMap("", "directory", directory));
}
// authentication (Basic) required
// http basic authentication required
if (!String.IsNullOrEmpty(this.Configuration.Username) || !String.IsNullOrEmpty(this.Configuration.Password))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Basic " + FactSet.AnalyticsAPI.Engines.Client.ClientUtils.Base64Encode(this.Configuration.Username + ":" + this.Configuration.Password));
}
// make the HTTP request
var localVarResponse = this.Client.Get <Dictionary <string, ColumnSummary> >("/analytics/lookups/v2/engines/pa/columns", localVarRequestOptions, this.Configuration);
if (this.ExceptionFactory != null)
{
Exception _exception = this.ExceptionFactory("GetPAColumns", localVarResponse);
if (_exception != null)
{
throw _exception;
}
}
return(localVarResponse);
}
/// <summary>
/// Run FIAB calculation This endpoint creates a new FIAB calculation. This must be used first before get status or cancelling endpoints with a calculation id. A successful response will contain the URL to check the status of the calculation request. Remarks: * Any settings in POST body will act as a one-time override over the settings saved in the FIAB template.
/// </summary>
/// <exception cref="FactSet.AnalyticsAPI.Engines.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="fIABCalculationParameters"> (optional)</param>
/// <returns>ApiResponse of Object(null)</returns>
public FactSet.AnalyticsAPI.Engines.Client.ApiResponse <object> RunCalculationWithHttpInfo(FIABCalculationParameters fIABCalculationParameters = default(FIABCalculationParameters))
{
FactSet.AnalyticsAPI.Engines.Client.RequestOptions localVarRequestOptions = new FactSet.AnalyticsAPI.Engines.Client.RequestOptions();
String[] _contentTypes = new String[] {
"application/json"
};
// to determine the Accept header
String[] _accepts = new String[] {
};
localVarRequestOptions.ResponseReturnTypes = new Dictionary <int, Type>
{
};
var localVarContentType = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
if (localVarContentType != null)
{
localVarRequestOptions.HeaderParameters.Add("Content-Type", localVarContentType);
}
var localVarAccept = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderAccept(_accepts);
if (localVarAccept != null)
{
localVarRequestOptions.HeaderParameters.Add("Accept", localVarAccept);
}
localVarRequestOptions.Data = fIABCalculationParameters;
// authentication (Basic) required
// http basic authentication required
if (!String.IsNullOrEmpty(this.Configuration.Username) || !String.IsNullOrEmpty(this.Configuration.Password))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Basic " + FactSet.AnalyticsAPI.Engines.Client.ClientUtils.Base64Encode(this.Configuration.Username + ":" + this.Configuration.Password));
}
// authentication (Bearer) required
// bearer authentication required
if (!String.IsNullOrEmpty(this.Configuration.AccessToken))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Bearer " + this.Configuration.AccessToken);
}
// make the HTTP request
var localVarResponse = this.Client.Post <object>("/analytics/engines/fiab/v1/calculations", localVarRequestOptions, this.Configuration);
if (this.ExceptionFactory != null)
{
Exception _exception = this.ExceptionFactory("RunCalculation", localVarResponse);
if (_exception != null)
{
throw _exception;
}
}
return(localVarResponse);
}
/// <summary>
/// Get currencies This endpoint lists all the currencies that can be applied to any calculation.
/// </summary>
/// <exception cref="FactSet.AnalyticsAPI.Engines.Client.ApiException">Thrown when fails to make API call</exception>
/// <returns>ApiResponse of CurrencyRoot</returns>
public FactSet.AnalyticsAPI.Engines.Client.ApiResponse <CurrencyRoot> GetCurrenciesWithHttpInfo()
{
FactSet.AnalyticsAPI.Engines.Client.RequestOptions localVarRequestOptions = new FactSet.AnalyticsAPI.Engines.Client.RequestOptions();
String[] _contentTypes = new String[] {
};
// to determine the Accept header
String[] _accepts = new String[] {
"application/json"
};
localVarRequestOptions.ResponseReturnTypes = new Dictionary <int, Type>
{
{ 200, typeof(CurrencyRoot) },
};
var localVarContentType = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
if (localVarContentType != null)
{
localVarRequestOptions.HeaderParameters.Add("Content-Type", localVarContentType);
}
var localVarAccept = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderAccept(_accepts);
if (localVarAccept != null)
{
localVarRequestOptions.HeaderParameters.Add("Accept", localVarAccept);
}
// authentication (Basic) required
// http basic authentication required
if (!String.IsNullOrEmpty(this.Configuration.Username) || !String.IsNullOrEmpty(this.Configuration.Password))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Basic " + FactSet.AnalyticsAPI.Engines.Client.ClientUtils.Base64Encode(this.Configuration.Username + ":" + this.Configuration.Password));
}
// authentication (Bearer) required
// bearer authentication required
if (!String.IsNullOrEmpty(this.Configuration.AccessToken))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Bearer " + this.Configuration.AccessToken);
}
// make the HTTP request
var localVarResponse = this.Client.Get <CurrencyRoot>("/analytics/lookups/v3/currencies", localVarRequestOptions, this.Configuration);
if (this.ExceptionFactory != null)
{
Exception _exception = this.ExceptionFactory("GetCurrencies", localVarResponse);
if (_exception != null)
{
throw _exception;
}
}
return(localVarResponse);
}
/// <summary>
/// Get by Url This function can be used to fetch data from any GET endpoint.
/// </summary>
/// <exception cref="FactSet.AnalyticsAPI.Engines.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="url">Url of the GET endpoint</param>
/// <returns>ApiResponse of string</returns>
public FactSet.AnalyticsAPI.Engines.Client.ApiResponse <string> GetByUrlWithHttpInfo(string url)
{
// verify the required parameter 'url' is set
if (url == null)
{
throw new FactSet.AnalyticsAPI.Engines.Client.ApiException(400, "Missing required parameter 'url' when calling UtilityApi->GetByUrl");
}
FactSet.AnalyticsAPI.Engines.Client.RequestOptions localVarRequestOptions = new FactSet.AnalyticsAPI.Engines.Client.RequestOptions();
String[] _contentTypes = new String[] {
};
// to determine the Accept header
String[] _accepts = new String[] {
"text/plain",
"application/json",
"text/json"
};
var localVarContentType = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
if (localVarContentType != null)
{
localVarRequestOptions.HeaderParameters.Add("Content-Type", localVarContentType);
}
var localVarAccept = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderAccept(_accepts);
if (localVarAccept != null)
{
localVarRequestOptions.HeaderParameters.Add("Accept", localVarAccept);
}
// authentication (Basic) required
// http basic authentication required
if (!String.IsNullOrEmpty(this.Configuration.Username) || !String.IsNullOrEmpty(this.Configuration.Password))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Basic " + FactSet.AnalyticsAPI.Engines.Client.ClientUtils.Base64Encode(this.Configuration.Username + ":" + this.Configuration.Password));
}
// make the HTTP request
// trimming the url as it already contains the basepath in it
url = url.Contains(this.Configuration.BasePath) ? url.Replace(this.Configuration.BasePath, string.Empty) : url;
var localVarResponse = this.Client.Get <string>(url, localVarRequestOptions, this.Configuration);
if (this.ExceptionFactory != null)
{
Exception _exception = this.ExceptionFactory("GetByUrl", localVarResponse);
if (_exception != null)
{
throw _exception;
}
}
return(localVarResponse);
}
/// <summary>
/// Get PA column settings This endpoint returns the default settings of a PA column.
/// </summary>
/// <exception cref="FactSet.AnalyticsAPI.Engines.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="id">Unique identifier for a column</param>
/// <returns>ApiResponse of Column</returns>
public FactSet.AnalyticsAPI.Engines.Client.ApiResponse <Column> GetPAColumnByIdWithHttpInfo(string id)
{
// verify the required parameter 'id' is set
if (id == null)
{
throw new FactSet.AnalyticsAPI.Engines.Client.ApiException(400, "Missing required parameter 'id' when calling ColumnsApi->GetPAColumnById");
}
FactSet.AnalyticsAPI.Engines.Client.RequestOptions localVarRequestOptions = new FactSet.AnalyticsAPI.Engines.Client.RequestOptions();
String[] _contentTypes = new String[] {
};
// to determine the Accept header
String[] _accepts = new String[] {
"application/json"
};
var localVarContentType = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
if (localVarContentType != null)
{
localVarRequestOptions.HeaderParameters.Add("Content-Type", localVarContentType);
}
var localVarAccept = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderAccept(_accepts);
if (localVarAccept != null)
{
localVarRequestOptions.HeaderParameters.Add("Accept", localVarAccept);
}
localVarRequestOptions.PathParameters.Add("id", FactSet.AnalyticsAPI.Engines.Client.ClientUtils.ParameterToString(id)); // path parameter
// authentication (Basic) required
// http basic authentication required
if (!String.IsNullOrEmpty(this.Configuration.Username) || !String.IsNullOrEmpty(this.Configuration.Password))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Basic " + FactSet.AnalyticsAPI.Engines.Client.ClientUtils.Base64Encode(this.Configuration.Username + ":" + this.Configuration.Password));
}
// make the HTTP request
var localVarResponse = this.Client.Get <Column>("/analytics/lookups/v2/engines/pa/columns/{id}", localVarRequestOptions, this.Configuration);
if (this.ExceptionFactory != null)
{
Exception _exception = this.ExceptionFactory("GetPAColumnById", localVarResponse);
if (_exception != null)
{
throw _exception;
}
}
return(localVarResponse);
}
/// <summary>
/// Get Vault configurations This endpoint returns all the Vault configurations saved in the provided account.
/// </summary>
/// <exception cref="FactSet.AnalyticsAPI.Engines.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="account">Required account query parameter to filter configurations for a specific account</param>
/// <returns>ApiResponse of Dictionary<string, VaultConfigurationSummary></returns>
public FactSet.AnalyticsAPI.Engines.Client.ApiResponse <Dictionary <string, VaultConfigurationSummary> > GetVaultConfigurationsWithHttpInfo(string account)
{
// verify the required parameter 'account' is set
if (account == null)
{
throw new FactSet.AnalyticsAPI.Engines.Client.ApiException(400, "Missing required parameter 'account' when calling ConfigurationsApi->GetVaultConfigurations");
}
FactSet.AnalyticsAPI.Engines.Client.RequestOptions localVarRequestOptions = new FactSet.AnalyticsAPI.Engines.Client.RequestOptions();
String[] _contentTypes = new String[] {
};
// to determine the Accept header
String[] _accepts = new String[] {
"application/json"
};
var localVarContentType = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
if (localVarContentType != null)
{
localVarRequestOptions.HeaderParameters.Add("Content-Type", localVarContentType);
}
var localVarAccept = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderAccept(_accepts);
if (localVarAccept != null)
{
localVarRequestOptions.HeaderParameters.Add("Accept", localVarAccept);
}
localVarRequestOptions.QueryParameters.Add(FactSet.AnalyticsAPI.Engines.Client.ClientUtils.ParameterToMultiMap("", "account", account));
// authentication (Basic) required
// http basic authentication required
if (!String.IsNullOrEmpty(this.Configuration.Username) || !String.IsNullOrEmpty(this.Configuration.Password))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Basic " + FactSet.AnalyticsAPI.Engines.Client.ClientUtils.Base64Encode(this.Configuration.Username + ":" + this.Configuration.Password));
}
// make the HTTP request
var localVarResponse = this.Client.Get <Dictionary <string, VaultConfigurationSummary> >("/analytics/lookups/v2/engines/vault/configurations", localVarRequestOptions, this.Configuration);
if (this.ExceptionFactory != null)
{
Exception _exception = this.ExceptionFactory("GetVaultConfigurations", localVarResponse);
if (_exception != null)
{
throw _exception;
}
}
return(localVarResponse);
}
/// <summary>
/// Get calculation status by id This is the endpoint to check on the progress of a previous calculation request. Response body contains status information of the entire request and each individual calculation unit.
/// </summary>
/// <exception cref="FactSet.AnalyticsAPI.Engines.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="id">From url, provided from the location header in the Run Multiple Calculations endpoint.</param>
/// <returns>Task of ApiResponse (CalculationStatus)</returns>
public async System.Threading.Tasks.Task <FactSet.AnalyticsAPI.Engines.Client.ApiResponse <CalculationStatus> > GetCalculationStatusByIdAsyncWithHttpInfo(string id)
{
// verify the required parameter 'id' is set
if (id == null)
{
throw new FactSet.AnalyticsAPI.Engines.Client.ApiException(400, "Missing required parameter 'id' when calling CalculationsApi->GetCalculationStatusById");
}
FactSet.AnalyticsAPI.Engines.Client.RequestOptions localVarRequestOptions = new FactSet.AnalyticsAPI.Engines.Client.RequestOptions();
String[] _contentTypes = new String[] {
};
// to determine the Accept header
String[] _accepts = new String[] {
"application/json"
};
foreach (var _contentType in _contentTypes)
{
localVarRequestOptions.HeaderParameters.Add("Content-Type", _contentType);
}
foreach (var _accept in _accepts)
{
localVarRequestOptions.HeaderParameters.Add("Accept", _accept);
}
localVarRequestOptions.PathParameters.Add("id", FactSet.AnalyticsAPI.Engines.Client.ClientUtils.ParameterToString(id)); // path parameter
// authentication (Basic) required
// http basic authentication required
if (!String.IsNullOrEmpty(this.Configuration.Username) || !String.IsNullOrEmpty(this.Configuration.Password))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Basic " + FactSet.AnalyticsAPI.Engines.Client.ClientUtils.Base64Encode(this.Configuration.Username + ":" + this.Configuration.Password));
}
// make the HTTP request
var localVarResponse = await this.AsynchronousClient.GetAsync <CalculationStatus>("/analytics/engines/v2/calculations/{id}", localVarRequestOptions, this.Configuration);
if (this.ExceptionFactory != null)
{
Exception _exception = this.ExceptionFactory("GetCalculationStatusById", localVarResponse);
if (_exception != null)
{
throw _exception;
}
}
return(localVarResponse);
}
/// <summary>
/// Get by Url This function can be used to fetch data from any GET endpoint.
/// </summary>
/// <exception cref="FactSet.AnalyticsAPI.Engines.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="url">Url of the GET endpoint</param>
/// <returns>Task of ApiResponse(string)</returns>
public async System.Threading.Tasks.Task <FactSet.AnalyticsAPI.Engines.Client.ApiResponse <string> > GetByUrlAsyncWithHttpInfo(string url)
{
// verify the required parameter 'url' is set
if (url == null)
{
throw new FactSet.AnalyticsAPI.Engines.Client.ApiException(400, "Missing required parameter 'url' when calling ->GetByUrl");
}
FactSet.AnalyticsAPI.Engines.Client.RequestOptions localVarRequestOptions = new FactSet.AnalyticsAPI.Engines.Client.RequestOptions();
String[] _contentTypes = new String[] {
};
// to determine the Accept header
String[] _accepts = new String[] {
"application/json;text/plain;text/json"
};
foreach (var contentType in _contentTypes)
{
localVarRequestOptions.HeaderParameters.Add("Content-Type", contentType);
}
foreach (var accept in _accepts)
{
localVarRequestOptions.HeaderParameters.Add("Accept", accept);
}
// authentication (Basic) required
// http basic authentication required
if (!String.IsNullOrEmpty(this.Configuration.Username) || !String.IsNullOrEmpty(this.Configuration.Password))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Basic " + FactSet.AnalyticsAPI.Engines.Client.ClientUtils.Base64Encode(this.Configuration.Username + ":" + this.Configuration.Password));
}
// make the HTTP request
var localVarResponse = await this.AsynchronousClient.GetAsync <string>(url, localVarRequestOptions, this.Configuration);
if (this.ExceptionFactory != null)
{
Exception _exception = this.ExceptionFactory("GetByUrl", localVarResponse);
if (_exception != null)
{
throw _exception;
}
}
return(localVarResponse);
}
/// <summary>
/// Get all calculation statuses This endpoints returns all active calculation requests.
/// </summary>
/// <exception cref="FactSet.AnalyticsAPI.Engines.Client.ApiException">Thrown when fails to make API call</exception>
/// <returns>ApiResponse of Dictionary<string, CalculationStatusSummary></returns>
public FactSet.AnalyticsAPI.Engines.Client.ApiResponse <Dictionary <string, CalculationStatusSummary> > GetCalculationStatusSummariesWithHttpInfo()
{
FactSet.AnalyticsAPI.Engines.Client.RequestOptions localVarRequestOptions = new FactSet.AnalyticsAPI.Engines.Client.RequestOptions();
String[] _contentTypes = new String[] {
};
// to determine the Accept header
String[] _accepts = new String[] {
"application/json"
};
var localVarContentType = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
if (localVarContentType != null)
{
localVarRequestOptions.HeaderParameters.Add("Content-Type", localVarContentType);
}
var localVarAccept = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderAccept(_accepts);
if (localVarAccept != null)
{
localVarRequestOptions.HeaderParameters.Add("Accept", localVarAccept);
}
// authentication (Basic) required
// http basic authentication required
if (!String.IsNullOrEmpty(this.Configuration.Username) || !String.IsNullOrEmpty(this.Configuration.Password))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Basic " + FactSet.AnalyticsAPI.Engines.Client.ClientUtils.Base64Encode(this.Configuration.Username + ":" + this.Configuration.Password));
}
// make the HTTP request
var localVarResponse = this.Client.Get <Dictionary <string, CalculationStatusSummary> >("/analytics/engines/v2/calculations", localVarRequestOptions, this.Configuration);
if (this.ExceptionFactory != null)
{
Exception _exception = this.ExceptionFactory("GetCalculationStatusSummaries", localVarResponse);
if (_exception != null)
{
throw _exception;
}
}
return(localVarResponse);
}
/// <summary>
/// Run Vault Calculation This endpoint runs the Vault calculation specified in the POST body parameters. It must be used first before polling or cancelling endpoints. A successful response will contain the URL to poll for the result of the calculation. Remarks: * Start and and end date must be within the configuration's min and max date range
/// </summary>
/// <exception cref="FactSet.AnalyticsAPI.Engines.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="vaultCalculationParameters"> (optional)</param>
/// <returns>Task of ApiResponse (Object)</returns>
public async System.Threading.Tasks.Task <FactSet.AnalyticsAPI.Engines.Client.ApiResponse <Object> > RunVaultCalculationAsyncWithHttpInfo(VaultCalculationParameters vaultCalculationParameters = default(VaultCalculationParameters))
{
FactSet.AnalyticsAPI.Engines.Client.RequestOptions localVarRequestOptions = new FactSet.AnalyticsAPI.Engines.Client.RequestOptions();
String[] _contentTypes = new String[] {
"application/json"
};
// to determine the Accept header
String[] _accepts = new String[] {
"application/json"
};
foreach (var _contentType in _contentTypes)
{
localVarRequestOptions.HeaderParameters.Add("Content-Type", _contentType);
}
foreach (var _accept in _accepts)
{
localVarRequestOptions.HeaderParameters.Add("Accept", _accept);
}
localVarRequestOptions.Data = vaultCalculationParameters;
// authentication (Basic) required
// http basic authentication required
if (!String.IsNullOrEmpty(this.Configuration.Username) || !String.IsNullOrEmpty(this.Configuration.Password))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Basic " + FactSet.AnalyticsAPI.Engines.Client.ClientUtils.Base64Encode(this.Configuration.Username + ":" + this.Configuration.Password));
}
// make the HTTP request
var localVarResponse = await this.AsynchronousClient.PostAsync <Object>("/analytics/engines/vault/v2/calculations", localVarRequestOptions, this.Configuration);
if (this.ExceptionFactory != null)
{
Exception _exception = this.ExceptionFactory("RunVaultCalculation", localVarResponse);
if (_exception != null)
{
throw _exception;
}
}
return(localVarResponse);
}
/// <summary>
/// Get PA column statistics This endpoint lists all the column statistics that can be applied to a PA column.
/// </summary>
/// <exception cref="FactSet.AnalyticsAPI.Engines.Client.ApiException">Thrown when fails to make API call</exception>
/// <returns>Task of ApiResponse (Dictionary<string, ColumnStatistic>)</returns>
public async System.Threading.Tasks.Task <FactSet.AnalyticsAPI.Engines.Client.ApiResponse <Dictionary <string, ColumnStatistic> > > GetPAColumnStatisticsAsyncWithHttpInfo()
{
FactSet.AnalyticsAPI.Engines.Client.RequestOptions localVarRequestOptions = new FactSet.AnalyticsAPI.Engines.Client.RequestOptions();
String[] _contentTypes = new String[] {
};
// to determine the Accept header
String[] _accepts = new String[] {
"application/json"
};
foreach (var _contentType in _contentTypes)
{
localVarRequestOptions.HeaderParameters.Add("Content-Type", _contentType);
}
foreach (var _accept in _accepts)
{
localVarRequestOptions.HeaderParameters.Add("Accept", _accept);
}
// authentication (Basic) required
// http basic authentication required
if (!String.IsNullOrEmpty(this.Configuration.Username) || !String.IsNullOrEmpty(this.Configuration.Password))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Basic " + FactSet.AnalyticsAPI.Engines.Client.ClientUtils.Base64Encode(this.Configuration.Username + ":" + this.Configuration.Password));
}
// make the HTTP request
var localVarResponse = await this.AsynchronousClient.GetAsync <Dictionary <string, ColumnStatistic> >("/analytics/lookups/v2/engines/pa/columnstatistics", localVarRequestOptions, this.Configuration);
if (this.ExceptionFactory != null)
{
Exception _exception = this.ExceptionFactory("GetPAColumnStatistics", localVarResponse);
if (_exception != null)
{
throw _exception;
}
}
return(localVarResponse);
}
/// <summary>
/// Get Vault documents and sub-directories in a directory This endpoint looks up all Vault documents and sub-directories in a given directory.
/// </summary>
/// <exception cref="FactSet.AnalyticsAPI.Engines.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="path">The directory to get the documents in</param>
/// <returns>Task of ApiResponse (DocumentDirectories)</returns>
public async System.Threading.Tasks.Task<FactSet.AnalyticsAPI.Engines.Client.ApiResponse<DocumentDirectories>> GetVaultDocumentsAsyncWithHttpInfo (string path)
{
// verify the required parameter 'path' is set
if (path == null)
throw new FactSet.AnalyticsAPI.Engines.Client.ApiException(400, "Missing required parameter 'path' when calling DocumentsApi->GetVaultDocuments");
FactSet.AnalyticsAPI.Engines.Client.RequestOptions localVarRequestOptions = new FactSet.AnalyticsAPI.Engines.Client.RequestOptions();
String[] _contentTypes = new String[] {
};
// to determine the Accept header
String[] _accepts = new String[] {
"application/json"
};
foreach (var _contentType in _contentTypes)
localVarRequestOptions.HeaderParameters.Add("Content-Type", _contentType);
foreach (var _accept in _accepts)
localVarRequestOptions.HeaderParameters.Add("Accept", _accept);
localVarRequestOptions.PathParameters.Add("path", FactSet.AnalyticsAPI.Engines.Client.ClientUtils.ParameterToString(path)); // path parameter
// authentication (Basic) required
// http basic authentication required
if (!String.IsNullOrEmpty(this.Configuration.Username) || !String.IsNullOrEmpty(this.Configuration.Password))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Basic " + FactSet.AnalyticsAPI.Engines.Client.ClientUtils.Base64Encode(this.Configuration.Username + ":" + this.Configuration.Password));
}
// make the HTTP request
var localVarResponse = await this.AsynchronousClient.GetAsync<DocumentDirectories>("/analytics/lookups/v2/engines/vault/documents/{path}", localVarRequestOptions, this.Configuration);
if (this.ExceptionFactory != null)
{
Exception _exception = this.ExceptionFactory("GetVaultDocuments", localVarResponse);
if (_exception != null) throw _exception;
}
return localVarResponse;
}
/// <summary>
/// Get FIAB calculation by id This is the endpoint to check on the progress of a previously requested calculation.
/// </summary>
/// <exception cref="FactSet.AnalyticsAPI.Engines.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="id">from url, provided from the location header in the Run FIAB Calculation endpoint</param>
/// <returns>ApiResponse of FIABCalculationStatus</returns>
public FactSet.AnalyticsAPI.Engines.Client.ApiResponse <FIABCalculationStatus> GetCalculationByIdWithHttpInfo(string id)
{
// verify the required parameter 'id' is set
if (id == null)
{
throw new FactSet.AnalyticsAPI.Engines.Client.ApiException(400, "Missing required parameter 'id' when calling FIABCalculationsApi->GetCalculationById");
}
FactSet.AnalyticsAPI.Engines.Client.RequestOptions localVarRequestOptions = new FactSet.AnalyticsAPI.Engines.Client.RequestOptions();
String[] _contentTypes = new String[] {
};
// to determine the Accept header
String[] _accepts = new String[] {
"application/json"
};
localVarRequestOptions.ResponseReturnTypes = new Dictionary <int, Type>
{
{ 200, typeof(FIABCalculationStatus) },
{ 202, typeof(FIABCalculationStatus) },
};
var localVarContentType = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
if (localVarContentType != null)
{
localVarRequestOptions.HeaderParameters.Add("Content-Type", localVarContentType);
}
var localVarAccept = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderAccept(_accepts);
if (localVarAccept != null)
{
localVarRequestOptions.HeaderParameters.Add("Accept", localVarAccept);
}
localVarRequestOptions.PathParameters.Add("id", FactSet.AnalyticsAPI.Engines.Client.ClientUtils.ParameterToString(id)); // path parameter
// authentication (Basic) required
// http basic authentication required
if (!String.IsNullOrEmpty(this.Configuration.Username) || !String.IsNullOrEmpty(this.Configuration.Password))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Basic " + FactSet.AnalyticsAPI.Engines.Client.ClientUtils.Base64Encode(this.Configuration.Username + ":" + this.Configuration.Password));
}
// authentication (Bearer) required
// bearer authentication required
if (!String.IsNullOrEmpty(this.Configuration.AccessToken))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Bearer " + this.Configuration.AccessToken);
}
// make the HTTP request
var localVarResponse = this.Client.Get <FIABCalculationStatus>("/analytics/engines/fiab/v1/calculations/{id}", localVarRequestOptions, this.Configuration);
if (this.ExceptionFactory != null)
{
Exception _exception = this.ExceptionFactory("GetCalculationById", localVarResponse);
if (_exception != null)
{
throw _exception;
}
}
return(localVarResponse);
}
/// <summary>
/// Convert Vault dates to absolute format This endpoint converts the given start and end dates in FactSet date format to yyyymmdd format for a Vault calculation. For more information on FactSet date format, please refer to the Vault API documentation under the 'API Documentation' section in the developer portal.
/// </summary>
/// <exception cref="FactSet.AnalyticsAPI.Engines.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="enddate">End Date</param>
/// <param name="componentid">Vault Component Id</param>
/// <param name="account">Account</param>
/// <param name="startdate">Start Date (optional)</param>
/// <returns>Task of ApiResponse (DateParametersSummary)</returns>
public async System.Threading.Tasks.Task <FactSet.AnalyticsAPI.Engines.Client.ApiResponse <DateParametersSummary> > ConvertVaultDatesToAbsoluteFormatAsyncWithHttpInfo(string enddate, string componentid, string account, string startdate = default(string))
{
// verify the required parameter 'enddate' is set
if (enddate == null)
{
throw new FactSet.AnalyticsAPI.Engines.Client.ApiException(400, "Missing required parameter 'enddate' when calling DatesApi->ConvertVaultDatesToAbsoluteFormat");
}
// verify the required parameter 'componentid' is set
if (componentid == null)
{
throw new FactSet.AnalyticsAPI.Engines.Client.ApiException(400, "Missing required parameter 'componentid' when calling DatesApi->ConvertVaultDatesToAbsoluteFormat");
}
// verify the required parameter 'account' is set
if (account == null)
{
throw new FactSet.AnalyticsAPI.Engines.Client.ApiException(400, "Missing required parameter 'account' when calling DatesApi->ConvertVaultDatesToAbsoluteFormat");
}
FactSet.AnalyticsAPI.Engines.Client.RequestOptions localVarRequestOptions = new FactSet.AnalyticsAPI.Engines.Client.RequestOptions();
String[] _contentTypes = new String[] {
};
// to determine the Accept header
String[] _accepts = new String[] {
"application/json"
};
foreach (var _contentType in _contentTypes)
{
localVarRequestOptions.HeaderParameters.Add("Content-Type", _contentType);
}
foreach (var _accept in _accepts)
{
localVarRequestOptions.HeaderParameters.Add("Accept", _accept);
}
if (startdate != null)
{
localVarRequestOptions.QueryParameters.Add(FactSet.AnalyticsAPI.Engines.Client.ClientUtils.ParameterToMultiMap("", "startdate", startdate));
}
localVarRequestOptions.QueryParameters.Add(FactSet.AnalyticsAPI.Engines.Client.ClientUtils.ParameterToMultiMap("", "enddate", enddate));
localVarRequestOptions.QueryParameters.Add(FactSet.AnalyticsAPI.Engines.Client.ClientUtils.ParameterToMultiMap("", "componentid", componentid));
localVarRequestOptions.QueryParameters.Add(FactSet.AnalyticsAPI.Engines.Client.ClientUtils.ParameterToMultiMap("", "account", account));
// authentication (Basic) required
// http basic authentication required
if (!String.IsNullOrEmpty(this.Configuration.Username) || !String.IsNullOrEmpty(this.Configuration.Password))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Basic " + FactSet.AnalyticsAPI.Engines.Client.ClientUtils.Base64Encode(this.Configuration.Username + ":" + this.Configuration.Password));
}
// make the HTTP request
var localVarResponse = await this.AsynchronousClient.GetAsync <DateParametersSummary>("/analytics/lookups/v2/engines/vault/dates", localVarRequestOptions, this.Configuration);
if (this.ExceptionFactory != null)
{
Exception _exception = this.ExceptionFactory("ConvertVaultDatesToAbsoluteFormat", localVarResponse);
if (_exception != null)
{
throw _exception;
}
}
return(localVarResponse);
}
/// <summary>
/// Convert Vault dates to absolute format This endpoint converts the given start and end dates in FactSet date format to yyyymmdd format for a Vault calculation. For more information on FactSet date format, please refer to the Vault API documentation under the 'API Documentation' section in the developer portal.
/// </summary>
/// <exception cref="FactSet.AnalyticsAPI.Engines.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="enddate">End Date</param>
/// <param name="componentid">Vault Component Id</param>
/// <param name="account">Account</param>
/// <param name="startdate">Start Date (optional)</param>
/// <param name="cancellationToken">Cancellation Token to cancel the request.</param>
/// <returns>Task of ApiResponse of DateParametersSummaryRoot</returns>
public async System.Threading.Tasks.Task <FactSet.AnalyticsAPI.Engines.Client.ApiResponse <DateParametersSummaryRoot> > ConvertVaultDatesToAbsoluteFormatWithHttpInfoAsync(string enddate, string componentid, string account, string startdate = default(string), System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken))
{
// verify the required parameter 'enddate' is set
if (enddate == null)
{
throw new FactSet.AnalyticsAPI.Engines.Client.ApiException(400, "Missing required parameter 'enddate' when calling DatesApi->ConvertVaultDatesToAbsoluteFormat");
}
// verify the required parameter 'componentid' is set
if (componentid == null)
{
throw new FactSet.AnalyticsAPI.Engines.Client.ApiException(400, "Missing required parameter 'componentid' when calling DatesApi->ConvertVaultDatesToAbsoluteFormat");
}
// verify the required parameter 'account' is set
if (account == null)
{
throw new FactSet.AnalyticsAPI.Engines.Client.ApiException(400, "Missing required parameter 'account' when calling DatesApi->ConvertVaultDatesToAbsoluteFormat");
}
FactSet.AnalyticsAPI.Engines.Client.RequestOptions localVarRequestOptions = new FactSet.AnalyticsAPI.Engines.Client.RequestOptions();
String[] _contentTypes = new String[] {
};
// to determine the Accept header
String[] _accepts = new String[] {
"application/json"
};
localVarRequestOptions.ResponseReturnTypes = new Dictionary <int, Type>
{
{ 200, typeof(DateParametersSummaryRoot) },
{ 400, typeof(ClientErrorResponse) },
{ 404, typeof(ClientErrorResponse) },
};
var localVarContentType = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
if (localVarContentType != null)
{
localVarRequestOptions.HeaderParameters.Add("Content-Type", localVarContentType);
}
var localVarAccept = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderAccept(_accepts);
if (localVarAccept != null)
{
localVarRequestOptions.HeaderParameters.Add("Accept", localVarAccept);
}
if (startdate != null)
{
localVarRequestOptions.QueryParameters.Add(FactSet.AnalyticsAPI.Engines.Client.ClientUtils.ParameterToMultiMap("", "startdate", startdate));
}
localVarRequestOptions.QueryParameters.Add(FactSet.AnalyticsAPI.Engines.Client.ClientUtils.ParameterToMultiMap("", "enddate", enddate));
localVarRequestOptions.QueryParameters.Add(FactSet.AnalyticsAPI.Engines.Client.ClientUtils.ParameterToMultiMap("", "componentid", componentid));
localVarRequestOptions.QueryParameters.Add(FactSet.AnalyticsAPI.Engines.Client.ClientUtils.ParameterToMultiMap("", "account", account));
// authentication (Basic) required
// http basic authentication required
if (!String.IsNullOrEmpty(this.Configuration.Username) || !String.IsNullOrEmpty(this.Configuration.Password))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Basic " + FactSet.AnalyticsAPI.Engines.Client.ClientUtils.Base64Encode(this.Configuration.Username + ":" + this.Configuration.Password));
}
// authentication (Bearer) required
// bearer authentication required
if (!String.IsNullOrEmpty(this.Configuration.AccessToken))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Bearer " + this.Configuration.AccessToken);
}
// make the HTTP request
var localVarResponse = await this.AsynchronousClient.GetAsync <DateParametersSummaryRoot>("/analytics/engines/vault/v3/dates", localVarRequestOptions, this.Configuration, cancellationToken).ConfigureAwait(false);
if (this.ExceptionFactory != null)
{
Exception _exception = this.ExceptionFactory("ConvertVaultDatesToAbsoluteFormat", localVarResponse);
if (_exception != null)
{
throw _exception;
}
}
return(localVarResponse);
}
/// <summary>
/// Get SPAR account returns type details This endpoint returns the returns type of account associated with SPAR
/// </summary>
/// <exception cref="FactSet.AnalyticsAPI.Engines.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="accountPath">URL encoded account path</param>
/// <returns>ApiResponse of SPARAccountsRoot</returns>
public FactSet.AnalyticsAPI.Engines.Client.ApiResponse <SPARAccountsRoot> GetSPARReturnsTypeWithHttpInfo(string accountPath)
{
// verify the required parameter 'accountPath' is set
if (accountPath == null)
{
throw new FactSet.AnalyticsAPI.Engines.Client.ApiException(400, "Missing required parameter 'accountPath' when calling AccountsApi->GetSPARReturnsType");
}
FactSet.AnalyticsAPI.Engines.Client.RequestOptions localVarRequestOptions = new FactSet.AnalyticsAPI.Engines.Client.RequestOptions();
String[] _contentTypes = new String[] {
};
// to determine the Accept header
String[] _accepts = new String[] {
"application/json"
};
localVarRequestOptions.ResponseReturnTypes = new Dictionary <int, Type>
{
{ 200, typeof(SPARAccountsRoot) },
{ 400, typeof(ClientErrorResponse) },
{ 404, typeof(ClientErrorResponse) },
};
var localVarContentType = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
if (localVarContentType != null)
{
localVarRequestOptions.HeaderParameters.Add("Content-Type", localVarContentType);
}
var localVarAccept = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderAccept(_accepts);
if (localVarAccept != null)
{
localVarRequestOptions.HeaderParameters.Add("Accept", localVarAccept);
}
localVarRequestOptions.PathParameters.Add("accountPath", FactSet.AnalyticsAPI.Engines.Client.ClientUtils.ParameterToString(accountPath)); // path parameter
// authentication (Basic) required
// http basic authentication required
if (!String.IsNullOrEmpty(this.Configuration.Username) || !String.IsNullOrEmpty(this.Configuration.Password))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Basic " + FactSet.AnalyticsAPI.Engines.Client.ClientUtils.Base64Encode(this.Configuration.Username + ":" + this.Configuration.Password));
}
// authentication (Bearer) required
// bearer authentication required
if (!String.IsNullOrEmpty(this.Configuration.AccessToken))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Bearer " + this.Configuration.AccessToken);
}
// make the HTTP request
var localVarResponse = this.Client.Get <SPARAccountsRoot>("/analytics/engines/spar/v3/accounts/{accountPath}/returns-type", localVarRequestOptions, this.Configuration);
if (this.ExceptionFactory != null)
{
Exception _exception = this.ExceptionFactory("GetSPARReturnsType", localVarResponse);
if (_exception != null)
{
throw _exception;
}
}
return(localVarResponse);
}
/// <summary>
/// Get SPAR benchmark details This endpoint returns the details of a given SPAR benchmark identifier.
/// </summary>
/// <exception cref="FactSet.AnalyticsAPI.Engines.Client.ApiException">Thrown when fails to make API call</exception>
/// <param name="id">Benchmark Identifier</param>
/// <param name="cancellationToken">Cancellation Token to cancel the request.</param>
/// <returns>Task of ApiResponse of SPARBenchmarkRoot</returns>
public async System.Threading.Tasks.Task <FactSet.AnalyticsAPI.Engines.Client.ApiResponse <SPARBenchmarkRoot> > GetSPARBenchmarkByIdWithHttpInfoAsync(string id, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken))
{
// verify the required parameter 'id' is set
if (id == null)
{
throw new FactSet.AnalyticsAPI.Engines.Client.ApiException(400, "Missing required parameter 'id' when calling BenchmarksApi->GetSPARBenchmarkById");
}
FactSet.AnalyticsAPI.Engines.Client.RequestOptions localVarRequestOptions = new FactSet.AnalyticsAPI.Engines.Client.RequestOptions();
String[] _contentTypes = new String[] {
};
// to determine the Accept header
String[] _accepts = new String[] {
"application/json"
};
localVarRequestOptions.ResponseReturnTypes = new Dictionary <int, Type>
{
{ 200, typeof(SPARBenchmarkRoot) },
{ 400, typeof(ClientErrorResponse) },
{ 404, typeof(ClientErrorResponse) },
};
var localVarContentType = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderContentType(_contentTypes);
if (localVarContentType != null)
{
localVarRequestOptions.HeaderParameters.Add("Content-Type", localVarContentType);
}
var localVarAccept = FactSet.AnalyticsAPI.Engines.Client.ClientUtils.SelectHeaderAccept(_accepts);
if (localVarAccept != null)
{
localVarRequestOptions.HeaderParameters.Add("Accept", localVarAccept);
}
localVarRequestOptions.QueryParameters.Add(FactSet.AnalyticsAPI.Engines.Client.ClientUtils.ParameterToMultiMap("", "id", id));
// authentication (Basic) required
// http basic authentication required
if (!String.IsNullOrEmpty(this.Configuration.Username) || !String.IsNullOrEmpty(this.Configuration.Password))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Basic " + FactSet.AnalyticsAPI.Engines.Client.ClientUtils.Base64Encode(this.Configuration.Username + ":" + this.Configuration.Password));
}
// authentication (Bearer) required
// bearer authentication required
if (!String.IsNullOrEmpty(this.Configuration.AccessToken))
{
localVarRequestOptions.HeaderParameters.Add("Authorization", "Bearer " + this.Configuration.AccessToken);
}
// make the HTTP request
var localVarResponse = await this.AsynchronousClient.GetAsync <SPARBenchmarkRoot>("/analytics/engines/spar/v3/benchmarks", localVarRequestOptions, this.Configuration, cancellationToken).ConfigureAwait(false);
if (this.ExceptionFactory != null)
{
Exception _exception = this.ExceptionFactory("GetSPARBenchmarkById", localVarResponse);
if (_exception != null)
{
throw _exception;
}
}
return(localVarResponse);
}