private static void AddCallOptions(CallOptions options, RestRequest request)
{
request.AddParameter("From", options.From);
request.AddParameter("To", options.To);
if (options.ApplicationSid.HasValue())
{
request.AddParameter("ApplicationSid", options.ApplicationSid);
}
else
{
request.AddParameter("Url", options.Url);
}
if (options.StatusCallback.HasValue()) request.AddParameter("StatusCallback", options.StatusCallback);
if (options.StatusCallbackMethod.HasValue()) request.AddParameter("StatusCallbackMethod", options.StatusCallbackMethod);
if (options.FallbackUrl.HasValue()) request.AddParameter("FallbackUrl", options.FallbackUrl);
if (options.FallbackMethod.HasValue()) request.AddParameter("FallbackMethod", options.FallbackMethod);
if (options.Method.HasValue()) request.AddParameter("Method", options.Method);
if (options.SendDigits.HasValue()) request.AddParameter("SendDigits", options.SendDigits);
if (options.IfMachine.HasValue()) request.AddParameter("IfMachine", options.IfMachine);
if (options.Timeout.HasValue) request.AddParameter("Timeout", options.Timeout.Value);
if (options.Record) request.AddParameter("Record", "true");
if (options.SipAuthUsername.HasValue()) request.AddParameter("SipAuthUsername", options.SipAuthUsername);
if (options.SipAuthPassword.HasValue()) request.AddParameter("SipAuthPassword", options.SipAuthPassword);
}
public virtual async Task<VoiceCountryResult> ListVoiceCountriesAsync()
{
var request = new RestRequest(Method.GET);
request.Resource = "Voice/Countries";
return await Execute<VoiceCountryResult>(request);
}
/// <summary>
/// Create a new application
/// </summary>
/// <param name="friendlyName">The friendly name to name the application</param>
/// <param name="options">Optional parameters to use when purchasing number</param>
/// <param name="callback">Method to call upon successful completion</param>
public virtual void AddApplication(string friendlyName, ApplicationOptions options, Action<Application> callback)
{
var request = new RestRequest(Method.POST);
request.Resource = "Accounts/{AccountSid}/Applications.json";
Require.Argument("FriendlyName", friendlyName);
Validate.IsValidLength(friendlyName, 64);
request.AddParameter("FriendlyName", friendlyName);
// some check for null. in those cases an empty string is a valid value (to remove a URL assignment)
if (options != null)
{
if (options.VoiceUrl != null) request.AddParameter("VoiceUrl", options.VoiceUrl);
if (options.VoiceMethod.HasValue()) request.AddParameter("VoiceMethod", options.VoiceMethod.ToString());
if (options.VoiceFallbackUrl != null) request.AddParameter("VoiceFallbackUrl", options.VoiceFallbackUrl);
if (options.VoiceFallbackMethod.HasValue()) request.AddParameter("VoiceFallbackMethod", options.VoiceFallbackMethod.ToString());
if (options.VoiceCallerIdLookup.HasValue) request.AddParameter("VoiceCallerIdLookup", options.VoiceCallerIdLookup.Value);
if (options.StatusCallback.HasValue()) request.AddParameter("StatusCallback", options.StatusCallback);
if (options.StatusCallbackMethod.HasValue()) request.AddParameter("StatusCallbackMethod", options.StatusCallbackMethod.ToString());
if (options.SmsUrl != null) request.AddParameter("SmsUrl", options.SmsUrl);
if (options.SmsMethod.HasValue()) request.AddParameter("SmsMethod", options.SmsMethod.ToString());
if (options.SmsFallbackUrl != null) request.AddParameter("SmsFallbackUrl", options.SmsFallbackUrl);
if (options.SmsFallbackMethod.HasValue()) request.AddParameter("SmsFallbackMethod", options.SmsFallbackMethod.ToString());
}
ExecuteAsync<Application>(request, (response) => { callback(response); });
}
/// <summary>
/// Returns a filtered list of Messages. The list includes paging information.
/// Makes a GET request to the Messages List resource.
/// </summary>
/// <param name="options">The list filters for the request</param>
public virtual async Task<MessageResult> ListMessagesAsync(MessageListRequest options)
{
var request = new RestRequest();
request.Resource = "Accounts/{AccountSid}/Messages.json";
AddMessageListOptions(options, request);
return await Execute<MessageResult>(request);
}
/// <summary>
/// Returns the Sandbox resource associated with the account identified by {YourAccountSid}.
/// Twilio accounts upgraded prior to February 2010 may not have a Sandbox resource, and in this case you will receive a 404 (Not Found) response.
/// Makes a GET request to the Sandbox Instance resource.
/// </summary>
public virtual Sandbox GetSandbox()
{
var request = new RestRequest();
request.Resource = "Accounts/{AccountSid}/Sandbox.json";
return Execute<Sandbox>(request);
}
/// <summary>
/// List all subaccounts created for the authenticated account. Makes a GET request to the Account List resource.
/// </summary>
public virtual AccountResult ListSubAccounts()
{
var request = new RestRequest();
request.Resource = "Accounts.json";
return Execute<AccountResult>(request);
}
public virtual void ListVoiceCountries(Action<VoiceCountryResult> callback)
{
var request = new RestRequest(Method.GET);
request.Resource = "Voice/Countries";
ExecuteAsync<VoiceCountryResult>(request, (response) => callback(response));
}
/// <summary>
/// Retrieve the account details for the currently authenticated account. Makes a GET request to an Account Instance resource.
/// </summary>
public virtual async Task<Account> GetAccountAsync()
{
var request = new RestRequest();
request.Resource = "Accounts/{AccountSid}.json";
return await Execute<Account>(request);
}
public virtual PhoneNumberCountryResult ListPhoneNumberCountries()
{
var request = new RestRequest(Method.GET);
request.Resource = "PhoneNumbers/Countries";
return Execute<PhoneNumberCountryResult>(request);
}
public virtual async Task<PhoneNumberCountryResult> ListPhoneNumberCountriesAsync()
{
var request = new RestRequest(Method.GET);
request.Resource = "PhoneNumbers/Countries";
return await Execute<PhoneNumberCountryResult>(request);
}
/// <summary>
/// Returns the Sandbox resource associated with the account identified by {YourAccountSid}. Twilio accounts upgraded prior to February 2010 may not have a Sandbox resource, and in this case you will receive a 404 (Not Found) response.
/// </summary>
/// <param name="callback">Method to call upon successful completion</param>
public virtual void GetSandbox(Action<Sandbox> callback)
{
var request = new RestRequest();
request.Resource = "Accounts/{AccountSid}/Sandbox.json";
ExecuteAsync<Sandbox>(request, callback);
}
/// <summary>
/// Return a list of all Queue resources
/// </summary>
/// <param name="callback">Method to call upon successful completion</param>
/// <returns></returns>
public virtual void ListQueues(Action<QueueResult> callback)
{
var request = new RestRequest();
request.Resource = "Accounts/{AccountSid}/Queues.json";
ExecuteAsync<QueueResult>(request, (response) => callback(response) );
}
/// <summary>
/// Return a list of all Queue resources
/// </summary>
/// <returns></returns>
public virtual QueueResult ListQueues()
{
var request = new RestRequest();
request.Resource = "Accounts/{AccountSid}/Queues.json";
return Execute<QueueResult>(request);
}
/// <summary>
/// Returns the Sandbox resource associated with the account identified by {YourAccountSid}.
/// Twilio accounts upgraded prior to February 2010 may not have a Sandbox resource, and in this case you will receive a 404 (Not Found) response.
/// Makes a GET request to the Sandbox Instance resource.
/// </summary>
public virtual async Task<Sandbox> GetSandboxAsync()
{
var request = new RestRequest();
request.Resource = "Accounts/{AccountSid}/Sandbox.json";
return await Execute<Sandbox>(request);
}
/// <summary>
/// Retrieve the account details for the currently authenticated account
/// </summary>
/// <param name="callback">Method to call upon successful completion</param>
public virtual void GetAccount(Action<Account> callback)
{
var request = new RestRequest();
request.Resource = "Accounts/{AccountSid}.json";
ExecuteAsync<Account>(request, (response) => { callback(response); });
}
/// <summary>
/// Returns a paged list of phone calls made to and from the account.
/// Makes a GET request to the Calls List resource.
/// </summary>
public virtual async Task<CallResult> ListCallsAsync()
{
var request = new RestRequest();
request.Resource = "Accounts/{AccountSid}/Calls.json";
return await Execute<CallResult>(request);
}
/// <summary>
/// List all subaccounts created for the authenticated account
/// </summary>
/// <param name="callback">Method to call upon successful completion</param>
public virtual void ListSubAccounts(Action<AccountResult> callback)
{
var request = new RestRequest();
request.Resource = "Accounts.json";
ExecuteAsync<AccountResult>(request, (response) => { callback(response); });
}
/// <summary>
/// List all subaccounts created for the authenticated account. Makes a GET request to the Account List resource.
/// </summary>
public virtual async Task<AccountResult> ListSubAccountsAsync()
{
var request = new RestRequest();
request.Resource = "Accounts.json";
return await Execute<AccountResult>(request);
}
public void When_Request_Method_Is_POST_Then_Request_Body_Contains_Encoded_Parameters()
{
string body = "Foo=12345&Bar=abcde";
var sourcebytes = Encoding.UTF8.GetBytes(body);
client = new RestClient();
client.BaseUrl = BASE_URL;
var request = new RestRequest();
request.Method = "POST";
request.AddParameter("Foo", "12345");
request.AddParameter("Bar", "abcde");
var wrapper = new HttpWebRequestWrapper();
wrapper.Request = new FakeHttpWebRequest();
var webrequest = (FakeHttpWebRequest)wrapper.ConfigureRequest(client, request);
var stream = webrequest.GetRequestStream();
stream.Position = 0;
byte[] actualbytes = stream.ReadAsBytes();
Assert.AreEqual(sourcebytes.Length, webrequest.ContentLength);
Assert.AreEqual(sourcebytes.Length, actualbytes.Length);
CollectionAssert.AreEquivalent(sourcebytes, actualbytes);
}
/// <summary>
/// Retrieve the account details for the currently authenticated account. Makes a GET request to an Account Instance resource.
/// </summary>
public virtual Account GetAccount()
{
var request = new RestRequest();
request.Resource = "Accounts/{AccountSid}.json";
return Execute<Account>(request);
}
/// <summary>
/// Returns a list of conferences within an account.
/// The list includes paging information.
/// Makes a GET request to the Conferences List resource.
/// </summary>
public virtual ConferenceResult ListConferences()
{
var request = new RestRequest();
request.Resource = "Accounts/{AccountSid}/Conferences.json";
return Execute<ConferenceResult>(request);
}
/// <summary>
/// Returns a paged list of phone calls made to and from the account.
/// Makes a GET request to the Calls List resource.
/// </summary>
public virtual CallResult ListCalls()
{
var request = new RestRequest();
request.Resource = "Accounts/{AccountSid}/Calls.json";
return Execute<CallResult>(request);
}
/// <summary>
/// Create a new Address.
/// </summary>
/// <param name="friendlyName">Friendly name (optional)</param>
/// <param name="customerName">Customer name.</param>
/// <param name="street">Street.</param>
/// <param name="city">City.</param>
/// <param name="region">Region.</param>
/// <param name="postalCode">Postal code.</param>
/// <param name="isoCountry">Iso country.</param>
/// <param name="callback">Method to call upon successful completion.</param>
public virtual void AddAddress(string friendlyName, string customerName, string street, string city, string region, string postalCode, string isoCountry, Action<Address> callback)
{
var request = new RestRequest(Method.POST);
request.Resource = "Accounts/{AccountSid}/Addresses.json";
Require.Argument("CustomerName", customerName);
Require.Argument("Street", street);
Require.Argument("City", city);
Require.Argument("Region", region);
Require.Argument("PostalCode", postalCode);
Require.Argument("IsoCountry", isoCountry);
if (friendlyName.HasValue())
{
Validate.IsValidLength(friendlyName, 64);
request.AddParameter("FriendlyName", friendlyName);
}
request.AddParameter("CustomerName", customerName);
request.AddParameter("Street", street);
request.AddParameter("City", city);
request.AddParameter("Region", region);
request.AddParameter("PostalCode", postalCode);
request.AddParameter("IsoCountry", isoCountry);
ExecuteAsync<Address>(request, (response) =>
{
callback(response);
});
}
private void AddEventListOptions(EventListRequest options, RestRequest request)
{
if (options.StartDate.HasValue) {
request.AddParameter("StartDate", options.StartDate.Value.ToString("yyyy-MM-ddTHH:mm:ssK"));
}
if (options.EndDate.HasValue) {
request.AddParameter("EndDate", options.EndDate.Value.ToString("yyyy-MM-ddTHH:mm:ssK"));
}
if (options.ActorSid.HasValue()) {
request.AddParameter("ActorSid", options.ActorSid);
}
if (options.SourceIpAddress.HasValue()) {
request.AddParameter("SourceIpAddress", options.SourceIpAddress);
}
if (options.ResourceSid.HasValue()) {
request.AddParameter("ResourceSid", options.ResourceSid);
}
if (options.EventType.HasValue()) {
request.AddParameter("EventType", options.EventType);
}
if (options.PageToken.HasValue()) {
request.AddParameter("PageToken", options.PageToken);
}
if (options.Count.HasValue) {
request.AddParameter("PageSize", options.Count.Value);
}
}
/// <summary>
/// Create a new Address.
/// </summary>
/// <returns>The address.</returns>
/// <param name="friendlyName">Friendly name (optional)</param>
/// <param name="customerName">Customer name</param>
/// <param name="street">Number and street of the address</param>
/// <param name="city">City name for the address</param>
/// <param name="region">The state or region</param>
/// <param name="postalCode">Postal code</param>
/// <param name="isoCountry">ISO 3166-1 2-letter country code</param>
public virtual async Task<Address> AddAddressAsync(string friendlyName, string customerName, string street, string city, string region, string postalCode, string isoCountry)
{
var request = new RestRequest(Method.POST);
request.Resource = "Accounts/{AccountSid}/Addresses.json";
Require.Argument("CustomerName", customerName);
Require.Argument("Street", street);
Require.Argument("City", city);
Require.Argument("Region", region);
Require.Argument("PostalCode", postalCode);
Require.Argument("IsoCountry", isoCountry);
if (friendlyName.HasValue())
{
Validate.IsValidLength(friendlyName, 64);
request.AddParameter("FriendlyName", friendlyName);
}
request.AddParameter("CustomerName", customerName);
request.AddParameter("Street", street);
request.AddParameter("City", city);
request.AddParameter("Region", region);
request.AddParameter("PostalCode", postalCode);
request.AddParameter("IsoCountry", isoCountry);
return await Execute<Address>(request);
}
public virtual VoiceCountryResult ListVoiceCountries()
{
var request = new RestRequest("GET");
request.Resource = "Voice/Countries";
return Execute<VoiceCountryResult>(request);
}
/// <summary>
/// Returns a filtered list of Messages. The list includes paging information.
/// Makes a GET request to the Messages List resource.
/// </summary>
/// <param name="options">The list filters for the request</param>
/// <param name="callback"></param>
public virtual void ListMessages(MessageListRequest options, Action<MessageResult> callback)
{
var request = new RestRequest();
request.Resource = "Accounts/{AccountSid}/Messages.json";
AddMessageListOptions(options, request);
ExecuteAsync<MessageResult>(request, (response) => callback(response));
}
/// <summary>
/// Retrieve a list of countries where Twilio hosted Phone Numbers
/// are available.
/// </summary>
/// <param name="callback">Callback to handle response.</param>
public virtual void ListPhoneNumberCountries(Action<PhoneNumberCountryResult> callback)
{
var request = new RestRequest(Method.GET);
request.Resource = "PhoneNumbers/Countries";
ExecuteAsync<PhoneNumberCountryResult>(request, (response) => callback(response));
}
/// <summary>
/// List all media for a particular message
/// </summary>
/// <param name="messageSid">The message sid to filter on</param>
/// <param name="options"></param>
/// <param name="callback"></param>
public virtual void ListMessageMedia(string messageSid, MediaListRequest options, Action<MediaResult> callback)
{
var request = new RestRequest();
request.Resource = "Accounts/{AccountSid}/Messages/{MessageSid}/Media.json";
request.AddUrlSegment("MessageSid", messageSid);
AddMediaListOptions(options, request);
ExecuteAsync<MediaResult>(request, (response) => callback(response));
}
/// <summary>
/// Get the details for a specific Media instance.
/// </summary>
public virtual void GetMessageMedia(string messageSid, string mediaSid, Action<Media> callback)
{
var request = new RestRequest();
request.Resource = "Accounts/{AccountSid}/Messages/{MessageSid}/Media/{MediaSid}.json";
request.AddUrlSegment("MediaSid", mediaSid);
request.AddUrlSegment("MessageSid", messageSid);
ExecuteAsync<Media>(request, (response) => callback(response));
}
