/// <summary>
/// Update multiple Users in a single batch (batch size must be less than 250kb)
/// </summary>
/// <param name="body">Required parameter: Example: </param>
/// <return>Returns the void response from the API call</return>
public async Task UpdateCompaniesBatchAsync(List <CompanyModel> body)
{
//the base uri for api requestss
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/v1/companies/batch");
//validate and preprocess url
string _queryUrl = ApiHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "content-type", "application/json; charset=utf-8" }
};
_headers.Add("X-Moesif-Application-Id", Configuration.ApplicationId);
//append body params
var _body = ApiHelper.JsonSerialize(body);
//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);
HttpContext _context = new HttpContext(_request, _response);
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
}
/// <summary>
/// TODO: type endpoint description here
/// </summary>
/// <param name="body">Optional parameter: Example: </param>
/// <return>Returns the void response from the API call</return>
public async Task CreateDispatchWebhookAsync(DefaultWebhookPayloadModel body = null)
{
//the base uri for api requests
var baseUri = Configuration.GetBaseURI();
//prepare query string for API call
var queryBuilder = new StringBuilder(baseUri);
queryBuilder.Append("/yourdomain.com/your/registered/web-hook/address");
//validate and preprocess url
var queryUrl = APIHelper.CleanUrl(queryBuilder);
//append request with appropriate headers and parameters
var headers = APIHelper.GetContentRequestHeaders();
//append body params
var serializedBody = APIHelper.JsonSerialize(body);
//prepare the API call request to fetch the response
var request = ClientInstance.PostBody(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 defined at the API level
ValidateResponse(response, context);
}
public async Task <Models.CustomerResponse> CreateCustomerAsync(Models.CustomerRequest body)
{
string _baseUri = Configuration.GetBaseURI();
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/customers");
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
var _headers = Utilities.APIHelper.GetHeader();
var _body = APIHelper.JsonSerialize(body);
HttpRequest _request = ClientInstance.PostBody(_queryUrl, _headers, _body);
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <Models.CustomerResponse>(_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>
/// Create a new sender id to send messages using it
/// </summary>
/// <param name="senderName">Required parameter: Name you want to register as Sender Name</param>
/// <return>Returns the string response from the API call</return>
public async Task <string> CreateSenderNameAsync(string senderName)
{
//validating required parameters
if (null == senderName)
{
throw new ArgumentNullException("senderName", "The parameter \"senderName\" is a required parameter and cannot be null.");
}
//the base uri for api requests
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/sender/create");
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "Releans" },
{ "content-type", "text/plain; charset=utf-8" }
};
_headers.Add("Authorization", string.Format("Bearer {0}", Configuration.OAuthAccessToken));
//append body params
var _body = senderName;
//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);
//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>
/// Echo's back the request
/// </summary>
/// <param name="input">Required parameter: Example: </param>
/// <return>Returns the dynamic response from the API call</return>
public async Task <dynamic> JsonEchoAsync(object input)
{
//validating required parameters
if (null == input)
{
throw new ArgumentNullException("input", "The parameter \"input\" 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("/");
//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" },
{ "content-type", "application/json; charset=utf-8" }
};
//append body params
var _body = APIHelper.JsonSerialize(input);
//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);
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 <dynamic>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// Creates a new customer
/// </summary>
/// <param name="body">Required parameter: Request Body</param>
/// <return>Returns the Models.CustomerModel response from the API call</return>
public async Task <Models.CustomerModel> CreateCustomerAsync(Models.CreateCustomerRequestModel body)
{
//validating required parameters
if (null == body)
{
throw new ArgumentNullException("body", "The parameter \"body\" 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");
//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" },
{ "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.PostBody(_queryUrl, _headers, _body, 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 <Models.CustomerModel>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// Create an Invoice
/// </summary>
/// <param name="subscriptionId">Required parameter: Subscription Id</param>
/// <param name="cycleId">Required parameter: Cycle Id</param>
/// <param name="request">Optional parameter: Example: </param>
/// <param name="idempotencyKey">Optional parameter: Example: </param>
/// <return>Returns the Models.GetInvoiceResponse response from the API call</return>
public async Task <Models.GetInvoiceResponse> CreateInvoiceAsync(
string subscriptionId,
string cycleId,
Models.CreateInvoiceRequest request = null,
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("/subscriptions/{subscription_id}/cycles/{cycle_id}/pay");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "subscription_id", subscriptionId },
{ "cycle_id", cycleId }
});
//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 2.3.0" },
{ "accept", "application/json" },
{ "content-type", "application/json; charset=utf-8" },
{ "idempotency-key", idempotencyKey }
};
//append body params
var _body = APIHelper.JsonSerialize(request);
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.PostBody(_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.GetInvoiceResponse>(_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="suites">Required parameter: Example: </param>
/// <return>Returns the ServerResponse response from the API call</return>
public async Task <ServerResponse> SendIntegerEnumArrayAsync(List <SuiteCode> suites)
{
//validating required parameters
if (null == suites)
{
throw new ArgumentNullException("suites", "The parameter \"suites\" 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("/body/integerenum");
//process optional query parameters
APIHelper.AppendUrlWithQueryParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "array", "true" }
});
//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" },
{ "content-type", "application/json; charset=utf-8" }
};
//append body params
var _body = APIHelper.JsonSerialize(suites);
//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);
HttpContext _context = new HttpContext(_request, _response);
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <ServerResponse>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// Creates a new inbound route which can then be associated with phone numbers. Please see "List Inbound Routes" to review the route values that you can associate with your Flowroute phone numbers.
/// </summary>
/// <param name="body">Required parameter: The new inbound route to be created.</param>
/// <return>Returns the string response from the API call</return>
public async Task <string> ValidateE911Async(Models.E911 body)
{
//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/validate");
//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", "application/json; charset=utf-8" }
};
//append body params
var _body = "{\"data\": {\"type\": \"e911s\", \"attributes\": ";
_body += APIHelper.JsonSerialize(body);
_body += "}}";
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.PostBody(_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);
//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>
/// RESTful web service to get alternate pickup locations.
/// [Download the YAML for this call](API_getAlternatePickupLocations.yaml)
/// </summary>
/// <param name="request">Required parameter: Example: </param>
/// <return>Returns the Models.AlternatePickupLocationsResponse response from the API call</return>
public async Task <Models.AlternatePickupLocationsResponse> AlternatePickupLocationWebServiceAsync(Models.AlternatePickupLocationsRequest request)
{
//the base uri for api requests
string _baseUri = Configuration.GetBaseURI();
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/call/getAlternatePickupLocations");
//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(request);
//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);
//Error handling using HTTP status codes
if (_response.StatusCode == 400)
{
throw new AlternatePickupLocationsErrorResponseException(@"Response on Error", _context);
}
if ((_response.StatusCode < 200) || (_response.StatusCode > 208)) //[200,208] = HTTP OK
{
throw new Error1Exception(@"Unexpected error", _context);
}
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <Models.AlternatePickupLocationsResponse>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// Create a webhook for one or more of the specified events.
/// A webhook would typically have the following structure:
/// ```
/// {
/// "url": "http://webhook.com",
/// "method": "POST",
/// "encoding": "JSON",
/// "headers": {
/// "Account": "DeveloperPortal7000"
/// },
/// "events": [
/// "RECEIVED_SMS"
/// ],
/// "template": "{\"id\":\"$mtId\",\"status\":\"$statusCode\"}"
/// }
/// ```
/// A valid webhook must consist of the following properties:
/// - ```url``` The configured URL which will trigger the webhook when a selected event occurs.
/// - ```method``` The methods to map CRUD (create, retrieve, update, delete) operations to HTTP requests.
/// - ```encoding``` The format in which the payload will be returned. You can choose from ```JSON```, ```FORM_ENCODED``` or ```XML```. This will automatically add the Content-Type header for you so you don't have to add it again in the `headers` property.
/// - ```headers``` HTTP header fields which provide required information about the request or response, or about the object sent in the message body. This should not include the `Content-Type` header.
/// - ```events``` Event or events that will trigger the webhook. Atleast one event should be present.
/// - ```template``` The structure of the payload that will be returned.
/// #### Types of Events
/// You can select all of the events (listed below) or combine them in whatever way you like but atleast one event must be used. Otherwise, the webhook won't be created.
/// A webhook will be triggered when any one or more of the events occur:
/// + **SMS**
/// + `RECEIVED_SMS` Receive an SMS
/// + `OPT_OUT_SMS` Opt-out occured
/// + **MMS**
/// + `RECEIVED_MMS` Receive an MMS
/// + **DR (Delivery Reports)**
/// + `ENROUTE_DR` Message is enroute
/// + `EXPIRED_DR` Message has expired
/// + `REJECTED_DR` Message is rejected
/// + `FAILED_DR` Message has failed
/// + `DELIVERED_DR` Message is delivered
/// + `SUBMITTED_DR` Message is submitted
/// #### Template Parameters
/// You can choose what to include in the data that will be sent as the payload via the Webhook.
/// Keep in my mind, you must escape the JSON in the template value (see example above).
/// The table illustrates a list of all the parameters that can be included in the template and which event types it can be applied to.
/// | Data | Parameter Name | Example | Event Type |
/// |:--|--|--|--|--|
/// | **Service Type** | $type| `SMS` | `DR` `MO` `MO MMS` |
/// | **Message ID** | $mtId, $messageId| `877c19ef-fa2e-4cec-827a-e1df9b5509f7` | `DR` `MO` `MO MMS`|
/// | **Delivery Report ID** |$drId, $reportId| `01e1fa0a-6e27-4945-9cdb-18644b4de043` | `DR` |
/// | **Reply ID**| $moId, $replyId| `a175e797-2b54-468b-9850-41a3eab32f74` | `MO` `MO MMS` |
/// | **Account ID** | $accountId| `DeveloperPortal7000` | `DR` `MO` `MO MMS` |
/// | **Message Timestamp** | $submittedTimestamp| `2016-12-07T08:43:00.850Z` | `DR` `MO` `MO MMS` |
/// | **Provider Timestamp** | $receivedTimestamp| `2016-12-07T08:44:00.850Z` | `DR` `MO` `MO MMS` |
/// | **Message Status** | $status| `enroute` | `DR` |
/// | **Status Code** | $statusCode| `200` | `DR` |
/// | **External Metadata** | $metadata.get('key')| `name` | `DR` `MO` `MO MMS` |
/// | **Source Address**| $sourceAddress| `+61491570156` | `DR` `MO` `MO MMS` |
/// | **Destination Address**| $destinationAddress| `+61491593156` | `MO` `MO MMS` |
/// | **Message Content**| $mtContent, $messageContent| `Hi Derp` | `DR` `MO` `MO MMS` |
/// | **Reply Content**| $moContent, $replyContent| `Hello Derpina` | `MO` `MO MMS` |
/// | **Retry Count**| $retryCount| `1` | `DR` `MO` `MO MMS` |
/// *Note: A 400 response will be returned if the `url` is invalid, the `events`, `encoding` or `method` is null or the `headers` has a Content-Type attribute.*
/// </summary>
/// <param name="body">Required parameter: Example: </param>
/// <return>Returns the dynamic response from the API call</return>
public async Task <dynamic> CreateWebhookAsync(Models.CreateWebhookRequest body)
{
//the base uri for api requests
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/v1/webhooks/messages");
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "messagesmedia-webhooks" },
{ "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.PostBody(_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);
//Error handling using HTTP status codes
if (_response.StatusCode == 400)
{
throw new CreateWebhook400ResponseException(@"Unexpected error in API call. See HTTP response body for details.", _context);
}
if (_response.StatusCode == 409)
{
throw new CreateWebhook400ResponseException(@"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 <dynamic>(_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>
/// TODO: type endpoint description here
/// </summary>
/// <param name="Models.NewInput">Object containing request parameters</param>
/// <return>Returns the dynamic response from the API call</return>
public async Task <dynamic> NewAsync(Models.NewInput 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("/1.1/test.php");
//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" },
{ "cache-control", input.CacheControl },
{ "content-type", input.ContentType },
{ "postman-token", input.PostmanToken }
};
_headers.Add("gfdsfkl", Configuration.Gfdsfkl);
_headers.Add("dsfsdf", Configuration.Dsfsdf);
_headers.Add("Authorization", string.Format("Bearer {0}", Configuration.OAuthToken.AccessToken));
//append body params
var _body = APIHelper.JsonSerialize(input.Body);
//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>
/// Authenticate to this Bouncer instance.
/// </summary>
/// <param name="body">Required parameter: Example: </param>
/// <return>Returns the Models.LoginToBouncerAPIResponse response from the API call</return>
public async Task <Models.LoginToBouncerAPIResponse> LoginToBouncerAPIAsync(Models.LoginToBouncerAPIRequest 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/login");
//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.PostBody(_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.LoginToBouncerAPIResponse>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// Allows you to set a text alias on a given DID.
/// </summary>
/// <param name="number">Required parameter: Phone number to operate on.</param>
/// <param name="callback">Required parameter: URL to apply.</param>
/// <return>Returns the response from the API call</return>
public async Task <Int32> SetDIDCallbackAsync(string number, string callback)
{
//the base uri for api requests
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/v2/numbers/{did}/relationships/dlr_callback");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "did", number }
});
var body = "{\"data\":{\"attributes\": {\"callback_url\":\"";
body += callback;
body += "\"}}}";
//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.PostBody(_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);
//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);
return(_response.StatusCode);
}
/// <summary>
/// Post Bulk Items
/// </summary>
/// <param name="items">Required parameter: A number of item metadata objects separated with newlines. Each item metadata object must have its id field. Note that this is not a valid JSON data structure. The body size is limited to 10 thousand lines.</param>
/// <return>Returns the BulkPostResponse response from the API call</return>
public async Task<BulkPostResponse> PostBulkItemsAsync(string items)
{
//the base uri for api requestss
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/v1/items/_bulk");
//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" },
{ "content-type", "text/plain; charset=utf-8" }
};
//append body params
var _body = items;
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.PostBody(_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);
//Error handling using HTTP status codes
if (_response.StatusCode == 400)
throw new ErrorResponseException(@"Body is missing.", _context);
else 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<BulkPostResponse>(_response.Body);
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// This Endpoint sends emails with the credentials passed.
/// </summary>
/// <param name="apiKey">Optional parameter: Generated header parameter. Example value ='5ce7096ed4bf2b39dfa932ff5fa84ed9ed8'</param>
/// <param name="body">Optional parameter: The body passed will be json format.</param>
/// <return>Returns the Models.SendEmailResponse response from the API call</return>
public async Task <Models.SendEmailResponse> CreateSendEmailAsync(string apiKey = null, Models.EmailBody body = null)
{
//the base uri for api requests
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/v2/sendEmail");
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "pepi-sdk-csharp v2" },
{ "accept", "application/json" },
{ "content-type", "application/json; charset=utf-8" },
{ "api_key", apiKey }
};
//append body params
var _body = APIHelper.JsonSerialize(body);
//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);
//Error handling using HTTP status codes
if (_response.StatusCode == 405)
{
throw new APIException(@"Method not allowed", _context);
}
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <Models.SendEmailResponse>(_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="publicKey">Required parameter: Public key</param>
/// <param name="request">Required parameter: Request for creating a token</param>
/// <return>Returns the Models.GetTokenResponse response from the API call</return>
public async Task <Models.GetTokenResponse> CreateTokenAsync(string publicKey, Models.CreateTokenRequest request)
{
//the base uri for api requests
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/tokens?appId={public_key}");
//process optional template parameters
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "public_key", publicKey }
});
//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.13.40" },
{ "accept", "application/json" },
{ "content-type", "application/json; charset=utf-8" }
};
//append body params
var _body = APIHelper.JsonSerialize(request);
//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 <Models.GetTokenResponse>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// The endpoint send is used to generate the request to pepipost server for sending an email to recipients.
/// </summary>
/// <param name="body">Required parameter: New mail request will be generated</param>
/// <return>Returns the object response from the API call</return>
public async Task <object> CreateGeneratethemailsendrequestAsync(Models.Send body, string url = null)
{
//the base uri for api requests
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder();
if (string.IsNullOrWhiteSpace(url))
{
_queryBuilder.Append("/mail/send");
}
else
{
_queryBuilder.Append(url + "/v5/mail/send");
}
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "pepi-sdk-csharp v5" },
{ "content-type", "application/json; charset=utf-8" }
};
_headers.Add("api_key", Configuration.ApiKey);
//append body params
var _body = APIHelper.JsonSerialize(body);
//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);
try
{
return(_response.Body);
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message + "\nResponse : " + _response.Body, _context);
}
}
/// <summary>
/// This endpoint allows to refund a payment.
/// You can try this API with configuring client parameters in Console Tab below. Test OAuthClientId is b30359c21700fd6f2b91154adcb7b37bab3e7e0a33e22682e5dd149d7a6ac4df and OAuthClientSecret is 4bc4335faad41d6a23cd059e495005f00496a64e34e6187b1d72695a8debd28c
/// </summary>
/// <param name="body">Required parameter: The body of the request.</param>
/// <return>Returns the Models.Response response from the API call</return>
public async Task <Models.Response> CreateRefundMilePaymentAsync(Models.RefundMilePaymentRequest 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/ecommerce/payments/actions/refund");
//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.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 <Models.Response>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// Echo's back the request
/// </summary>
/// <param name="input">Required parameter: TODO: type parameter description here</param>
/// <return>Returns the dynamic response from the API call</return>
public async Task <dynamic> JsonEchoAsync(
object input)
{
//the base uri for api requestss
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/");
//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" },
{ "content-type", "application/json; charset=utf-8" }
};
//append body params
var _body = APIHelper.JsonSerialize(input);
//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);
HttpContext _context = new HttpContext(_request, _response);
//Error handling using HTTP status codes
if ((_response.StatusCode < 200) || (_response.StatusCode > 206)) //[200,206] = HTTP OK
{
throw new APIException(@"HTTP Response Not OK", _context);
}
try
{
return(APIHelper.JsonDeserialize <dynamic>(_response.Body));
}
catch (Exception ex)
{
throw new APIException("Failed to parse the response: " + ex.Message, _context);
}
}
/// <summary>
/// Commits a file immediately and waits for the job to complete before returning
/// </summary>
/// <param name="body">Required parameter: Job Details</param>
/// <return>Returns the Models.JobStatus response from the API call</return>
public async Task <Models.JobStatus> CreateCommitNowAsync(Models.GitJob body)
{
//the base uri for api requests
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/git/pushnow");
//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("x-username", Configuration.XUsername);
_headers.Add("x-password", Configuration.XPassword);
//append body params
var _body = APIHelper.JsonSerialize(body);
//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 <Models.JobStatus>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// `Check if booking is possible` method request requires lesser parameters as compared to `Create a booking`.In fact before creating a booking we advise to run this request first:- it will check if booking can be made without writing any data in BMG database- it will provide a correct total amount for selected services- if partner is caching products this should be used just before creating a booking - so any differences in cached prices (on partner side) and current price for total amount can be discovered- if partner discover difference in provided total amount then he can act accordingly in his user/client interface (for example - ask customer to accept final changed price)The main difference is that no booking is created in the system and some fields in response JSON object have NULL values. If the product has timeslots, the `timeslotUUID` of the product is REQUIRED in `Check a Booking` and `Create a new booking` methods. Otherwise, it can be excluded.For `booking check` request you don't have to pass customer's data or `partnerReference`.Example JSON request: { "productTypeUuid": "9d4b4d76-5b54-5407-b2d9-e6c021cc472e", "pax": 2, "children": 3, "timeSlotUuid": "b02ae425-421f-5edf-a880-4104c0245dac", "addons": [ { "uuid": "37e0f490-d31d-521b-b1f0-95c6e4e38d4c", "quantity": "1" }, { "uuid": "a50090e3-567d-5743-9d87-e9d261aad0a9", "quantity": "2" } ], "arrivalDate": "2015-06-07", "usePromotion": false }Response example: { "data": { "uuid": null, "totalAmount": "123.98", "currencyCode": "SGD", "currencyUuid": "cd15153e-dfd1-5039-8aa3-115bec58e86e", "totalAmountRequestCurrency": "369.46", "requestCurrencyCode": "MYR", "requestCurrencyUuid": "e98aaf89-ae5a-5c11-859a-b36f2c8e13c7", "createdAt": null, "updatedAt": null, "arrivalDate": "2015-06-07", "salutation": null, "firstName": null, "lastName": null, "email": null, "phone": null, "guests": 2, "children": 3, "partnerReference": null, "confirmationEmailSentAt": null, "confirmationEmailFiles": [], "status": null, "productTypeTitle": null, "productTypeTitleTranslated": null, "productTypeUuid": "9d4b4d76-5b54-5407-b2d9-e6c021cc472e" } }
/// </summary>
/// <param name="body">Required parameter: TODO: type parameter description here</param>
/// <return>Returns the CheckABookingResponse response from the API call</return>
public async Task <CheckABookingResponse> CreateCheckABookingAsync(
CheckABookingRequest body)
{
//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/check");
//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(body);
//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);
HttpContext _context = new HttpContext(_request, _response);
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <CheckABookingResponse>(_response.Body));
}
catch (Exception ex)
{
throw new APIException("Failed to parse the response: " + ex.Message, _context);
}
}
/// <summary>
/// Mark a delivery report as confirmed so it is no longer return in check delivery reports requests.
/// The confirm delivery reports endpoint is intended to be used in conjunction with the check delivery
/// reports endpoint to allow for robust processing of delivery reports. Once one or more delivery
/// reports have been processed, they can then be confirmed using the confirm delivery reports endpoint so they
/// are no longer returned in subsequent check delivery reports requests.
/// The confirm delivery reports endpoint takes a list of delivery report IDs as follows:
/// ```json
/// {
/// "delivery_report_ids": [
/// "011dcead-6988-4ad6-a1c7-6b6c68ea628d",
/// "3487b3fa-6586-4979-a233-2d1b095c7718",
/// "ba28e94b-c83d-4759-98e7-ff9c7edb87a1"
/// ]
/// }
/// ```
/// Up to 100 delivery reports can be confirmed in a single confirm delivery reports request.
/// </summary>
/// <param name="body">Required parameter: Example: </param>
/// <return>Returns the dynamic response from the API call</return>
public async Task <dynamic> ConfirmDeliveryReportsAsReceivedAsync(Models.ConfirmDeliveryReportsAsReceivedRequest body)
{
//the base uri for api requests
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/v1/delivery_reports/confirmed");
//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" },
{ "content-type", "application/json; charset=utf-8" }
};
//append body params
var _body = APIHelper.JsonSerialize(body);
//append authentication headers
AuthManager.Instance.GetAuthHeaders(_queryUrl, _baseUri, _body).ToList().ForEach(x => _headers.Add(x.Key, x.Value));
//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>
/// An access token will allow you to make requests for the system. We support only one type of token: client_credentials.
/// You can try this API with configuring client parameters in Console Tab below. Test OAuthClientId is b30359c21700fd6f2b91154adcb7b37bab3e7e0a33e22682e5dd149d7a6ac4df and OAuthClientSecret is 4bc4335faad41d6a23cd059e495005f00496a64e34e6187b1d72695a8debd28c
/// </summary>
/// <param name="accept">Required parameter: It advertises which content type is able to understand.</param>
/// <param name="contentType">Required parameter: It tells the client what the content type of the returned.</param>
/// <param name="body">Required parameter: The body of the request.</param>
/// <return>Returns the Models.OAuthResponse response from the API call</return>
public async Task <Models.OAuthResponse> CreateAuthenticationAsync(string accept, string contentType, Models.OAuthRequest body)
{
//the base uri for api requests
string _baseUri = Configuration.GetBaseURI();
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/oauth/token");
//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" },
{ "Accept", accept },
{ "Content-Type", contentType }
};
//append body params
var _body = APIHelper.JsonSerialize(body);
//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 <Models.OAuthResponse>(_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="array">Required parameter: TODO: type parameter description here</param>
/// <return>Returns the dynamic response from the API call</return>
public async Task <dynamic> SendStringEnumArrayAsync(
List <Days> array)
{
//the base uri for api requestss
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/body/stringenum?array=true");
//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" },
{ "content-type", "application/json; charset=utf-8" }
};
//append body params
var _body = APIHelper.JsonSerialize(array);
//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);
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>
/// TODO: type endpoint description here
/// </summary>
/// <param name="request">Required parameter: Example: </param>
/// <return>Returns the Models.GetTransfer response from the API call</return>
public async Task <Models.GetTransfer> CreateTransferAsync(Models.CreateTransfer request)
{
//the base uri for api requests
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/transfers/recipients");
//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 2.3.0" },
{ "accept", "application/json" },
{ "content-type", "application/json; charset=utf-8" }
};
//append body params
var _body = APIHelper.JsonSerialize(request);
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.PostBody(_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.GetTransfer>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}
/// <summary>
/// Send SMS to recipients using D7 SMS Gateway
/// </summary>
/// <param name="Models.CreateSendSMSInput">Object containing request parameters</param>
/// <return>Returns the void response from the API call</return>
public async Task CreateSendSMSAsync(Models.CreateSendSMSInput input)
{
//the base uri for api requests
string _baseUri = Configuration.BaseUri;
//prepare query string for API call
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/send");
//validate and preprocess url
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
//append request with appropriate headers and parameters
var _headers = new Dictionary <string, string>()
{
{ "user-agent", "D7SDK 1.0" },
{ "Content-Type", input.ContentType },
{ "Accept", input.Accept }
};
//append body params
var _body = APIHelper.JsonSerialize(input.Body);
//prepare the API call request to fetch the response
HttpRequest _request = ClientInstance.PostBody(_queryUrl, _headers, _body, Configuration.APIUsername, Configuration.APIPassword);
//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 == 500)
{
throw new APIException(@"Internal Server Error", _context);
}
//handle errors defined at the API level
base.ValidateResponse(_response, _context);
}
public async Task <Models.EscrowResponse> ReleaseEscrowAsync(string escrowId)
{
string _baseUri = Configuration.GetBaseURI();
StringBuilder _queryBuilder = new StringBuilder(_baseUri);
_queryBuilder.Append("/escrows/{escrow-id}/release");
APIHelper.AppendUrlWithTemplateParameters(_queryBuilder, new Dictionary <string, object>()
{
{ "escrow-id", escrowId }
});
dynamic body = "";
var _body = APIHelper.JsonSerialize(body);
string _queryUrl = APIHelper.CleanUrl(_queryBuilder);
var _headers = Utilities.APIHelper.GetHeader();
HttpRequest _request = ClientInstance.PostBody(_queryUrl, _headers, _body);
HttpStringResponse _response = (HttpStringResponse)await ClientInstance.ExecuteAsStringAsync(_request).ConfigureAwait(false);
HttpContext _context = new HttpContext(_request, _response);
base.ValidateResponse(_response, _context);
try
{
return(APIHelper.JsonDeserialize <Models.EscrowResponse>(_response.Body));
}
catch (Exception _ex)
{
throw new APIException("Failed to parse the response: " + _ex.Message, _context);
}
}