/// <summary>
/// Delete the recurring transfer of a savings goal
/// </summary>
/// <param name="accountUid">Required parameter: Account uid</param>
/// <param name="savingsGoalUid">Required parameter: Savings goal uid</param>
/// <return>Returns the void response from the API call</return>
public async Task DeleteRecurringTransferAsync(Guid accountUid, Guid savingsGoalUid)
{
//the base uri for api requests
var baseUri = Configuration.GetBaseURI();
//prepare query string for API call
var queryBuilder = new StringBuilder(baseUri);
queryBuilder.Append("/api/v2/account/{accountUid}/savings-goals/{savingsGoalUid}/recurring-transfer");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(queryBuilder, new Dictionary <string, object>
{
{ "accountUid", accountUid },
{ "savingsGoalUid", savingsGoalUid }
});
//validate and preprocess url
var queryUrl = APIHelper.CleanUrl(queryBuilder);
//append request with appropriate headers and parameters
var headers = APIHelper.GetRequestHeaders(true, true);
//prepare the API call request to fetch the response
var request = ClientInstance.Delete(queryUrl, headers, null);
//invoke request and get response
var response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(request).ConfigureAwait(false);
var context = new HTTPContext(request, response);
//handle errors
ValidateResponse(response, context);
}
/// <summary>
/// Update an IP Address in the Blacklist
/// </summary>
/// <param name="entryId">Required parameter: a unique identifier for the IP Address; opaque but likely a GUID</param>
/// <param name="body">Required parameter: Example: </param>
/// <return>Returns the Models.UpdateResponse response from the API call</return>
public async Task <Models.UpdateResponse> UpdateAsync(string entryId, Models.IPAddress body)
{
//the base uri for api requests
string _baseUri = Configuration.GetBaseURI();
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/v1.1/blacklists/ipaddresses/{entry_id}/update");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "entry_id", entryId }
});
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "APIMATIC 2.0" },
{ "accept", "application/json" },
{ "content-type", "application/json; charset=utf-8" }
};
//append body params
var _body = APIHelper.JsonSerialize(body);
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.PutBody(_queryUrl, _headers, _body);
//Custom Authentication to be added for authorization
AuthUtility.AppendCustomAuthParams(_request);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
//Error handling using HTTP status codes
if (_response.StatusCode == 400)
{
throw new ReturnException(@"Unexpected error in API call. See HTTP response body for details.", _context);
}
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <Models.UpdateResponse>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// Gets the URL for a particular alias in the current environment and appends it with template parameters
/// </summary>
/// <param name="alias">Default value:DEFAULT</param>
/// <return>Returns the baseurl</return>
internal static string GetBaseURI(Servers alias = Servers.DEFAULT)
{
StringBuilder Url = new StringBuilder(EnvironmentsMap[Environment][alias]);
APIHelper.AppendUrlWithTemplateParameters(Url, GetBaseURIParameters());
return(Url.ToString());
}
/// <summary>
/// Gets the URL for a particular alias in the current environment and appends it with template parameters
/// </summary>
/// <return>Returns the baseurl</return>
internal static string GetBaseURI()
{
var url = new StringBuilder("https://gateway.trulioo.com");
APIHelper.AppendUrlWithTemplateParameters(url, GetBaseURIParameters());
return(url.ToString());
}
/// <summary>
/// Get list of options and their details for a specific style ID
/// </summary>
/// <param name="callback">Required parameter: The callback function that the JSON response will be wrapped in if desired</param>
/// <param name="category">Required parameter: Option category (Acceptable values are: "", "Interior", "Exterior", "Roof", "Interior Trim", "Mechanical", "Package", "Additional Fees", "Other")</param>
/// <param name="fmt">Required parameter: Response format (json only) (Acceptable values are: "json")</param>
/// <param name="id">Required parameter: Edmunds vehicle style ID</param>
/// <return>Returns the dynamic response from the API call</return>
public async Task <dynamic> GetOptionsAsync(
string callback,
string category,
string fmt,
string id)
{
//the base uri for api requestss
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/api/vehicle/v2/styles/{id}/options");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "id", id }
});
//process optional query parameters
APIHelper.AppendUrlWithQueryParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "callback", callback },
{ "category", category },
{ "fmt", fmt },
{ "api_key", Configuration.ApiKey }
});
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "APIMATIC 2.0" },
{ "accept", "application/json" }
};
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.Get(_queryUrl, _headers);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request);
HttpContext _context = new HttpContext(_request, _response);
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <dynamic>(_response.Body));
}
catch (Exception ex)
{
throw new APIException("Failed to parse the response: " + ex.Message, _context);
}
}
/// <summary>
/// Use this endpoint to remove an E911 record.
/// </summary>
/// <param name="e911Id">Required parameter: The id of the E911 record to remove.</param>
/// <return>Returns the string response from the API call</return>
public async Task <string> DeleteE911Async(string e911Id)
{
//the base uri for api requests
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/v2/e911s/{e911_id}");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "e911_id", e911Id }
});
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "APIMATIC 2.0" },
{ "content-type", "text/plain; charset=utf-8" }
};
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.Delete(_queryUrl, _headers, null, Configuration.BasicAuthUserName, Configuration.BasicAuthPassword);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
//Error handling using HTTP status codes
if (_response.StatusCode == 401)
{
throw new ErrorException(@"Unauthorized – There was an issue with your API credentials.", _context);
}
if (_response.StatusCode == 404)
{
throw new ErrorException(@"The specified resource was not found", _context);
}
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(_response.Body);
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// TODO: type endpoint description here
/// </summary>
/// <param name="strings">Required parameter: Example: </param>
/// <return>Returns the EchoResponse response from the API call</return>
public async Task <EchoResponse> SendStringArrayAsync(List <string> strings)
{
//validating required parameters
if (null == strings)
{
throw new ArgumentNullException("strings", "The parameter \"strings\" is a required parameter and cannot be null.");
}
//the base uri for api requestss
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/{strings}");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "strings", strings }
});
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "Stamplay SDK" },
{ "accept", "application/json" }
};
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.Get(_queryUrl, _headers);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request);
HttpContext _context = new HttpContext(_request, _response);
//return null on 404
if (_response.StatusCode == 404)
{
return(null);
}
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <EchoResponse>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// Retrieves a list of accounts for a given customer
/// </summary>
/// <param name="customerIdentifier">Required parameter: Customer Identifier</param>
/// <return>Returns the List<Models.AccountSummaryModel> response from the API call</return>
public async Task <List <Models.AccountSummaryModel> > GetAccountsByCustomerAsync(string customerIdentifier)
{
//validating required parameters
if (null == customerIdentifier)
{
throw new ArgumentNullException("customerIdentifier", "The parameter \"customerIdentifier\" is a required parameter and cannot be null.");
}
//the base uri for api requests
string _baseUri = Configuration.GetBaseURI();
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/customers/{customerIdentifier}/accounts");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "customerIdentifier", customerIdentifier }
});
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "V2NGSDK" },
{ "accept", "application/json" }
};
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.Get(_queryUrl, _headers, Configuration.PlatformName, Configuration.PlatformKey);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
//Error handling using HTTP status codes
if ((_response.StatusCode < 200) || (_response.StatusCode > 208)) //[200,208] = HTTP OK
{
throw new RaasGenericException(@"API Error", _context);
}
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <List <Models.AccountSummaryModel> >(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// Get a list of existing keywords.
/// </summary>
/// <param name="format">Required parameter: Response format e.g. json or xml</param>
/// <param name="number">Optional parameter: Filter the list by virtual number</param>
/// <param name="page">Optional parameter: Page number, for pagination</param>
/// <param name="max">Optional parameter: Maximum results returned per page</param>
/// <return>Returns the dynamic response from the API call</return>
public async Task <dynamic> GetKeywordsAsync(
string format,
string number = null,
string page = null,
string max = null)
{
//the base uri for api requests
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/get-keywords.{format}");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "format", format }
});
//process optional query parameters
APIHelper.AppendUrlWithQueryParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "number", number },
{ "page", page },
{ "max", max }
}, ArrayDeserializationFormat, ParameterSeparator);
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "APIMATIC 2.0" },
{ "accept", "application/json" }
};
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.Get(_queryUrl, _headers, Configuration.Apikey, Configuration.Apisecret);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <dynamic>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// Delete or Merge Sub account
/// </summary>
/// <param name="CreateDeleteMergeSubAccountInput">Object containing request parameters</param>
/// <return>Returns the string response from the API call</return>
public async Task <string> CreateDeleteMergeSubAccountAsync(CreateDeleteMergeSubAccountInput input)
{
//validating required parameters
if (null == input.Subaccountsid)
{
throw new ArgumentNullException("subaccountsid", "The property \"Subaccountsid\" in the input object cannot be null.");
}
//the base uri for api requestss
string _baseUri = Configuration.GetBaseURI();
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/user/deletesubaccount.{ResponseType}");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "ResponseType", input.ResponseType }
});
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "message360-api" }
};
//append form/field parameters
var _fields = new Dictionary <string, object>()
{
{ "subaccountsid", input.Subaccountsid },
{ "mergenumber", (int)(input.Mergenumber) }
};
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.Post(_queryUrl, _headers, _fields, Configuration.BasicAuthUserName, Configuration.BasicAuthPassword);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(_response.Body);
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// Calling this method will perform a verification. If your account includes address cleansing set the CleansedAddress flag to get
/// additional address information in the result. You can query configuration to get what fields are available to you in each country.
/// It is also possible to get sample requests from the customer portal. If you are configured for a sandbox account make sure to call Get Test Entities to get test data for a country you want to try. Sandbox accounts only use these test entities and so trying to verify with any other data will result in no matches being found.
/// </summary>
/// <param name="body">Required parameter: Example: </param>
/// <return>Returns the Models.VerifyResult response from the API call</return>
public async Task <VerifyResult> CreateVerifyAsync(VerifyRequest body)
{
//validating required parameters
if (null == body)
{
throw new ArgumentNullException(nameof(body), "The parameter \"body\" is a required parameter and cannot be null.");
}
//the base uri for api requests
var baseUri = Configuration.GetBaseURI();
//prepare query string for API call
var queryBuilder = new StringBuilder(baseUri);
queryBuilder.Append("/{mode}/verifications/v1/verify");
var parameters = new Dictionary <string, object> {
{ "mode", Configuration.Mode.ToFriendlyString() }
};
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(queryBuilder, parameters);
//validate and preprocess url
var queryUrl = APIHelper.CleanUrl(queryBuilder);
//append request with appropriate headers and parameters
var headers = new Dictionary <string, string>
{
{ "user-agent", "Trulioo C# SDK" },
{ "accept", "application/json" },
{ "content-type", "application/json; charset=utf-8" },
{ "x-trulioo-api-key", Configuration.XTruliooApiKey }
};
//append body params
var json = APIHelper.JsonSerialize(body);
//prepare the API call request to fetch the response
HttpRequest request = ClientInstance.PostBody(queryUrl, headers, json);
//invoke request and get response
var response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(request).ConfigureAwait(false);
var context = new HttpContext(request, response);
//handle errors defined at the API level
ValidateResponse(response, context);
try
{
return(APIHelper.JsonDeserialize <VerifyResult>(response.Body));
}
catch (Exception ex)
{
throw new APIException("Failed to parse the response: " + ex.Message, context);
}
}
/// <summary>
/// Calculates the expression using the specified operation.
/// </summary>
/// <param name="Models.GetCalculateInput">Object containing request parameters</param>
/// <return>Returns the double response from the API call</return>
public async Task <double> GetCalculateAsync(Models.GetCalculateInput input)
{
//Check if authentication token is set
AuthManager.Instance.CheckAuthorization();
//the base uri for api requests
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/{operation}");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "operation", Models.OperationTypeEnumHelper.ToValue(input.Operation) }
});
//process optional query parameters
APIHelper.AppendUrlWithQueryParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "x", input.X },
{ "y", input.Y }
}, ArrayDeserializationFormat, ParameterSeparator);
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "APIMATIC 2.0" }
};
_headers.Add("gfdsfkl", Configuration.Gfdsfkl);
_headers.Add("dsfsdf", Configuration.Dsfsdf);
_headers.Add("Authorization", string.Format("Bearer {0}", Configuration.OAuthToken.AccessToken));
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.Get(_queryUrl, _headers);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(double.Parse(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// TODO: type endpoint description here
/// </summary>
/// <param name="webhookId">Required parameter: Example: </param>
/// <return>Returns the string response from the API call</return>
public async Task <string> DestroyAsync(int webhookId)
{
//the base uri for api requestss
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/webhooks/{webhook_id}");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "webhook_id", webhookId }
});
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "APIMATIC 2.0" }
};
_headers.Add("X-API-TOKEN", Configuration.XAPITOKEN);
_headers.Add("X-API-EMAIL", Configuration.XAPIEMAIL);
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.Delete(_queryUrl, _headers, null);
//Custom Authentication to be added for authorization
AuthUtility.AppendCustomAuthParams(_request);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request);
HttpContext _context = new HttpContext(_request, _response);
//return null on 404
if (_response.StatusCode == 404)
{
return(null);
}
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(_response.Body);
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// Get Properties of a Type
/// </summary>
/// <param name="type">Required parameter: The name of the type to get properties.</param>
/// <return>Returns the GetTypeResponse response from the API call</return>
public async Task <GetTypeResponse> GetTypeAsync(string type)
{
//the base uri for api requestss
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/v1/types/{type}");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "type", type }
});
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "SUGGESTGRID" },
{ "accept", "application/json" }
};
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.Get(_queryUrl, _headers, Configuration.BasicAuthUserName, Configuration.BasicAuthPassword);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request);
HttpContext _context = new HttpContext(_request, _response);
//Error handling using HTTP status codes
if (_response.StatusCode == 429)
{
throw new ErrorResponseException(@"Too many requests.", _context);
}
else if (_response.StatusCode == 500)
{
throw new APIException(@"Unexpected internal error.", _context);
}
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <GetTypeResponse>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// Submit a receipt for a feed item
/// </summary>
/// <param name="accountUid">Required parameter: Account uid</param>
/// <param name="categoryUid">Required parameter: Category uid</param>
/// <param name="feedItemUid">Required parameter: Feed item uid</param>
/// <param name="body">Required parameter: Receipt</param>
/// <return>Returns the Models.ReceiptCreationResponse response from the API call</return>
public async Task <ReceiptCreationResponse> CreateOrUpdateReceiptAsync(
Guid accountUid,
Guid categoryUid,
Guid feedItemUid,
Receipt body)
{
//validating required parameters
if (null == body)
{
throw new ArgumentNullException(nameof(body), "The parameter \"body\" is a required parameter and cannot be null.");
}
//the base uri for api requests
var baseUri = Configuration.GetBaseURI();
//prepare query string for API call
var queryBuilder = new StringBuilder(baseUri);
queryBuilder.Append("/api/v2/feed/account/{accountUid}/category/{categoryUid}/{feedItemUid}/receipt");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(queryBuilder, new Dictionary <string, object>
{
{ "accountUid", accountUid },
{ "categoryUid", categoryUid },
{ "feedItemUid", feedItemUid }
});
//validate and preprocess url
var queryUrl = APIHelper.CleanUrl(queryBuilder);
//append request with appropriate headers and parameters
var headers = APIHelper.GetContentRequestHeaders(true, true);
//append body params
var serializedBody = APIHelper.JsonSerialize(body);
//prepare the API call request to fetch the response
var request = ClientInstance.PutBody(queryUrl, headers, serializedBody);
//invoke request and get response
var response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(request).ConfigureAwait(false);
var context = new HTTPContext(request, response);
//handle errors
ValidateResponse(response, context);
try
{
return(APIHelper.JsonDeserialize <ReceiptCreationResponse>(response.Body));
}
catch (Exception ex)
{
throw new APIException("Failed to parse the response: " + ex.Message, context);
}
}
/// <summary>
/// Lists all of the information associated with any of the CNAM Records in your account.
/// </summary>
/// <param name="id">Required parameter: CNAM Record to search for.</param>
/// <return>Returns the response from the API call</return>
public async Task <dynamic> GetCNAMDetailsAsync(string id)
{
//the base uri for api requests
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/v2/cnams/{id}");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "id", id }
});
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "Flowroute SDK v3.0" },
{ "accept", "application/json" }
};
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.Get(_queryUrl, _headers, Configuration.BasicAuthUserName, Configuration.BasicAuthPassword);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
//Error handling using HTTP status codes
if (_response.StatusCode == 401)
{
throw new APIException(@"Unauthorized", _context);
}
if (_response.StatusCode == 404)
{
throw new APIException(@"Not Found", _context);
}
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <dynamic>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// List Conference
/// </summary>
/// <param name="CreateListConferenceInput">Object containing request parameters</param>
/// <return>Returns the string response from the API call</return>
public async Task <string> CreateListConferenceAsync(CreateListConferenceInput input)
{
//the base uri for api requestss
string _baseUri = Configuration.GetBaseURI();
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/conferences/listconference.{ResponseType}");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "ResponseType", input.ResponseType }
});
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "message360-api" }
};
//append form/field parameters
var _fields = new Dictionary <string, object>()
{
{ "Page", input.Page },
{ "PageSize", input.PageSize },
{ "FriendlyName", input.FriendlyName },
{ "Status", (input.Status.HasValue) ? InterruptedCallStatusHelper.ToValue(input.Status.Value) : null },
{ "DateCreated", input.DateCreated },
{ "DateUpdated", input.DateUpdated }
};
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.Post(_queryUrl, _headers, _fields, Configuration.BasicAuthUserName, Configuration.BasicAuthPassword);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(_response.Body);
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// Categories are subdivisions within an account.
/// The `defaultCategory` from [`/api/v2/accounts`](#operations-tag-Accounts) is where the main balance and transactions are held.
/// Other categories are used for Savings Goals.
/// </summary>
/// <param name="accountUid">Required parameter: Account uid</param>
/// <param name="categoryUid">Required parameter: Category uid</param>
/// <param name="minTransactionTimestamp">Required parameter: Minimum transaction timestamp</param>
/// <param name="maxTransactionTimestamp">Required parameter: Maximum transaction timestamp</param>
/// <return>Returns the Models.FeedItems response from the API call</return>
public async Task <FeedItems> GetQueryFeedItemsWithTransactionTimesBetweenAsync(
Guid accountUid,
Guid categoryUid,
DateTime minTransactionTimestamp,
DateTime maxTransactionTimestamp)
{
//the base uri for api requests
var baseUri = Configuration.GetBaseURI();
//prepare query string for API call
var queryBuilder = new StringBuilder(baseUri);
queryBuilder.Append("/api/v2/feed/account/{accountUid}/category/{categoryUid}/transactions-between");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(queryBuilder, new Dictionary <string, object>
{
{ "accountUid", accountUid },
{ "categoryUid", categoryUid }
});
//process optional query parameters
APIHelper.AppendUrlWithQueryParameters(queryBuilder, new Dictionary <string, object>
{
// ReSharper disable StringLiteralTypo
{ "minTransactionTimestamp", minTransactionTimestamp.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK") },
{ "maxTransactionTimestamp", maxTransactionTimestamp.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK") }
// ReSharper restore StringLiteralTypo
}, ArrayDeserializationFormat, ParameterSeparator);
//validate and preprocess url
var queryUrl = APIHelper.CleanUrl(queryBuilder);
//append request with appropriate headers and parameters
var headers = APIHelper.GetRequestHeaders();
//prepare the API call request to fetch the response
var request = ClientInstance.Get(queryUrl, headers);
//invoke request and get response
var response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(request).ConfigureAwait(false);
var context = new HTTPContext(request, response);
//handle errors
ValidateResponse(response, context);
try
{
return(APIHelper.JsonDeserialize <FeedItems>(response.Body));
}
catch (Exception ex)
{
throw new APIException("Failed to parse the response: " + ex.Message, context);
}
}
/// <summary>
/// Updates a plan item
/// </summary>
/// <param name="planId">Required parameter: Plan id</param>
/// <param name="planItemId">Required parameter: Plan item id</param>
/// <param name="body">Required parameter: Request for updating the plan item</param>
/// <param name="idempotencyKey">Optional parameter: Example: </param>
/// <return>Returns the Models.GetPlanItemResponse response from the API call</return>
public async Task <Models.GetPlanItemResponse> UpdatePlanItemAsync(
string planId,
string planItemId,
Models.UpdatePlanItemRequest body,
string idempotencyKey = null)
{
//the base uri for api requests
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/plans/{plan_id}/items/{plan_item_id}");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "plan_id", planId },
{ "plan_item_id", planItemId }
});
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "MundiSDK - DotNet 0.16.0-beta.0" },
{ "accept", "application/json" },
{ "content-type", "application/json; charset=utf-8" },
{ "idempotency-key", idempotencyKey }
};
//append body params
var _body = APIHelper.JsonSerialize(body);
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.PutBody(_queryUrl, _headers, _body, Configuration.BasicAuthUserName, Configuration.BasicAuthPassword);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <Models.GetPlanItemResponse>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// This method retrieves the consents required for the data sources currently configured in your account configuration.
/// The response for this method contains a collection of string that Verify method's ConsentForDataSources field expects to perform a verification using those data sources.
/// Failure to provide an element from the string collection will lead to a 1005 service error
/// </summary>
/// <param name="country">The country which serializes to the country alpha2 code</param>
/// <param name="configurationName">Required parameter: The product configuration. Currently defaults to "Identity Verification" for all products.</param>
/// <return> Returns the List{string} response from the API call</return>
public async Task <List <string> > GetConsentsAsync(Country country, string configurationName = "Identity Verification")
{
//validating country parameter
if (country == Country.NotSet)
{
throw new ArgumentException(nameof(country), "The parameter \"country\" is required and cannot have the value NotSet.");
}
//the base uri for api requests
var baseUri = Configuration.GetBaseURI();
//prepare query string for API call
var queryBuilder = new StringBuilder(baseUri);
queryBuilder.Append("/{mode}/configuration/v1/consents/{configurationName}/{countryCode}");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(queryBuilder, new Dictionary <string, object>()
{
{ "mode", Configuration.Mode.ToFriendlyString() },
{ "countryCode", country.ToAlpha2CodeString() },
{ "configurationName", configurationName }
});
//validate and preprocess url
var queryUrl = APIHelper.CleanUrl(queryBuilder);
//append request with appropriate headers and parameters
var headers = new Dictionary <string, string>
{
{ "user-agent", "Trulioo C# SDK" },
{ "accept", "application/json" },
{ "x-trulioo-api-key", Configuration.XTruliooApiKey }
};
//prepare the API call request to fetch the response
HttpRequest request = ClientInstance.Get(queryUrl, headers);
//invoke request and get response
var response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(request).ConfigureAwait(false);
var context = new HttpContext(request, response);
//handle errors defined at the API level
ValidateResponse(response, context);
try
{
return(APIHelper.JsonDeserialize <List <string> >(response.Body));
}
catch (Exception ex)
{
throw new APIException("Failed to parse the response: " + ex.Message, context);
}
}
/// <summary>
/// Updates Booking status information.Newly created booking has status `reserved`. In this status BeMyGuest inventory is not yet deducted.Inventory is locked after changing status of the booking from `reserved` to `waiting` (`confirm` action).When the booking is first created, it is marked as `reserved`. Inventories aren't touched yet. Once the partner decides to confirm the said booking, this is the only time the inventory will be impacted. The booking status will be updated from `reserved` to `waiting`.5 days after the booking date all booking with status `waiting` will be marked `expired`.There's 3rd extra action you may invoke in this method : `resend`. If `confirmationEmailSentAt` value is not null then the confirmation email copy sent o partner will be sent again and the timestamp value of this field will be updated.In response Booking object is returned, for example { "data": { "uuid": "c53cbc74-1efa-58bb-afef-750afc52cd75", "totalAmount": "123.98", "currencyCode": "SGD", "currencyUuid": "cd15153e-dfd1-5039-8aa3-115bec58e86e", "totalAmountRequestCurrency": "369.46", "requestCurrencyCode": "MYR", "requestCurrencyUuid": "e98aaf89-ae5a-5c11-859a-b36f2c8e13c7", "createdAt": "2015-12-21 19:53:23", "updatedAt": "2015-12-21 19:53:23", "arrivalDate": "2016-02-21", "salutation": "Mr.", "firstName": "test", "lastName": "test", "email": "*****@*****.**", "phone": "123456789", "guests": 2, "children": 0, "partnerReference": "test93828", "confirmationEmailSentAt": null, "confirmationEmailFiles": [], "status": "reserved", "productTypeTitle": "14% OFF for Family: E-Ticket to Universal Studios Singapore", "productTypeTitleTranslated": "14% OFF for Family: E-Ticket to Universal Studios Singapore", "productTypeUuid": "9b967f1a-89c2-5083-a758-e359deb2af9b" } }### Parameters+ uuid (required,string) - UUID of booking+ status (string) - Status "confirm" or "cancel"
/// </summary>
/// <param name="status">Required parameter: New status of the booking, one of [confirm, cancel, resend]</param>
/// <param name="uuid">Required parameter: UUID of booking</param>
/// <param name="data">Optional parameter: TODO: type parameter description here</param>
/// <return>Returns the UpdateBookingStatusResponse response from the API call</return>
public async Task <UpdateBookingStatusResponse> UpdateBookingStatusAsync(
string status,
string uuid,
UpdateBookingRequest data = null)
{
//the base uri for api requestss
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/v1/bookings/{uuid}/{status}");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "status", status },
{ "uuid", uuid }
});
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "BeMyGuest.SDK.v1" },
{ "accept", "application/json" },
{ "content-type", "application/json; charset=utf-8" }
};
_headers.Add("X-Authorization", Configuration.XAuthorization);
//append body params
var _body = APIHelper.JsonSerialize(data);
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.PutBody(_queryUrl, _headers, _body);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request);
HttpContext _context = new HttpContext(_request, _response);
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <UpdateBookingStatusResponse>(_response.Body));
}
catch (Exception ex)
{
throw new APIException("Failed to parse the response: " + ex.Message, _context);
}
}
/// <summary>
/// Get the spending insights grouped by counter party
/// </summary>
/// <param name="accountUid">Required parameter: Account uid</param>
/// <param name="year">Required parameter: Year</param>
/// <param name="month">Required parameter: Month</param>
/// <return>Returns the Models.SpendingCounterPartySummary response from the API call</return>
public async Task <SpendingCounterPartySummary> GetQuerySpendingInsightsByCounterpartyAsync(Guid accountUid, string year, MonthEnum month)
{
//validating required parameters
if (null == year)
{
throw new ArgumentNullException(nameof(year), "The parameter \"year\" is a required parameter and cannot be null.");
}
//the base uri for api requests
var baseUri = Configuration.GetBaseURI();
//prepare query string for API call
var queryBuilder = new StringBuilder(baseUri);
queryBuilder.Append("/api/v2/accounts/{accountUid}/spending-insights/counter-party");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(queryBuilder, new Dictionary <string, object>
{
{ "accountUid", accountUid }
});
//process optional query parameters
APIHelper.AppendUrlWithQueryParameters(queryBuilder, new Dictionary <string, object>
{
{ "year", year },
{ "month", MonthEnumHelper.ToValue(month) }
}, ArrayDeserializationFormat, ParameterSeparator);
//validate and preprocess url
var queryUrl = APIHelper.CleanUrl(queryBuilder);
//append request with appropriate headers and parameters
var headers = APIHelper.GetRequestHeaders();
//prepare the API call request to fetch the response
var request = ClientInstance.Get(queryUrl, headers);
//invoke request and get response
var response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(request).ConfigureAwait(false);
var context = new HTTPContext(request, response);
//handle errors
ValidateResponse(response, context);
try
{
return(APIHelper.JsonDeserialize <SpendingCounterPartySummary>(response.Body));
}
catch (Exception ex)
{
throw new APIException("Failed to parse the response: " + ex.Message, context);
}
}
/// <summary>
/// Retrieve the current status of a message using the message ID returned in the send messages end point.
/// A successful request to the get message status endpoint will return a response body as follows:
/// ```json
/// {
/// "format": "SMS",
/// "content": "My first message!",
/// "metadata": {
/// "key1": "value1",
/// "key2": "value2"
/// },
/// "message_id": "877c19ef-fa2e-4cec-827a-e1df9b5509f7",
/// "callback_url": "https://my.callback.url.com",
/// "delivery_report": true,
/// "destination_number": "+61401760575",
/// "scheduled": "2016-11-03T11:49:02.807Z",
/// "source_number": "+61491570157",
/// "source_number_type": "INTERNATIONAL",
/// "message_expiry_timestamp": "2016-11-03T11:49:02.807Z",
/// "status": "enroute"
/// }
/// ```
/// The status property of the response indicates the current status of the message. See the Delivery
/// Reports section of this documentation for more information on message statues.
/// *Note: If an invalid or non existent message ID parameter is specified in the request, then
/// a HTTP 404 Not Found response will be returned*
/// </summary>
/// <param name="messageId">Required parameter: Example: </param>
/// <return>Returns the Models.GetMessageStatusResponse response from the API call</return>
public async Task <Models.GetMessageStatusResponse> GetMessageStatusAsync(string messageId)
{
//the base uri for api requests
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/v1/messages/{messageId}");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "messageId", messageId }
});
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "messagemedia-messages" },
{ "accept", "application/json" }
};
//append authentication headers
AuthManager.Instance.GetAuthHeaders(_queryUrl, _baseUri).ToList().ForEach(x => _headers.Add(x.Key, x.Value));
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.Get(_queryUrl, _headers);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
//Error handling using HTTP status codes
if (_response.StatusCode == 404)
{
throw new APIException(@"Resource not found", _context);
}
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <Models.GetMessageStatusResponse>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// Create a new referral.
/// </summary>
/// <param name="accountSlug">Required parameter: The account identifier</param>
/// <param name="advocateToken">Required parameter: The advocate's token</param>
/// <param name="referralForm">Required parameter: The body of the request</param>
/// <return>Returns the dynamic response from the API call</return>
public async Task <dynamic> PostReferralAsync(string accountSlug, string advocateToken, ReferralForm referralForm)
{
//the base uri for api requestss
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/accounts/{account_slug}/advocates/{advocate_token}/referrals");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "account_slug", accountSlug },
{ "advocate_token", advocateToken }
});
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "APIMATIC 2.0" },
{ "accept", "application/json" },
{ "content-type", "application/json; charset=utf-8" }
};
_headers.Add("Content-Type", Configuration.ContentType);
_headers.Add("X-Auth-Token", Configuration.XAuthToken);
//append body params
var _body = APIHelper.JsonSerialize(referralForm);
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.PostBody(_queryUrl, _headers, _body);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <dynamic>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// Retrieve the current status of a message using the message ID returned in the send messages end point.
/// A successful request to the get message status endpoint will return a response body as follows:
/// ```json
/// {
/// "format": "SMS",
/// "content": "My first message!",
/// "metadata": {
/// "key1": "value1",
/// "key2": "value2"
/// },
/// "message_id": "877c19ef-fa2e-4cec-827a-e1df9b5509f7",
/// "callback_url": "https://my.callback.url.com",
/// "delivery_report": true,
/// "destination_number": "+61401760575",
/// "scheduled": "2016-11-03T11:49:02.807Z",
/// "source_number": "+61491570157",
/// "source_number_type": "INTERNATIONAL"
/// "message_expiry_timestamp": "2016-11-03T11:49:02.807Z",
/// "status": "enroute"
/// }
/// ```
/// The status property of the response indicates the current status of the message. See the Delivery
/// Reports section of this documentation for more information on message statues.
/// *Note: If an invalid or non existent message ID parameter is specified in the request, then
/// a HTTP 404 Not Found response will be returned*
/// </summary>
/// <param name="messageId">Required parameter: Example: </param>
/// <param name="accountHeaderValue">Optional parameter: Sends the API an account value.</param>
/// <return>Returns the dynamic response from the API call</return>
public async Task <dynamic> GetMessageStatusAsync(string messageId, string accountHeaderValue = null)
{
//the base uri for api requests
string baseUri = Configuration.BaseUri;
string methodUri = $@"/v1/messages/{messageId}";
//prepare query string for API call
StringBuilder queryBuilder = new StringBuilder(baseUri);
queryBuilder.Append("/v1/messages/{messageId}");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(queryBuilder, new Dictionary <string, object>()
{
{ "messageId", messageId }
});
//validate and preprocess url
string queryUrl = APIHelper.CleanUrl(queryBuilder);
//append request with appropriate headers and parameters
var headers = new Dictionary <string, string>()
{
{ "user-agent", SdkVersion },
{ "accept", "application/json" }
};
AddAccountHeaderTo(headers, accountHeaderValue);
//prepare the API call request to fetch the response
HttpRequest request = GetHttpRequest(queryUrl, headers);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(request).ConfigureAwait(false);
HttpContext _context = new HttpContext(request, _response);
//Error handling using HTTP status codes
if (_response.StatusCode == 404)
{
throw new APIException(@"", _context);
}
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <dynamic>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// To choose a file format, set the Accept header to either 'application/pdf' or 'text/csv'
/// </summary>
/// <param name="accountUid">Required parameter: Example: </param>
/// <param name="yearMonth">Required parameter: Example: </param>
/// <return>Returns the Stream response from the API call</return>
public async Task <Stream> GetDownloadCsvStatementAsync(Guid accountUid, string yearMonth)
{
//validating required parameters
if (null == yearMonth)
{
throw new ArgumentNullException(nameof(yearMonth), "The parameter \"yearMonth\" is a required parameter and cannot be null.");
}
//the base uri for api requests
var baseUri = Configuration.GetBaseURI();
//prepare query string for API call
var queryBuilder = new StringBuilder(baseUri);
queryBuilder.Append("/api/v2/accounts/{accountUid}/statement/download");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(queryBuilder, new Dictionary <string, object>
{
{ "accountUid", accountUid }
});
//process optional query parameters
APIHelper.AppendUrlWithQueryParameters(queryBuilder, new Dictionary <string, object>
{
{ "yearMonth", yearMonth }
}, ArrayDeserializationFormat, ParameterSeparator);
//validate and preprocess url
var queryUrl = APIHelper.CleanUrl(queryBuilder);
//append request with appropriate headers and parameters
var headers = APIHelper.GetRequestHeaders(true, true);
//prepare the API call request to fetch the response
var request = ClientInstance.Get(queryUrl, headers);
//invoke request and get response
var response = await ClientInstance.ExecuteAsBinaryAsync(request).ConfigureAwait(false);
var context = new HTTPContext(request, response);
//handle errors
ValidateResponse(response, context);
try
{
return(response.RawBody);
}
catch (Exception ex)
{
throw new APIException("Failed to parse the response: " + ex.Message, context);
}
}
/// <summary>
/// N.B. if you're looking for only the next payment date, this is also returned when getting a standing order in the `StandingOrder` response from the field `nextDate`.
/// Categories are subdivisions within an account.
/// The `defaultCategory` from [`/api/v2/accounts`](#operations-tag-Accounts) is where the main balance and transactions are held.
/// Other categories are used for Savings Goals.
/// </summary>
/// <param name="accountUid">Required parameter: Account uid</param>
/// <param name="categoryUid">Required parameter: Category uid</param>
/// <param name="paymentOrderUid">Required parameter: Payment Order uid</param>
/// <param name="count">Optional parameter: Number of next payment dates to retrieve, between 1 and 100. If count is greater than the number of future payments all future payments will be returned. Defaults to 10.</param>
/// <return>Returns the Models.NextPaymentDatesResponse response from the API call</return>
public async Task <NextPaymentDatesResponse> ListNextPaymentDatesAsync(
Guid accountUid,
Guid categoryUid,
Guid paymentOrderUid,
int?count = null)
{
//the base uri for api requests
var baseUri = Configuration.GetBaseURI();
//prepare query string for API call
var queryBuilder = new StringBuilder(baseUri);
queryBuilder.Append("/api/v2/payments/local/account/{accountUid}/category/{categoryUid}/standing-orders/{paymentOrderUid}/upcoming-payments");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(queryBuilder, new Dictionary <string, object>
{
{ "accountUid", accountUid },
{ "categoryUid", categoryUid },
{ "paymentOrderUid", paymentOrderUid }
});
//process optional query parameters
APIHelper.AppendUrlWithQueryParameters(queryBuilder, new Dictionary <string, object>
{
{ "count", count }
}, ArrayDeserializationFormat, ParameterSeparator);
//validate and preprocess url
var queryUrl = APIHelper.CleanUrl(queryBuilder);
//append request with appropriate headers and parameters
var headers = APIHelper.GetRequestHeaders();
//prepare the API call request to fetch the response
var request = ClientInstance.Get(queryUrl, headers);
//invoke request and get response
var response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(request).ConfigureAwait(false);
var context = new HTTPContext(request, response);
//handle errors
ValidateResponse(response, context);
try
{
return(APIHelper.JsonDeserialize <NextPaymentDatesResponse>(response.Body));
}
catch (Exception ex)
{
throw new APIException("Failed to parse the response: " + ex.Message, context);
}
}
/// <summary>
/// Remove a purchased Ytel number from your account.
/// </summary>
/// <param name="responseType">Required parameter: Response type format xml or json</param>
/// <param name="phoneNumber">Required parameter: A valid 10-digit Ytel number (E.164 format).</param>
/// <return>Returns the string response from the API call</return>
public async Task <string> CreateReleaseNumberAsync(string responseType, string phoneNumber)
{
//the base uri for api requests
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/incomingphone/releasenumber.{ResponseType}");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "ResponseType", responseType }
});
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "APIMATIC 2.0" }
};
//append form/field parameters
var _fields = new List <KeyValuePair <string, Object> >()
{
new KeyValuePair <string, object>("PhoneNumber", phoneNumber)
};
//remove null parameters
_fields = _fields.Where(kvp => kvp.Value != null).ToList();
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.Post(_queryUrl, _headers, _fields, Configuration.BasicAuthUserName, Configuration.BasicAuthPassword);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(_response.Body);
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// In order to cancel payment with miles you can use this endpoint. It allows to cancel payment only related GSM and terminal ID numbers.
/// You can try this endpoint with configuring client parameters in Console Tab below. Test OAuthClientId is b30359c21700fd6f2b91154adcb7b37bab3e7e0a33e22682e5dd149d7a6ac4df
/// and OAuthClientSecret is 4bc4335faad41d6a23cd059e495005f00496a64e34e6187b1d72695a8debd28c
/// </summary>
/// <param name="milesPaymentProvisionId">Required parameter: Provision ID.</param>
/// <param name="body">Required parameter: The body of the request.</param>
/// <return>Returns the Models.CancelMilePaymentResponse response from the API call</return>
public async Task <Models.CancelMilePaymentResponse> DeleteCancelMilePaymentAsync(int milesPaymentProvisionId, Models.CancelMilePaymentRequest body)
{
//Check if authentication token is set
AuthManager.Instance.CheckAuthorization();
//the base uri for api requests
string _baseUri = Configuration.GetBaseURI();
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/v2/pos/payments/{miles_payment_provision_id}");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "miles_payment_provision_id", milesPaymentProvisionId }
});
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "APIMATIC 2.0" },
{ "accept", "application/json" },
{ "content-type", "application/json; charset=utf-8" }
};
_headers.Add("Authorization", string.Format("Bearer {0}", Configuration.OAuthToken.AccessToken));
//append body params
var _body = APIHelper.JsonSerialize(body);
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.DeleteBody(_queryUrl, _headers, _body);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <Models.CancelMilePaymentResponse>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// TODO: type endpoint description here
/// </summary>
/// <param name="chargeId">Required parameter: Charge Id</param>
/// <param name="page">Optional parameter: Page number</param>
/// <param name="size">Optional parameter: Page size</param>
/// <return>Returns the Models.ListChargeTransactionsResponse response from the API call</return>
public async Task <Models.ListChargeTransactionsResponse> GetChargeTransactionsAsync(string chargeId, int?page = null, int?size = null)
{
//the base uri for api requests
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/charges/{charge_id}/transactions");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "charge_id", chargeId }
});
//process optional query parameters
APIHelper.AppendUrlWithQueryParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "page", page },
{ "size", size }
}, ArrayDeserializationFormat, ParameterSeparator);
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "MundiSDK - DotNet 0.16.21" },
{ "accept", "application/json" }
};
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.Get(_queryUrl, _headers, Configuration.BasicAuthUserName, Configuration.BasicAuthPassword);
//invoke request and get response
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <Models.ListChargeTransactionsResponse>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}