private async Task <SendNotificationResult> SendNotificationAsync(Notification notification)
{
ValidateParameters(notification);
var result = new SendNotificationResult();
TwilioClient.Init(_options.AccountId, _options.AccountPassword);
try
{
var message = await MessageResource.CreateAsync(
body : notification.Body,
from : new Twilio.Types.PhoneNumber(_options.Sender),
to : notification.Recipient
);
result.IsSuccess = message.Status != MessageResource.StatusEnum.Failed;
if (!result.IsSuccess)
{
result.ErrorMessage = $"Twilio sending failed. Error code: {message.ErrorCode}. Error message: {message.ErrorMessage}.";
}
}
catch (ApiException e)
{
result.ErrorMessage = $"Twilio Error {e.Code} - {e.MoreInfo}. Exception: {e.Message}";
}
catch (Exception e)
{
result.ErrorMessage = $"Twilio sending failed. Exception: {e.Message}";
}
return(result);
}
public async Task SendSMSMessageAsync(string bodyText, string fromPhoneNumber, string toPhoneNumber)
{
var twilioRestClient = GetTwilioRestClient();
await MessageResource.CreateAsync(body : bodyText, from : new PhoneNumber(fromPhoneNumber), to : new PhoneNumber(toPhoneNumber), client : twilioRestClient).ConfigureAwait(false);
_logger.LogInformation("Sent Text Message {Body} From:{From} To: {To}", bodyText, fromPhoneNumber, toPhoneNumber);
}
public async Task <MessageResource> SendSMSAsync(string toPhoneNumber, string fromPhoneNumber, string message)
{
MessageResource messageResource = null;
try
{
TwilioClient.Init(AccountSID, AuthToken);
messageResource = await MessageResource.CreateAsync(body : message,
from : new PhoneNumber(fromPhoneNumber),
to : new PhoneNumber(toPhoneNumber));
}
catch (AuthenticationException e)
{
//Debug.WriteLine(e.Message);
throw e;
}
catch (ApiException e)
{
//Debug.WriteLine(e.Message);
//Debug.WriteLine($"Twilio Error {e.Code} - {e.MoreInfo}");
throw e;
}
return(messageResource);
}
public Task SendAsync(string number, string message)
{
if (string.IsNullOrWhiteSpace(SMSAccountFrom))
{
throw new ArgumentNullException();
}
if (string.IsNullOrWhiteSpace(SMSAccountIdentification))
{
throw new ArgumentNullException();
}
if (string.IsNullOrWhiteSpace(SMSAccountPassword))
{
throw new ArgumentNullException();
}
try
{
TwilioClient.Init(SMSAccountIdentification, SMSAccountPassword);
return(MessageResource.CreateAsync(
to: new PhoneNumber(number),
from: new PhoneNumber(SMSAccountFrom),
body: message));
}
catch (Exception e)
{
_logger.LogCritical(e, e.Message);
return(Task.CompletedTask);
}
}
public async Task SendMessageAsync(string message, string phoneNumber)
{
var messageResource = await MessageResource.CreateAsync(
to : new PhoneNumber(phoneNumber),
from : new PhoneNumber(_fromPhonenumber),
body : message, client : _client);
}
public async Task <string> SendSms(string messageContent, string phoneNumberTo)
{
try
{
// Find your Account Sid and Token at twilio.com/console
const string accountSid = AppConstants.TwilioAccountSid;
const string authToken = AppConstants.TwilioAuthToken;
const string phoneNumberFrom = AppConstants.TwilioFromPhoneNumber;
TwilioClient.Init(accountSid, authToken);
var message = await MessageResource.CreateAsync(
body : messageContent,
from : new Twilio.Types.PhoneNumber(phoneNumberFrom),
to : new Twilio.Types.PhoneNumber(phoneNumberTo)
);
Console.WriteLine(message.Sid);
return(messageContent);
}
catch (ApiException e)
{
Console.WriteLine(e.Message);
Console.WriteLine($"Twilio Error {e.Code} - {e.MoreInfo}");
return($"Twilio Error {e.Message} - {e.Code}");
}
}
private async static Task <MessageResource> SendTwilioMessageAsync(string fromPhone, string callbackUrl, List <Uri> attachmentMediaUrls, string twilioNumber, string messageText)
{
MessageResource response;
CreateMessageOptions createMessageOptions = new CreateMessageOptions(new TwilioTypes.PhoneNumber(twilioNumber))
{
From = new TwilioTypes.PhoneNumber(fromPhone),
Body = messageText
};
if (callbackUrl.IsNotNullOrWhiteSpace())
{
if (System.Web.Hosting.HostingEnvironment.IsDevelopmentEnvironment &&
!callbackUrl.Contains(".ngrok.io"))
{
createMessageOptions.StatusCallback = null;
}
else
{
createMessageOptions.StatusCallback = new Uri(callbackUrl);
}
}
if (attachmentMediaUrls != null && attachmentMediaUrls.Any())
{
createMessageOptions.MediaUrl = attachmentMediaUrls;
}
response = await MessageResource.CreateAsync(createMessageOptions).ConfigureAwait(false);
return(response);
}
public static async Task Main(string[] args)
{
// pull our account sid, auth token and the phone numbers from the usersecrets.json file
// in a production app we'd obviously want to store these in a secure spot like our appSettings
// or environmental variables.
// see https://www.twilio.com/blog/2018/05/user-secrets-in-a-net-core-console-app.html
// for more info on user secrets
var builder = new ConfigurationBuilder();
builder.AddUserSecrets <Program>();
var config = builder.Build();
var accountSid = config["twilio:accountSid"];
var authToken = config["twilio:authToken"];
var fromPhone = config["app:fromPhone"];
var toPhone = config["app:toPhone"];
TwilioClient.SetRestClient(new ChaosTwilioRestClient(new TwilioRestClient(accountSid, authToken), TimeSpan.FromSeconds(10)));
var policy = PollyPolicies.TwilioCircuitBreakerWrappedInRetryPolicy;
var message = await policy.ExecuteAsync(async() => await MessageResource.CreateAsync(
body: "Coming to you live from a very chaotic world!",
from: new Twilio.Types.PhoneNumber(fromPhone),
to: new Twilio.Types.PhoneNumber(toPhone)
));
Console.WriteLine($"Message sent! Sid: {message.Sid}");
Console.ReadLine();
}
public async Task <SmsResult> SendAsync(App app, string to, string body, string reference,
CancellationToken ct = default)
{
try
{
var callbackUrl = smsUrl.SmsWebhookUrl(app.Id, integrationId, new Dictionary <string, string>
{
["reference"] = reference,
["reference_number"] = to
});
var result = await MessageResource.CreateAsync(
ConvertPhoneNumber(to), null,
ConvertPhoneNumber(phoneNumber), null,
body,
statusCallback : new Uri(callbackUrl), client : twilioClient);
if (!string.IsNullOrWhiteSpace(result.ErrorMessage))
{
var errorMessage = string.Format(CultureInfo.CurrentCulture, Texts.Twilio_Error, to, result.ErrorMessage);
throw new DomainException(errorMessage);
}
return(SmsResult.Sent);
}
catch (Exception ex)
{
var errorMessage = string.Format(CultureInfo.CurrentCulture, Texts.Twilio_ErrorUnknown, to);
throw new DomainException(errorMessage, ex);
}
}
public async Task <MessageResource> SendMessageAsync(string to, string from, string body)
{
return(await MessageResource.CreateAsync(
to : new PhoneNumber(to),
from : new PhoneNumber(from),
body : body));
}
public async Task <Response> SendAsync(string receiver, string subject, string message, object data = null)
{
var response = new Response()
{
Successful = false
};
try
{
TwilioClient.Init(_option.AccountSID, _option.Token);
var res = await MessageResource.CreateAsync(
to : new PhoneNumber(receiver),
from : new PhoneNumber(_option.SendNumber),
body : message);
response = new Response()
{
Successful = true, Message = res.Sid
};
}
catch (Exception ex)
{
response.Message = ex.Message;
response.Error = ex;
}
return(response);
}
public Task SendAsync(IdentityMessage message)
{
//var accountSid = ConfigurationManager.AppSettings["SMSAccountIdentification"];
//var authToken = ConfigurationManager.AppSettings["SMSAccountPassword"];
//var fromNumber = ConfigurationManager.AppSettings["SMSAccountFrom"];
//TwilioClient.Init(accountSid, authToken);
//MessageResource result = MessageResource.Create(
// new PhoneNumber(message.Destination),
// from: new PhoneNumber(fromNumber),
// body: message.Body
//);
////Status is one of Queued, Sending, Sent, Failed or null if the number is not valid
//Trace.TraceInformation(result.Status.ToString());
////Twilio doesn't currently have an async API, so return success.
///
TwilioClient.Init(_accountSid, _authToken);
var result = MessageResource.CreateAsync(
body: message.Body,
from: new PhoneNumber(_fromNumber),
to: new PhoneNumber(message.Destination)
);
return(Task.FromResult(result));
}
public async Task SendMemory(string memoryToSend, string fromPhoneNumber, IEnumerable <string> phoneNumbers)
{
if (string.IsNullOrEmpty(memoryToSend) ||
string.IsNullOrEmpty(fromPhoneNumber))
{
return;
}
var parameterDictionary = await _parameterManagementService.RetrieveParameters(new List <string>
{
Constants.TwilioAccountSidKey,
Constants.TwilioAuthTokenKey,
Constants.TwilioPhoneNumberKey
});
// initialize client
TwilioClient.Init(parameterDictionary[Constants.TwilioAccountSidKey], parameterDictionary[Constants.TwilioAuthTokenKey]);
var textTaskList = new List <Task <MessageResource> >();
// send text(s)
foreach (var phoneNumber in phoneNumbers)
{
var textTask = MessageResource.CreateAsync(
body: memoryToSend,
from: new Twilio.Types.PhoneNumber(parameterDictionary[Constants.TwilioPhoneNumberKey]),
to: new Twilio.Types.PhoneNumber(phoneNumber)
);
textTaskList.Add(textTask);
}
// wait until done sending to all numbers
await Task.WhenAll(textTaskList);
}
/// <summary>
///
/// </summary>
/// <param name="pendingNotifications"></param>
/// <param name="log"></param>
public static void SendNotifications(List <NotificationModel> pendingNotifications, TraceWriter log)
{
TwilioClient.Init(ConfigurationManager.TwilioAccountId, ConfigurationManager.TwilioAccountSecret);
var messageIds = new List <string>();
foreach (var pendingNotification in pendingNotifications)
{
var responseUri = string.Format(ConfigurationManager.NotificationResponseRoute, pendingNotification.NotificationId, 2);
var shortenRequestModel = new ShortenRequestModel
{
LongUrl = responseUri,
GroupId = ConfigurationManager.BitlyGroupId
};
log.Info($"Response Uri : {responseUri}");
var shortenResponse = RestClient.PostAsync <ShortenResponseModel>(Constants.Common.BitlyHostName,
"/v4/shorten",
ConfigurationManager.BitlyKey,
JsonConvert.SerializeObject(shortenRequestModel)).GetAwaiter().GetResult();
log.Info($"Shorten Uri : {shortenResponse?.Link}");
var messageBody = $"{pendingNotification.Message} \n\n Please click : {(shortenResponse != null ? shortenResponse.Link : responseUri)} to optout.";
var messageId = MessageResource.CreateAsync(body: messageBody,
from: new Twilio.Types.PhoneNumber(ConfigurationManager.TwilioPhoneNumber),
to: new Twilio.Types.PhoneNumber(pendingNotification.PhoneNumber)).GetAwaiter().GetResult();
}
}
public static async Task SendSms(string msg, string to)
{
try
{
if (to == Number)
{
return;
}
// Find your Account Sid and Token at twilio.com/console
TwilioClient.Init(accountSid, authToken);
var message = await MessageResource.CreateAsync(
body : "SYSTEM:" + msg,
@from : new PhoneNumber(Number),
to : new PhoneNumber(to)
);
Console.WriteLine(message.Sid);
}
catch (Exception e)
{
Console.WriteLine("Error sending sms...");
Console.WriteLine(e);
}
}
public async Task <bool> SendSms(string toPhoneNumber, string message, string fromPhoneNumber = null)
{
var success = false;
try
{
var text = await MessageResource.CreateAsync(
body : message,
from : new Twilio.Types.PhoneNumber(fromPhoneNumber ?? _TwilioSettings.Value.PhoneNumber),
to : new Twilio.Types.PhoneNumber(toPhoneNumber)
);
if (text.Status != MessageResource.StatusEnum.Failed &&
text.Status != MessageResource.StatusEnum.Undelivered)
{
success = true;
}
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
}
return(success);
}
public async Task SendMessageAsync(string to, string body)
{
string sender = _configuration["Twilio:Sender"];
SMSLog log = new SMSLog
{
Sender = sender,
Recipient = to,
Text = body,
CreatedAt = DateTime.UtcNow
};
try
{
var message = await MessageResource.CreateAsync(
to : new PhoneNumber(to),
from : sender,
body : body);
log.Status = SendingStatus.Success;
}
catch (ApiException e)
{
log.Status = SendingStatus.Failed;
_logger.LogError($"Twilio Error {e.Code}({e.Message}) - {e.MoreInfo}");
throw new SystemException(e.Message);
}
finally
{
_unitOfWork.Repository <SMSLog>().Insert(log);
_unitOfWork.SaveChanges();
}
}
public async Task <bool> EnviarMensagemNotificacaoAsync(NotificacaoMensagemModel mensagem)
{
try
{
TwilioClient.Init(_twilioConfig.TwilioAccountSID,
_twilioConfig.TwilioAuthToken);
var msgResource = await MessageResource.CreateAsync(
from : new PhoneNumber($"whatsapp:{_twilioConfig.TwilioWhatsappNumber}"),
to : new PhoneNumber($"whatsapp:{TwilioHelper.FormatarNumeroNoPadraoDoTwilio(mensagem.Para)}"),
body : mensagem.Conteudo);
if (msgResource.Status == MessageResource.StatusEnum.Failed)
{
throw new Exception($"{msgResource.ErrorCode} - {msgResource.ErrorMessage}");
}
_logger.LogInformation($"Mensagem enviada para {msgResource.To} em {DateTime.Now}");
return(true);
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
return(false);
}
}
private async Task <string> NotifyRaffleWinner(RaffleEntry entry)
{
var msg = await MessageResource.FetchAsync(
entry.MessageSid,
_accountSid);
var response = await MessageResource.CreateAsync(
msg.From,
from : msg.To,
body : @"You've won the latest raffle. Visit the Twilio booth to pick up your prize. If you can't email [email protected]");
_notificationSid = response.Sid;
using (var httpClient = new HttpClient())
{
var data = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("winner", msg.From.ToString()),
new KeyValuePair <string, string>("raffleSid", LatestRaffle.Sid),
new KeyValuePair <string, string>("prize", LatestRaffle.Prize.Name)
});
var httpResponse = await httpClient.PostAsync("https://hooks.zapier.com/hooks/catch/3191324/o3o1bt1/", data);
httpResponse.EnsureSuccessStatusCode();
}
return(_notificationSid);
}
/// <summary> Send SMS(Twilio API) to mobile number with verification code, and verification link to verify the phone number directly from mobile</summary>
/// <returns>
/// true if sent successfully, else return false </returns>
public async Task <bool> SmsSender(string phoneNumber, string UserName, string token, string link)
{
try
{
// Convert the Number to be valid in Twilio API
var ToPhoneNumber = ConvertNumberToTwilioFormat(phoneNumber);
// if phone number is valid
if (!string.IsNullOrEmpty(ToPhoneNumber))
{
// Initialize the Twilio client
TwilioClient.Init(_SendSmsAccountSID, _SendSmsAuthToken);
// Send a new outgoing SMS by POSTing to the Messages resource
await MessageResource.CreateAsync(
// the phone number SMS API Twilio has a special format, it must not contain 00, for that change it to
// From number, must be an SMS-enabled Twilio number
from : new PhoneNumber(_SendSmsNumber),
to : new PhoneNumber(ToPhoneNumber),
// Message content
body : $"Hey {UserName} the tolken: {token} or click on this link: \n {link}"
);
return(true);
}
return(false);
}
catch (Exception)
{
return(false);
}
}
public async Task <MessageResource> SendMessage(string from, string to, string body)
{
var toPhoneNumber = new PhoneNumber(to);
MessageResource messageResource = await MessageResource.CreateAsync(toPhoneNumber, from : new PhoneNumber(from), body : body, client : this._client);
return(messageResource);
}
public async Task <bool> SendSmsAsync(SMSTextModel model)
{
if (string.IsNullOrWhiteSpace(model.From))
{
model.From = _config["Twilio:DefaultFrom"];
}
TwilioClient.Init(_accountSid, _authToken);
try
{
await MessageResource.CreateAsync
(
body :
model.Message,
from :
new Twilio.Types.PhoneNumber(model.From),
to :
new Twilio.Types.PhoneNumber(model.To)
);
_logger.LogInformation($"Sent an SMS message to {model.To} from {model.From}.");
}
catch (System.Exception)
{
_logger.LogError($"Failed to send an SMS message to {model.To} using phone number {model.From}.");
return(false);
}
return(true);
}
public override async Task SendAsync(string to, string body)
{
TwilioClient.Init(SmsProviderInfo.Sid, SmsProviderInfo.Token);
var destination = new PhoneNumber(to);
await MessageResource.CreateAsync(to, from : new PhoneNumber(SmsProviderInfo.From), body : body);
}
} // set only via Secret Manager
public async Task SendSmsAsync(string number, string message)
{
await MessageResource.CreateAsync(
to : new PhoneNumber(number),
from : new PhoneNumber(this.Options.From),
body : message);
}
public async Task <SmsServiceResponseDTO> SendVerificationCode(string phoneNumber, string code)
{
if (phoneNumber != null && code != null)
{
TwilioClient.Init(accountSid, authToken);
await MessageResource.CreateAsync(
body : code,
from : new Twilio.Types.PhoneNumber("+15017122661"),
to : new Twilio.Types.PhoneNumber($"{phoneNumber}"));
return(await Task.FromResult(new SmsServiceResponseDTO
{
StatusCode = 200,
Message = "Сообщения успешно отправлено"
}));
}
else
{
return(await Task.FromResult(new SmsServiceResponseDTO
{
StatusCode = 400,
Message = "Сообщение не было отправлено"
}));
}
}
private Task <MessageResource> SendInternalAsync(string phone, string message)
{
return(MessageResource.CreateAsync(
to: new PhoneNumber(phone),
from: new PhoneNumber(_configuration["TwilioPhoneNumber"]),
body: message));
}
public Task SendSmsAsync(string number, string message)
{
// Plug in your SMS service here to send a text message.
// Your Account SID from twilio.com/console
//var accountSid = Options.SMSAccountIdentification;
// Your Auth Token from twilio.com/console
//var authToken = Options.SMSAccountPassword;
//TwilioClient.SetUsername(accountSid);
//TwilioClient.SetPassword(authToken);
//TwilioClient.Init(accountSid, authToken);
TwilioClient.Init(_accountSid, _authToken);
return(MessageResource.CreateAsync(
to: new PhoneNumber("+84" + number),
from: new PhoneNumber(_sMSAccountFrom),
body: message));
/*
* return MessageResource.CreateAsync(
* to: new PhoneNumber("+84" + number),
* from: new PhoneNumber(Options.SMSAccountFrom),
* body: message);
*/
}
private async Task SendSms(string description, List <EmergencySkillset> requiredEmergencySkillsets)
{
const string accountSid = "21342135215321351"; // these are just random numbers
const string authToken = "1251809581058105"; // these are just random numbers
const string fromPhoneNumber = "208510538210"; // these are just random numbers
var skillsets = new List <Skillset>();
foreach (var requiredEmergencySkillset in requiredEmergencySkillsets)
{
skillsets.Add(requiredEmergencySkillset.Skillset);
}
var users = this.databaseContext.UserSkillsets
.Where(s => skillsets.Contains(s.Skillset))
.Select(s => s.User)
.ToList();
foreach (var user in users)
{
TwilioClient.Init(accountSid, authToken);
var message = await MessageResource.CreateAsync(
body : description,
from : new Twilio.Types.PhoneNumber(fromPhoneNumber),
to : new Twilio.Types.PhoneNumber(user.MobilPhone)
);
}
return;
}
public async void SendAsync <T>(Func <string, T> options) where T : class
{
try
{
if (options == null)
{
throw new ArgumentException(nameof(options));
}
TwilioClient.Init(_configuration.AccountSid, _configuration.AuthToken);
var code = _verificationCode.Generate(out var result);
var param = options.Invoke(code);
if (!(param is CreateMessageOptions))
{
return;
}
var msgOption = param as CreateMessageOptions;
var message = await MessageResource.CreateAsync(msgOption);
MessageSentHandler?.Invoke(result, message);
}
catch (Exception ex)
{
VerificationCodoeExceptionHandler?.Invoke(ex);
}
}
public async Task <bool> SendSms(MessageViewModel vm)
{
var accountSid = _twilioOptions.AccountSid;
var authToken = _twilioOptions.AuthToken;
TwilioClient.Init(accountSid, authToken);
var phoneNumber = new PhoneNumber(vm.To);
var message = "Want some Chuck Norris? Please respond with one of the following categories: Random, " + string.Join(", ", Enum.GetNames(typeof(JokeCategory)));
try
{
await MessageResource.CreateAsync(
to : phoneNumber,
from : new PhoneNumber(_twilioOptions.PhoneNumber),
body : message);
return(true);
}
catch (Exception exception)
{
LogHelper.Error($"MessageController:Post - CreateAsync Exceptioned with {exception.Message}");
}
return(false);
}
