/// <summary>
/// Return list of transcriptions
/// </summary>
/// <param name="page">Used to return a particular page withing the list.</param>
/// <param name="pageSize">Used to specify the amount of list items to return per page.</param>
/// <returns></returns>
public async Task<TranscriptionResult> GetAccountTranscriptions(int? page, int? pageSize)
{
var request = new RestRequest();
request.Resource = RequestUri.AccountTranscriptionsUri;
if (page.HasValue) request.AddParameter("Page", page);
if (pageSize.HasValue) request.AddParameter("PageSize", pageSize);
return await Execute<TranscriptionResult>(request);
}
/// <summary>
/// Return a list of all fraud control resources associated with a given account
/// </summary>
/// <param name="page">Used to return a particular page withing the list.</param>
/// <param name="pageSize">Used to specify the amount of list items to return per page.</param>
/// <returns></returns>
public async Task<FraudResult> GetFraudControlResources(int? page, int? pageSize)
{
var request = new RestRequest();
request.Resource = RequestUri.FraudControlResourcesUri;
if (page.HasValue) request.AddParameter("Page", page);
if (pageSize.HasValue) request.AddParameter("PageSize", pageSize);
return await Execute<FraudResult>(request);
}
/// <summary>
/// A lists of every notification associated with an account
/// </summary>
/// <param name="log">Specifies that only notifications with the given log level value should be listed.</param>
/// <param name="page">Used to return a particular page withing the list.</param>
/// <param name="pageSize">Used to specify the amount of list items to return per page.</param>
/// <returns></returns>
public async Task<NotificationResult> GetAccountNotifications(NotificationLog? log, int? page, int? pageSize)
{
var request = new RestRequest();
request.Resource = RequestUri.NotificationsUri;
if (log.HasValue) request.AddParameter("Log", (int)log);
if (page.HasValue) request.AddParameter("Page", page);
if (pageSize.HasValue) request.AddParameter("PageSize", pageSize);
return await Execute<NotificationResult>(request);
}
/// <summary>
/// Return applications list
/// </summary>
/// <param name="friendlyName">Specifies that only application resources matching the input FreindlyName should be returned in the list request.</param>
/// <param name="page">Used to return a particular page withing the list.</param>
/// <param name="pageSize">Used to specify the amount of list items to return per page.</param>
/// <returns></returns>
public async Task<ApplicationResult> GetApplications(string friendlyName, int? page, int? pageSize)
{
var request = new RestRequest();
request.Resource = RequestUri.ApplicationsUri;
if (friendlyName != null) request.AddParameter("FriendlyName", friendlyName);
if (page.HasValue) request.AddParameter("Page", page);
if (pageSize.HasValue) request.AddParameter("PageSize", pageSize);
return await Execute<ApplicationResult>(request);
}
/// <summary>
/// Gets TelAPI phone numbers associated with an account
/// </summary>
/// <param name="phoneNumber">Specifies what IncomingPhoneNumber resources should be returned in the list request.</param>
/// <param name="friendlyName">Specifies that only IncomingPhoneNumber resources matching the input FreindlyName should be returned in the list request.</param>
/// <param name="page">Used to return a particular page withing the list.</param>
/// <param name="pageSize">Used to specify the amount of list items to return per page.</param>
/// <returns></returns>
public async Task<IncomingPhoneNumberResult> GetIncomingPhoneNumbers(string phoneNumber, string friendlyName, int? page, int? pageSize)
{
var request = new RestRequest();
request.Resource = RequestUri.IncomingPhoneNumbersUri;
if (phoneNumber != null) request.AddParameter("PhoneNumber", phoneNumber);
if (friendlyName != null) request.AddParameter("FriendlyName", friendlyName);
if (page.HasValue) request.AddParameter("Page", page);
if (pageSize.HasValue) request.AddParameter("PageSize", pageSize);
return await Execute<IncomingPhoneNumberResult>(request);
}
/// <summary>
/// Get account recordings
/// </summary>
/// <param name="dateCreated">Lists all recordings created on or after a certain date. </param>
/// <param name="dateCreatedComparasion">Date created comparasion</param>
/// <param name="page">Used to return a particular page withing the list.</param>
/// <param name="pageSize">Used to specify the amount of list items to return per page.</param>
/// <returns></returns>
public async Task<RecordingResult> GetAccountRecordings(DateTime? dateCreated, ComparisonType? dateCreatedComparasion, int? page, int? pageSize)
{
var request = new RestRequest();
request.Resource = RequestUri.AccountRecordingsUri;
var dateCreatedParameterName = GetParameterNameWithEquality(dateCreatedComparasion, "DateCreated");
if (dateCreated.HasValue) request.AddParameter(dateCreatedParameterName, dateCreated.Value.ToString("yyyy-MM-dd"));
if (page.HasValue) request.AddParameter("Page", page);
if (pageSize.HasValue) request.AddParameter("PageSize", pageSize);
return await Execute<RecordingResult>(request);
}
/// <summary>
/// A list of only notifications associated with a given CallSid
/// </summary>
/// <param name="callSid">An alphanumeric string used for identification of calls.</param>
/// <param name="log">Specifies that only notifications with the given log level value should be listed.</param>
/// <param name="page">Used to return a particular page withing the list.</param>
/// <param name="pageSize">Used to specify the amount of list items to return per page.</param>
/// <returns></returns>
public async Task<NotificationResult> GetCallNotifications(string callSid, NotificationLog? log, int? page, int? pageSize)
{
Require.Argument("CallSid", callSid);
var request = new RestRequest();
request.Resource = RequestUri.CallNotificationUri;
request.AddUrlSegment("CallSid", callSid);
if (log.HasValue) request.AddParameter("Log", (int)log);
if (page.HasValue) request.AddParameter("Page", page);
if (pageSize.HasValue) request.AddParameter("PageSize", pageSize);
return await Execute<NotificationResult>(request);
}
/// <summary>
/// Used to authorize destinations for outbound calls and sms messages.
/// </summary>
/// <param name="countryCode">Two letter country code being whitelisted, authorized or blocked.</param>
/// <param name="mobileBreakout">Mobile breakout status for the destination.</param>
/// <param name="Landlinebreakout">Landline breakout status for the destination.</param>
/// <param name="smsEnabled">SMS status for the destination.</param>
/// <returns></returns>
public async Task<FraudResult> AuthorizeDestination(string countryCode, bool? mobileBreakout, bool? landlinebreakout, bool? smsEnabled)
{
Require.Argument("CountryCode", countryCode);
var request = new RestRequest(System.Net.Http.HttpMethod.Post);
request.Resource = RequestUri.FraudAuthorizeDestination;
request.AddUrlSegment(RequestUriParams.CountryCode, countryCode);
if (mobileBreakout.HasValue) request.AddParameter("MobileBreakout", mobileBreakout);
if (landlinebreakout.HasValue) request.AddParameter("LandlineBreakout", landlinebreakout);
if (smsEnabled.HasValue) request.AddParameter("SmsEnabled", smsEnabled);
return await Execute<FraudResult>(request);
}
/// <summary>
/// Send SMS message
/// </summary>
/// <param name="from">The number you want to display as sending the SMS. A surcharge will apply when sending via a custom From number.</param>
/// <param name="to">The number you want to send the SMS to.</param>
/// <param name="body">Text of the SMS message to be sent.</param>
/// <param name="statusCallback">URL that a set of default parameters will be forwarded to once the SMS is complete.</param>
/// <returns></returns>
public async Task<SmsMessage> SendSmsMessage(string from, string to, string body, string statusCallback)
{
Require.Argument("from", from);
Require.Argument("to", to);
Require.Argument("body", body);
var request = new RestRequest(System.Net.Http.HttpMethod.Post);
request.Resource = RequestUri.SendSmsMessageUri;
request.AddParameter("From", from);
request.AddParameter("To", to);
request.AddParameter("Body", body);
if (statusCallback != null) request.AddParameter("StatusCallback", statusCallback);
return await Execute<SmsMessage>(request);
}
/// <summary>
/// Request a list of available numbers
/// </summary>
/// <param name="isoCountryCode">Two letter country code of the available phone number.</param>
/// <param name="areaCode">Code used to identify the phone numbers geographic origin. Found at the beginning of the number.</param>
/// <param name="contains">Specifies the desired characters contained within the available numbers to list.</param>
/// <param name="inRegion">Specifies the desired region of the available numbers to be listed.</param>
/// <param name="inPostalCode">Specifies the desired postal code of the available numbers to be listed.</param>
/// <param name="type">Search for local (default) or toll free nubmers.</param>
/// <returns></returns>
public async Task<AvailablePhoneNumberResult> GetAvailablePhoneNumbers(string isoCountryCode, string areaCode, string contains, string inRegion, string inPostalCode, AvaliablePhoneNumberType type)
{
Require.Argument("IsoCountryCode", isoCountryCode);
var request = new RestRequest();
request.Resource = type == AvaliablePhoneNumberType.Local ? RequestUri.AvailablePhoneNumbersUri : RequestUri.AvailableTollFreePhoneNumbersUri;
request.AddUrlSegment(RequestUriParams.IsoCountryCode, isoCountryCode);
if (areaCode != null) request.AddParameter("AreaCode", areaCode);
if (contains != null) request.AddParameter("Contains", contains);
if (inRegion != null) request.AddParameter("InRegion", inRegion);
if (inPostalCode != null) request.AddParameter("InPostalCode", inPostalCode);
return await Execute<AvailablePhoneNumberResult>(request);
}
/// <summary>
/// TelAPI provides an endpoint for performing BNA (Billing Name Address) lookups on numbers.
/// BNA lookups provide geolocation information for phone numbers. BNA lookups are currently only available for US numbers.
/// </summary>
/// <param name="phoneNumber">The number of the phone you are attempting to perform the BNA lookup on.</param>
/// <returns></returns>
public async Task<BNALookupResult> BnaLookup(string phoneNumber)
{
Require.Argument("PhoneNumber", phoneNumber);
var request = new RestRequest();
request.Resource = RequestUri.BnaLookup;
request.AddParameter(RequestUriParams.PhoneNumber, phoneNumber);
return await Execute<BNALookupResult>(request);
}
/// <summary>
/// A complete list of usage that has occured through an account can be requested via the REST API.
/// This list includes every feature of TelAPI an account may use, from inbound/outbound call and SMS messages all the way to Carrier/CNAM lookups.
/// </summary>
/// <param name="day">Returns a list of usage for a given day within a month.</param>
/// <param name="month">Returns a list of usage for a given month. For January: Month=1, for February: Month=2, etc.</param>
/// <param name="year">Returns a list of usage for a given year.</param>
/// <param name="page">Used to return a particular page withing the list.</param>
/// <param name="pageSize">Used to specify the amount of list items to return per page.</param>
/// <param name="product">Returns a list of all usage for a specific "product" or feature of TelAPI.</param>
/// <returns></returns>
public async Task<UsageResult> GetUsages(int? day, int? month, int? year, int? page, int? pageSize, Products? product)
{
var request = new RestRequest();
request.Resource = RequestUri.GetUsagesUri;
if (day.HasValue) request.AddParameter("Day", day);
if (month.HasValue) request.AddParameter("Month", month);
if (year.HasValue) request.AddParameter("Year", year);
if (page.HasValue) request.AddParameter("Page", page);
if (pageSize.HasValue) request.AddParameter("PageSize", pageSize);
if (product.HasValue) request.AddParameter("Product", (int)product.Value);
return await Execute<UsageResult>(request);
}
/// <summary>
/// Return list of all conference resources associated with a given account
/// </summary>
/// <param name="friendlyName">List conferences with the given FriendlyName.</param>
/// <param name="status">List conferences with the given status.</param>
/// <param name="dateCreated">List conferences created on, after, or before a given date.</param>
/// <param name="dateCreatedComparasion">Date range can be specified using inequalities.</param>
/// <param name="dateUpdated">List conferences updated on, after, or before a given date.</param>
/// <param name="dateUpdatedComparasion">Date range can be specified using inequalities.</param>
/// <param name="page">Used to return a particular page withing the list.</param>
/// <param name="pageSize">Used to specify the amount of list items to return per page.</param>
/// <returns></returns>
public async Task<ConferenceResult> GetConferences(string friendlyName, ConferenceStatus? status, DateTime? dateCreated, ComparisonType? dateCreatedComparasion,
DateTime? dateUpdated, ComparisonType? dateUpdatedComparasion, int? page, int? pageSize)
{
var request = new RestRequest();
request.Resource = RequestUri.ConferencesUri;
var dateCreatedParameterName = GetParameterNameWithEquality(dateCreatedComparasion, "DateCreated");
var dateUpdatedParemeterName = GetParameterNameWithEquality(dateUpdatedComparasion, "DateUpdated");
if (friendlyName != null) request.AddParameter("FriendlyName", friendlyName);
if (status.HasValue) request.AddParameter("Status", status.ToString().ToLower());
if (dateCreated.HasValue) request.AddParameter(dateCreatedParameterName, dateCreated.Value.ToString("yyyy-MM-dd"));
if (dateUpdated.HasValue) request.AddParameter(dateUpdatedParemeterName, dateUpdated.Value.ToString("yyyy-MM-dd"));
if (page.HasValue) request.AddParameter("Page", page);
if (pageSize.HasValue) request.AddParameter("PageSize", pageSize);
return await Execute<ConferenceResult>(request);
}
/// <summary>
/// TelAPI offers a way to both initiate or end a call recording
/// </summary>
/// <param name="callSid">An alphanumeric string used for identification of calls</param>
/// <param name="isRecording">Specifies if call recording should beging or end. To start recording a call, value must be true. To stop recording a call, value must be false.</param>
/// <param name="timeLimit">The time in seconds the duration a call recording should not exceed. If no value specified, recordings are 60 seconds by default.</param>
/// <param name="callbackUrl">URL where recording information will be relayed to after it has completed.</param>
/// <returns></returns>
public async Task<RecordingResult> RecordCall(string callSid, bool isRecording, int? timeLimit, string callbackUrl)
{
Require.Argument("CallSid", callSid);
Require.Argument("Record", isRecording);
var request = new RestRequest(System.Net.Http.HttpMethod.Post);
request.Resource = RequestUri.RecordCallUri;
request.AddUrlSegment(RequestUriParams.CallSid, callSid);
request.AddParameter("Record", isRecording);
if (timeLimit.HasValue) request.AddParameter("TimeLimit", timeLimit);
if (callbackUrl != null) request.AddParameter("CallbackUrl", callbackUrl);
return await Execute<RecordingResult>(request);
}
/// <summary>
/// DTMFs, aka touch tone signals, can be sent to a call
/// </summary>
/// <param name="callSid">An alphanumeric string used for identification of calls</param>
/// <param name="playDtmf">Specifies which touch tone signals to send to a call. W or w can be used to include half second pauses within the digit transmission. For example: wwww1234 waits two seconds before sending the digits and 12wwww34 waits two seconds in between the sending of 12 and 34. Allowed Value: the digits 0-9, W, or w</param>
/// <param name="dtmfLeg">Specifies which leg of the call digits will be sent to. 'aleg' leg is the originator of the call, 'bleg' is the recipient of the call.</param>
/// <returns></returns>
public async Task<Call> SendDigits(string callSid, string playDtmf, PlayDtmfLeg? dtmfLeg)
{
Require.Argument("CallSid", callSid);
Require.Argument("PlayDtmf", playDtmf);
var request = new RestRequest(System.Net.Http.HttpMethod.Post);
request.Resource = RequestUri.SendDigitsUri;
request.AddUrlSegment(RequestUriParams.CallSid, callSid);
request.AddParameter("PlayDtmf", playDtmf);
if (dtmfLeg.HasValue) request.AddParameter("PlayDtmfLeg", dtmfLeg.ToString().ToLower());
return await Execute<Call>(request);
}
/// <summary>
/// To change the behavior of live calls, TelAPI provides the ability to interrupt calls in real time and end or redirect them to InboundXML for execution.
/// </summary>
/// <param name="callSid">An alphanumeric string used for identification of calls</param>
/// <param name="url">The URL in-progress calls can be forwarded to.</param>
/// <param name="httpMethod">Specifies the HTTP method used to request forwarding URL. Allowed Value: POST or GET. Default Value: POST</param>
/// <param name="status">The status used to end the call. canceled only ends queued/ringing calls while completed ends in-progress calls as well as queued/ringing calls. Allowed Value: canceled or completed</param>
/// <returns></returns>
public async Task<Call> InterruptLiveCall(string callSid, string url, HttpMethod? httpMethod, HangupCallStatus? status)
{
Require.Argument("CallSid", callSid);
var request = new RestRequest(System.Net.Http.HttpMethod.Post);
request.Resource = RequestUri.InterruptLiveCallUri;
request.AddUrlSegment(RequestUriParams.CallSid, callSid);
if(url != null) request.AddParameter("Url", url);
if(httpMethod != null) request.AddParameter("Method", httpMethod.ToString().ToLower());
if(status != null) request.AddParameter("Status", status.ToString().ToLower());
return await Execute<Call>(request);
}
/// <summary>
/// Helper Method to populate RestRequest params
/// </summary>
/// <param name="smsMessageOptions">Sms message options</param>
/// <param name="request">Rest request</param>
private void CreateSmsMessageListOptions(SmsMessageListOptions smsMessageOptions, RestRequest request)
{
var dateSentParameterName = GetParameterNameWithEquality(smsMessageOptions.DateSentComparison, "DateSent");
if (smsMessageOptions.To != null) request.AddParameter("To", smsMessageOptions.To);
if (smsMessageOptions.From != null) request.AddParameter("From", smsMessageOptions.From);
if (smsMessageOptions.DateSent.HasValue) request.AddParameter(dateSentParameterName, smsMessageOptions.DateSent.Value.ToString("yyyy-MM-dd"));
if (smsMessageOptions.Page.HasValue) request.AddParameter("Page", smsMessageOptions.Page.Value);
if (smsMessageOptions.PageSize.HasValue) request.AddParameter("PageSize", smsMessageOptions.PageSize.Value);
}
/// <summary>
/// Play audio to participant of conference call
/// </summary>
/// <param name="conferenceSid">Conference sid</param>
/// <param name="participant">Specifies the participant to play audio.</param>
/// <param name="url">Url where audio is located</param>
/// <returns></returns>
public async Task<Participant> PlayAudioToParticipant(string conferenceSid, Participant participant, string url)
{
Require.Argument("ConferenceSid", conferenceSid);
Require.Argument("CallSid", participant.CallSid);
Require.Argument("Url", url);
var request = new RestRequest(System.Net.Http.HttpMethod.Post);
request.Resource = RequestUri.ConferencePlayAudioToParticipantUri;
request.AddUrlSegment(RequestUriParams.ConferenceSid, conferenceSid);
request.AddUrlSegment(RequestUriParams.CallSid, participant.CallSid);
request.AddParameter("AudioUrl", url);
return await Execute<Participant>(request);
}
/// <summary>
/// Deaf participant of conference call
/// </summary>
/// <param name="conferenceSid">Conference sid</param>
/// <param name="participant">Specifies the participant to deaf.</param>
/// <param name="deaf">Deaf participant?</param>
/// <returns></returns>
public async Task<Participant> DeafParticipant(string conferenceSid, Participant participant, bool deaf)
{
Require.Argument("ConferenceSid", conferenceSid);
Require.Argument("CallSid", participant.CallSid);
var request = new RestRequest(System.Net.Http.HttpMethod.Post);
request.Resource = RequestUri.ConferenceParticipantActionUri;
request.AddUrlSegment(RequestUriParams.ConferenceSid, conferenceSid);
request.AddUrlSegment(RequestUriParams.CallSid, participant.CallSid);
request.AddParameter("Deaf", deaf);
return await Execute<Participant>(request);
}
/// <summary>
/// Hangup up current active call. Make POST request
/// </summary>
/// <param name="callSid">An alphanumeric string used for identification of calls.</param>
/// <returns></returns>
public async Task<Call> HangupCall(string callSid)
{
Require.Argument("CallSid", callSid);
var request = new RestRequest(System.Net.Http.HttpMethod.Post);
request.Resource = RequestUri.HangupCallUri;
request.AddUrlSegment(RequestUriParams.CallSid, callSid);
request.AddParameter("Status", HangupCallStatus.Completed.ToString().ToLower());
return await Execute<Call>(request);
}
/// <summary>
/// Helper method to populate Rest params
/// </summary>
/// <param name="audioOptions">Audio options</param>
/// <param name="request">Rest Request</param>
private void CreatePlayAudioOptions(PlayAudioOptions audioOptions, RestRequest request)
{
request.AddParameter("AudioUrl", audioOptions.AudioUrl);
if (audioOptions.Length.HasValue) request.AddParameter("Length", audioOptions.Length);
if (audioOptions.Leg.HasValue) request.AddParameter("Legs", audioOptions.Leg.ToString().ToLower());
if (audioOptions.Loop.HasValue) request.AddParameter("Loop", audioOptions.Loop);
if (audioOptions.Mix.HasValue) request.AddParameter("Mix", audioOptions.Mix);
}
/// <summary>
/// Helper method to populate Rest params
/// </summary>
/// <param name="callOptions">Call options</param>
/// <param name="request">Rest Request</param>
private void CreateCallOptions(CallOptions callOptions, RestRequest request)
{
request.AddParameter("To", callOptions.To);
request.AddParameter("From", callOptions.From);
request.AddParameter("Url", callOptions.Url);
if (callOptions.ForwardedFrom != null) request.AddParameter("ForwardedFrom", callOptions.ForwardedFrom);
if (callOptions.Method != null) request.AddParameter("Method", callOptions.Method.ToString().ToUpper());
if (callOptions.FallbackUrl != null) request.AddParameter("FallbackUrl", callOptions.FallbackUrl);
if (callOptions.FallbackMethod != null) request.AddParameter("FallbackMethod", callOptions.FallbackMethod.ToString().ToUpper());
if (callOptions.StatusCallback != null) request.AddParameter("StatusCallback", callOptions.StatusCallback);
if (callOptions.StatusCallbackMethod != null) request.AddParameter("StatusCallbackMethod", callOptions.StatusCallbackMethod.ToString().ToUpper());
if (callOptions.SendDigits != null) request.AddParameter("PlayDtmf", callOptions.SendDigits);
if (callOptions.Timeout.HasValue) request.AddParameter("Timeout", callOptions.Timeout);
if (callOptions.HideCallerId.HasValue) request.AddParameter("HideCallerId", callOptions.HideCallerId);
if (callOptions.HeartbeatUrl != null) request.AddParameter("HeartbeartUrl", callOptions.HeartbeatUrl);
if (callOptions.HeartbeatMethod.HasValue) request.AddParameter("HeartbeatMethod", callOptions.HeartbeatMethod.ToString().ToUpper());
if (callOptions.Record.HasValue) request.AddParameter("Record", callOptions.Record);
if (callOptions.RecordCallback != null) request.AddParameter("RecordCallback", callOptions.RecordCallback);
if (callOptions.RecordCallbackMethod.HasValue) request.AddParameter("RecordCallbackMethod", callOptions.RecordCallbackMethod.ToString().ToUpper());
if (callOptions.Transcribe.HasValue) request.AddParameter("Transcribe", callOptions.Transcribe);
if (callOptions.TranscribeCallback != null) request.AddParameter("TranscribeCallback", callOptions.TranscribeCallback);
}
/// <summary>
/// Start transcribe of external audio
/// </summary>
/// <param name="audioUrl">URL where the audio to be transcribed is located.</param>
/// <param name="quality">Specifies the transcription quality.</param>
/// <param name="transcribeCallback">URL that will be requested when the transcription has finished processing.</param>
/// <param name="callbackMethod">Specifies the HTTP method to use when requesting the TranscribeCallback URL.</param>
/// <returns></returns>
public async Task<Transcription> TranscribeAudio(string audioUrl, TranscriptionType? quality, string transcribeCallback, string callbackMethod)
{
Require.Argument("AudioUrl", audioUrl);
var request = new RestRequest(System.Net.Http.HttpMethod.Post);
request.Resource = RequestUri.TranscribeAudioUri;
request.AddParameter("AudioUrl", audioUrl);
if (quality.HasValue) request.AddParameter("Quality", quality.ToString().ToLower());
if (transcribeCallback != null) request.AddParameter("TranscribeCallback", transcribeCallback);
if (callbackMethod != null) request.AddParameter("CallbackMethod", callbackMethod);
return await Execute<Transcription>(request);
}
/// <summary>
/// Return list of recording transcriptions
/// </summary>
/// <param name="recordingSid">An alphanumeric string used for identification of recording.</param>
/// <param name="page">Used to return a particular page withing the list.</param>
/// <param name="pageSize">Used to specify the amount of list items to return per page.</param>
/// <returns></returns>
public async Task<TranscriptionResult> GetRecordingTranscriptions(string recordingSid, int? page, int? pageSize)
{
Require.Argument("RecordingSid", recordingSid);
var request = new RestRequest();
request.Resource = RequestUri.RecordingTranscriptionsUri;
request.AddUrlSegment("RecordingSid", RequestUriParams.RecordingSid);
if (page.HasValue) request.AddParameter("Page", page);
if (pageSize.HasValue) request.AddParameter("PageSize", pageSize);
return await Execute<TranscriptionResult>(request);
}
/// <summary>
/// Helper method to populate Rest params
/// </summary>
/// <param name="callListOptions">Call options</param>
/// <param name="request">Rest Request</param>
private void CreateCallListOptions(CallListOptions callListOptions, RestRequest request)
{
var startDateParameterName = GetParameterNameWithEquality(callListOptions.StartTimeComaparasion, "StartTime");
if (callListOptions.To != null) request.AddParameter("To", callListOptions.To);
if (callListOptions.From != null) request.AddParameter("From", callListOptions.From);
if (callListOptions.Status != null) request.AddParameter("Status", callListOptions.Status);
if (callListOptions.StartTime.HasValue) request.AddParameter(startDateParameterName, callListOptions.StartTime.Value.ToString("yyyy-MM-dd"));
if (callListOptions.Page.HasValue) request.AddParameter("Page", callListOptions.Page);
if (callListOptions.PageSize.HasValue) request.AddParameter("PageSize", callListOptions.PageSize);
}
/// <summary>
/// Get call recordings
/// </summary>
/// <param name="callSid">An alphanumeric string used to identify each call</param>
/// <param name="dateCreated">Lists all recordings created on or after a certain date</param>
/// <param name="dateCreatedComparasion">Date created comparasion</param>
/// <param name="page">Used to return a particular page withing the list.</param>
/// <param name="pageSize">Used to specify the amount of list items to return per page.</param>
/// <returns></returns>
public async Task<RecordingResult> GetCallRecordings(string callSid, DateTime? dateCreated, ComparisonType? dateCreatedComparasion, int? page, int? pageSize)
{
Require.Argument("CallSid", callSid);
var request = new RestRequest();
request.Resource = RequestUri.CallRecordingsUri;
request.AddUrlSegment(RequestUriParams.CallSid, callSid);
var dateCreatedParameterName = GetParameterNameWithEquality(dateCreatedComparasion, "DateCreated");
if (dateCreated.HasValue) request.AddParameter(dateCreatedParameterName, dateCreated.Value.ToString("yyyy-MM-dd"));
if (page.HasValue) request.AddParameter("Page", page);
if (pageSize.HasValue) request.AddParameter("PageSize", pageSize);
return await Execute<RecordingResult>(request);
}
/// <summary>
/// Helper method to populate Rest params
/// </summary>
/// <param name="voiceOptions">Voice effect options</param>
/// <param name="request">Rest Request</param>
private void CreateVoiceEffectsOptions(VoiceEffectOptions voiceOptions, RestRequest request)
{
if (voiceOptions.AudioDirection.HasValue) request.AddParameter("AudioDirection", voiceOptions.AudioDirection.ToString().ToLower());
if (voiceOptions.Pitch.HasValue) request.AddParameter("Pitch", voiceOptions.Pitch.Value.ToString(CultureInfo.InvariantCulture));
if (voiceOptions.PitchSemiTones.HasValue) request.AddParameter("PitchSemiTones", voiceOptions.PitchSemiTones.Value.ToString(CultureInfo.InvariantCulture));
if (voiceOptions.PitchOctaves.HasValue) request.AddParameter("PitchOctaves", voiceOptions.PitchOctaves.Value.ToString(CultureInfo.InvariantCulture));
if (voiceOptions.Rate.HasValue) request.AddParameter("Rate", voiceOptions.Rate.Value.ToString(CultureInfo.InvariantCulture));
if (voiceOptions.Tempo.HasValue) request.AddParameter("Tempo", voiceOptions.Tempo.Value.ToString(CultureInfo.InvariantCulture));
}
/// <summary>
/// Populate Rest request with application params
/// </summary>
/// <param name="application">Application object</param>
/// <param name="request">Rest request</param>
private void CreateApplicationParams(Application application, RestRequest request)
{
Require.Argument("FriendlyName", application.FriendlyName);
request.AddParameter("FriendlyName", application.FriendlyName);
if (application.VoiceUrl != null) request.AddParameter("VoiceUrl", application.VoiceUrl);
if (application.VoiceMethod != null) request.AddParameter("VoiceMethod", application.VoiceMethod);
if (application.VoiceFallbackUrl != null) request.AddParameter("VoiceFallbackUrl", application.VoiceFallbackUrl);
if (application.VoiceFallbackMethod != null) request.AddParameter("VoiceFallbackMethod", application.VoiceFallbackMethod);
if (application.VoiceCallerIdLookup != null) request.AddParameter("VoiceCallerIdLookup", application.VoiceCallerIdLookup);
if (application.SmsUrl != null) request.AddParameter("SmsUrl", application.SmsUrl);
if (application.SmsMethod != null) request.AddParameter("SmsMethod", application.SmsMethod);
if (application.SmsFallbackUrl != null) request.AddParameter("SmsFallbackUrl", application.SmsFallbackUrl);
if (application.SmsFallbackMethod != null) request.AddParameter("SmsFallbackMethod", application.SmsFallbackMethod);
if (application.HeartbeatUrl != null) request.AddParameter("HeartbeatUrl", application.HeartbeatUrl);
if (application.HeartbeatMethod != null) request.AddParameter("HeartbeatMethod", application.HeartbeatMethod);
if (application.HangupCallback != null) request.AddParameter("HangupCallback", application.HangupCallback);
if (application.HangupCallbackMethod != null) request.AddParameter("HangupCallbackMethod", application.HangupCallbackMethod);
}
/// <summary>
/// Add new Incoming Phone Number to your TelAPI account
/// </summary>
/// <param name="phoneNumber">Desired phone number to add to the account (E.164 format).</param>
/// <param name="areaCode">Desired area code of phone number to add to the account.</param>
/// <returns></returns>
public async Task<IncomingPhoneNumber> AddIncomingPhoneNumber(string phoneNumber, string areaCode)
{
Require.Argument("PhoneNumber", phoneNumber);
Require.Argument("AreaCode", areaCode);
var request = new RestRequest(System.Net.Http.HttpMethod.Post);
request.Resource = RequestUri.CreateIncomingPhoneNumber;
request.AddParameter("PhoneNumber", phoneNumber);
request.AddParameter("AreaCode", areaCode);
return await Execute<IncomingPhoneNumber>(request);
}
/// <summary>
/// Return list of all conference participants
/// </summary>
/// <param name="conferenceSid">Conference sid</param>
/// <param name="muted">Only list participants that are muted.</param>
/// <param name="deafed">Only list participants that are deaf.</param>
/// <param name="page">Used to return a particular page withing the list.</param>
/// <param name="pageSize">Used to specify the amount of list items to return per page.</param>
/// <returns></returns>
public async Task<List<Participant>> GetConferenceParticipants(string conferenceSid, bool? muted, bool? deafed, int? page, int? pageSize)
{
Require.Argument("ConferenceSid", conferenceSid);
var request = new RestRequest();
request.Resource = RequestUri.ConferenceParticipantsUri;
request.AddUrlSegment(RequestUriParams.ConferenceSid, conferenceSid);
if (muted.HasValue) request.AddParameter("Muted", muted);
if (deafed.HasValue) request.AddParameter("Deafed", deafed);
if (page.HasValue) request.AddParameter("Page", page);
if (pageSize.HasValue) request.AddParameter("PageSize", pageSize);
return await Execute<List<Participant>>(request);
}