static void Main(string[] args)
{
// Your Account SID from twilio.com/console
var accountSid = "AC66c6ae920b1c0db9acfe2cbf945f607a";
// Your Auth Token from twilio.com/console
var authToken = "64434993502cc71a95f188516ffc544f";
TwilioClient.Init(accountSid, authToken);
var message = MessageResource.Create(
to: new PhoneNumber("+923458638040"),
from: new PhoneNumber("+1 208-314-3389 "),
body: "Hello from C#");
Console.WriteLine(message.Sid);
Console.Write("Press any key to continue.");
Console.ReadKey();
//Publish to Github
}
public override bool SendMessage(string number, string message)
{
if (!number.StartsWith("+"))
{
number = "+" + number;
}
var twilioRestClient = new TwilioRestClient(TwilioLoginProvider.TwilioAccountSid, TwilioLoginProvider.TwilioAuthToken);
var smsMessage = MessageResource.Create(new PhoneNumber(number), body: message, from: new PhoneNumber(Sender), client: twilioRestClient);
Log.InfoFormat("SMS was sent to {0}, status: {1}", number, smsMessage.Status);
//if (smsMessage.RestException == null)
//{
// return true;
//}
//Log.Error("Failed to send sms message: " + smsMessage.RestException.Message);
return(false);
}
public static void SendSMS(string strPhoneNumber, string strBody)
{
// Find your Account Sid and Auth Token at twilio.com/user/account
string accountSid = GetSmsAccountSid();
//"AC283d289fa6894f38ed141d070fb1e0de";
string authToken = GetSmsAuthToken();
//"9dee64c9014a129f17d9298915369fb2";
// Initialize the Twilio client
TwilioClient.Init(accountSid, authToken);
// make an associative array of people we know, indexed by phone number
// Send a new outgoing SMS by POSTing to the Messages resource
MessageResource.Create(
from: new PhoneNumber(GetFromPhoneNumber()), // From number, must be an SMS-enabled Twilio number
to: new PhoneNumber(strPhoneNumber), // To number, if using Sandbox see note above
body: strBody); // Message content
}
private void OtpOperations()
{
//following code will generate OTP and will save it in OTP variable
var r = new Random();
_otp = r.Next(10000);
App.InitializeTwilioAccount();
var to = new PhoneNumber("+91" + _userPhoneNumber);
MessageResource.Create
(
to,
from: new PhoneNumber(Resource.TWILIO_PHONENUMBER),
body: "Thank you for creating account in Alexa Bank of India. Following is OTP for your account - " +
_otp
);
}
public ActionResult SendSms()
{
var accountSid = "AC74ec3e970780cfb5b8dae585125f2f21";
var authToken = "7c8bb8c522925c52ad29f6b32f682638";
TwilioClient.Init(accountSid, authToken);
var from = new PhoneNumber("+15005550006");
var phoneNumber = new PhoneNumber("+21623313606");
var message = MessageResource.Create(
body: "Test pi 28/11/2018 Daou Habib",
from: from,
to: phoneNumber
);
return(Content(message.Sid));
}
public Response <AssetDto> Post(AssetDto assetDto)
{
Response <AssetDto> response = new Response <AssetDto>();
try
{
AssetContext assetContext = new AssetContext();
response.Item = assetContext.SaveAsset(assetDto);
// Configure the Success response.
response.Code = OperationCode.ResponseCode.SUCCESS;
response.MessageList.Add(MessageResource.GetInstance().GetText("SawDAL_UpdateSuccess", MESSAGE_RESOURCE));
}
catch (Exception ex)
{
response.Code = OperationCode.ResponseCode.ERROR;
response.ErrorList.Add(MessageResource.GetInstance().GetText("SawDAL_UpdateInvalid", MESSAGE_RESOURCE));
}
return(response);
}
private void button5_Click(object sender, EventArgs e)
{
{
// Find your Account Sid and Token at twilio.com/console
// DANGER! This is insecure. See http://twil.io/secure
const string accountSid = "ACcac9d2c8905ff49a25a5482fac9ab034";
const string authToken = "be2b6048cf6cd819f1e3ad0d41288a6a";
TwilioClient.Init(accountSid, authToken);
var message = MessageResource.Create(
body: "",
from: new Twilio.Types.PhoneNumber("+19285698227"),
to: new Twilio.Types.PhoneNumber("+5514988162072")
);
Console.WriteLine(message.Sid);
}
}
public static void PrintSmsDetails(MessageResource pMessage)
{
Console.WriteLine("######################");
Console.WriteLine("{0,16}: {1}", "SID", pMessage.AccountSid);
Console.WriteLine("{0,16}: {1}", "From", pMessage.From);
Console.WriteLine("{0,16}: {1}", "To", pMessage.To);
Console.WriteLine("{0,16}: {1}", "Direction", pMessage.Direction);
Console.WriteLine("{0,16}: {1}", "Date Created", pMessage.DateCreated);
Console.WriteLine("{0,16}: {1}", "Date Sent", pMessage.DateSent);
Console.WriteLine("{0,16}: {1}", "Date Updated", pMessage.DateUpdated);
Console.WriteLine("{0,16}: {1}", "Body", pMessage.Body);
if (pMessage.ErrorCode != null || pMessage.ErrorMessage != null)
{
Console.WriteLine("/////////Error/////////");
Console.WriteLine("{0,16}: {1}", "Error Code", pMessage.ErrorCode);
Console.WriteLine("{0,16}: {1}", "Date Message", pMessage.ErrorMessage);
Console.WriteLine("/////////Error/////////");
}
Console.WriteLine("{0,16}: ${1}", "Price", pMessage.Price);
}
/// <summary>
/// Send a SMS message to the specified phone number.
/// You can specify instructions on how to respond separately from the main message body by including message options.
/// </summary>
/// <param name="toNumber">phone number to send the SMS to. Standard rates apply.</param>
/// <param name="messageBody">contents of the SMS message</param>
/// <param name="options">how the user is expected to reply</param>
/// <returns></returns>
public static MessageResource SendSMSMessage(string toNumber, string messageBody, List <MessageResponseOption> options = null)
{
//the paid account is not set up to handle sending text messages; there are no phone resources we can grab
TwilioClient.Init(TwilioTrialAccountSid, TwilioTrialAuthToken);
string optionsStr = (options == null) ? "" : GetTextOptions(options);
var phoneResource = GetTextPhoneResource();
var message = MessageResource.Create(
from: phoneResource.PhoneNumber,
to: new PhoneNumber(toNumber),
body: messageBody + optionsStr);
if (message.ErrorCode != null)
{
throw new Exception("Twilio encountered an error: " + message.ErrorCode + " - " + message.ErrorMessage);
}
return(message);
}
public void SendAndStoreSMS(SmsModel smsModel)
{
// TODO: store SMS in database, if required
// TODO: functionality for scheduled SMS events
var twilioAccountSid = Environment.GetEnvironmentVariable("TWILIO_ACCOUNT_SID");
var twilioAuthToken = Environment.GetEnvironmentVariable("TWILIO_AUTH_TOKEN");
TwilioClient.Init(twilioAccountSid, twilioAuthToken);
var message = MessageResource.Create(
body: smsModel.Body,
from: new PhoneNumber(smsModel.SendersPhoneNumber),
to: new PhoneNumber(smsModel.ReceiversPhoneNumber)
);
Console.WriteLine(message.Sid);
// TODO: return message response to contoller
}
public async Task GetMessageByIdHandler_ShouldReturnMessage_WhenMessageExists()
{
// Arrange
GetMessageByIdQuery request = new() { MessageId = 1 };
Message expectedMessage = new() { MessageId = 1 };
_unitOfWorkMock
.Setup(m => m.Messages.GetByIdAsync(request.MessageId))
.ReturnsAsync(expectedMessage);
GetMessageByIdQuery.Handler handler = new(_mapperMock, _unitOfWorkMock.Object, _userProviderMock.Object);
// Act
MessageResource message = await handler.Handle(request);
// Assert
Assert.NotNull(message);
}
}
public Task SendAsync(IdentityMessage message)
{
// Plug in your SMS service here to send a text message.
//var accountSid = ConfigurationManager.AppSettings["SMSAccountIdentification"];
//var authToken = ConfigurationManager.AppSettings["SMSAccountPassword"];
//var fromNumber = ConfigurationManager.AppSettings["SMSAccountFrom"];
var accountSid = "ACa8574533b3e522f0137793cf2460c87d";
var authToken = "8889f8f273a32a0b2656b4068572c975";
var fromNumber = "+17345266121";
TwilioClient.Init(accountSid, authToken);
MessageResource result = MessageResource.Create(
new PhoneNumber(message.Destination),
from: new PhoneNumber(fromNumber),
body: message.Body
);
Trace.TraceInformation(result.Status.ToString()); //Status is one of Queued, Sending, Sent, Failed or null if the number is not valid
return(Task.FromResult(0)); //Twilio doesn't currently have an async API, so return success.
}
protected override async Task <IResponse> SendTextMessage(string to, string from, string body)
{
try
{
TwilioClient.Init(_settings.GetConfigSetting <string>(SettingKeys.Messaging.TextMessages.Twilio.AccountSid), _settings.GetConfigSetting <string>(SettingKeys.Messaging.TextMessages.Twilio.Token));
// TODO: ApplicationSid? MessagingServiceSid?
var message = await MessageResource.CreateAsync(
new PhoneNumber(to),
messagingServiceSid : _settings.GetConfigSetting <string>(SettingKeys.Messaging.TextMessages.Twilio.ServiceSid),
body : body);
return(GetResponse(!message.ErrorCode.HasValue, message.ErrorMessage));
}
catch (Exception ex)
{
//_logger.Log(LogCategory.Error, new Exception("Failed to send SMS", ex));
return(GetResponse(false, ex.Message));
}
}
public Task SendAsync(IdentityMessage message)
{
// Plug in your SMS service here to send a text message.
//Twilio Begin
TwilioClient.Init(Keys.SMSAccountIdentification, Keys.SMSAccountPassword);
var m = MessageResource.Create(
to: new PhoneNumber(message.Destination),
from: new PhoneNumber(Keys.SMSAccountFrom),
body: message.Body);
//Twilio End
return(Task.FromResult(0));
}
public void TestReadRequest()
{
var twilioRestClient = Substitute.For <ITwilioRestClient>();
var request = new Request(
HttpMethod.Get,
Twilio.Rest.Domain.Conversations,
"/v1/Conversations/CHXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/Messages",
""
);
twilioRestClient.Request(request).Throws(new ApiException("Server Error, no content"));
try
{
MessageResource.Read("CHXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", client: twilioRestClient);
Assert.Fail("Expected TwilioException to be thrown for 500");
}
catch (ApiException) {}
twilioRestClient.Received().Request(request);
}
public async Task <long> SendCode(string phoneNumber, CancellationToken cancellationToken)
{
var user = await _oauthUserRepository.FindOAuthUserByClaim(Jwt.Constants.UserClaims.PhoneNumber, phoneNumber, cancellationToken);
if (user == null)
{
throw new BaseUIException(Exceptions.ErrorCodes.UNKNOWN_PHONENUMBER);
}
var otpAuthenticator = GetOTPAuthenticator();
var otpCode = otpAuthenticator.GenerateOtp(user);
TwilioClient.Init(_smsHostOptions.AccountSid, _smsHostOptions.AuthToken);
await MessageResource.CreateAsync(
body : string.Format(_smsHostOptions.Message, otpCode),
from : new PhoneNumber(_smsHostOptions.FromPhoneNumber),
to : new PhoneNumber(phoneNumber));
return(otpCode);
}
public SmsSenderResponse Send(SmsSenderRequest request)
{
TwilioClient.Init(_accountSid, _authToken);
//body content gibi bir tablodan gelebilir
var message = MessageResource.Create(
body: request.Body,
from: new Twilio.Types.PhoneNumber(request.From),
to: new Twilio.Types.PhoneNumber(request.To)
);
return(new SmsSenderResponse
{
MessageId = message.Sid,
Success = message.ErrorCode == null ? true : false, //test et burası değişsin
ErrorCode = message.ErrorCode,
ErrorMessage = message.ErrorMessage
});
}
public async Task <IActionResult> SendVerificationCode()
{
try
{
var user = await UserService.GetByIdAsync(User.GetUserId());
await UserService.DisableUserPhoneNumberVerificationTokens(User.GetUserId());
var verificationCode = UserService.GenerateNewPhoneNumberVerificationToken(User.GetUserId());
TwilioClient.Init(_twillioClient.CurrentValue.Sid, _twillioClient.CurrentValue.AuthToken);
var message = await MessageResource.CreateAsync(body : string.Format(_localizer.VerifyPhoneNumberFormat, verificationCode), from : new PhoneNumber("+13343264225"), to : new PhoneNumber(user.PhoneNumber));
ViewData["success"] = _localizer.VerifyPhoneNumberCodeSent;
}
catch (Exception e)
{
ViewData["error"] = _localizer.ErrorVerifyPhoneNumberCodeSent;
}
return(View("_VerifyPhoneNumber"));
}
public MessageResource WriteNewNotification(DAL.Notification notification, MessageStatus messageStatus = MessageStatus.Default)
{
string result = MessageDistributor(messageStatus, notification);
MessageResource message = null;
try
{
message = MessageResource.Create(
body: result,
from: new Twilio.Types.PhoneNumber(_PhoneNumber),
to: new Twilio.Types.PhoneNumber(notification.Num_Phone)
);
}
catch (Exception e)
{
//Twillio Error
}
return(message);
}
static string VerificationAccount(User user)
{
// Find your Account Sid and Token at twilio.com/console
const string accountSid = "AC9dc0d107f661a29db6e2db341af2beb4";
const string authToken = "d7d8170696c1de5bda1e96b4a9347018";
Random rnd = new Random();
string code = Convert.ToString(rnd.Next(100, 1000));
TwilioClient.Init(accountSid, authToken);
var message = MessageResource.Create(
from: new Twilio.Types.PhoneNumber("+18432585652"),
body: code,
to: new Twilio.Types.PhoneNumber(user.PhoneNumber) // user.PhoneNumber
);
// Console.WriteLine(message.Sid);
return(code);
}
public void Send(string id, string to, string body, bool retry = true)
{
try {
MessageResource.Create(
new PhoneNumber(to),
@from: new PhoneNumber(id),
body: body
);
} catch (ApiException ex) {
if (ex.Code == AlphaNumericNotSupportedCode && retry)
{
this._logger.LogInformation("Unable to send message using alpha-numeric ID. Trying with phone number..");
this.Send(this._settings.PhoneNumber, to, body, false);
}
else
{
this._logger.LogInformation($"Unable to send text message: {ex.Message}");
}
}
}
protected override void SendMessage(string logMessage)
{
if (!IsConfigured)
{
throw new ArgumentException($"{nameof( TwilioSink )} is not configured");
}
foreach (var rn in RecipientNumbers !)
{
try
{
MessageResource.Create(body: logMessage, to: rn, @from: FromNumber);
}
catch (Exception e)
{
throw new
InvalidOperationException($"Could not create Twilio message. Exception message was '{e.Message}'");
}
}
}
//Twilio
public Task SendAsync(IdentityMessage wiadomosc)
{
// Twilio Begin
var accountSid = ConfigurationManager.AppSettings["123"];
var authToken = ConfigurationManager.AppSettings["123"];
var fromNumber = ConfigurationManager.AppSettings["Bookly"];
TwilioClient.Init(accountSid, authToken);
MessageResource result = MessageResource.Create(
new PhoneNumber(wiadomosc.Destination),
from: new PhoneNumber(fromNumber),
body: wiadomosc.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.
return(Task.FromResult(0));
}
static void Main(string[] args)
{
// Find your Account Sid and Token at twilio.com/console
// DANGER! This is insecure. See http://twil.io/secure
const string accountSid = "ACXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
const string authToken = "your_auth_token";
TwilioClient.Init(accountSid, authToken);
var messages = MessageResource.Read(
pathServiceSid: "ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
pathChannelSid: "CHXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
limit: 20
);
foreach (var record in messages)
{
Console.WriteLine(record.Sid);
}
}
public ResponseData SendSMS(string toPhone, int code)
{
try
{
var response = MessageResource.Create(
to: toPhone,
from: new PhoneNumber("+12563804125"),
body: "Your Verification Code is " + code
);
return(new ResponseData {
Status = true, Message = "Message has been sent!"
});
}
catch (Exception ae)
{
return(new ResponseData {
Status = false, Message = ae.Message.ToString()
});
}
}
public ActionResult SendSMS(string[] phoneNumbers, string textMessage)
{
var accountsid = "AC1e234cf4a6742315d15d6d0f457c3d55";
var authToken = "8f0c777ebd152c1145b6c90f82d29ac4";
TwilioClient.Init(accountsid, authToken);
var from = new PhoneNumber("+14193703444");
foreach (var number in phoneNumbers)
{
var message = MessageResource.Create(
to: "+1" + number,
from: from,
body: textMessage + " (Please do not respond to this phone number. Instead, please contact 4192350626. Thanks!)"
);
}
return(RedirectToAction("Communications", "Home"));
}
public void TestCreateRequest()
{
var twilioRestClient = Substitute.For <ITwilioRestClient>();
var request = new Request(
HttpMethod.Post,
Twilio.Rest.Domain.Chat,
"/v2/Services/ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/Channels/CHXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/Messages",
""
);
twilioRestClient.Request(request).Throws(new ApiException("Server Error, no content"));
try
{
MessageResource.Create("ISXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "CHXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", client: twilioRestClient);
Assert.Fail("Expected TwilioException to be thrown for 500");
}
catch (ApiException) {}
twilioRestClient.Received().Request(request);
}
public Task SendAsync(IdentityMessage message)
{
// Find your Account Sid and Auth Token at twilio.com/console
string accountSid = ConfigurationManager.AppSettings["SMSAccountIdentification"];
string authToken = ConfigurationManager.AppSettings["SMSAccountPassword"];
TwilioClient.Init(accountSid, authToken);
var to = new PhoneNumber("+15017250604");
var result = MessageResource.Create(
to: message.Destination,
from: ConfigurationManager.AppSettings["SMSAccountFrom"],
body: message.Body);
// Status is one of Queued, Sending, Sent, Failed or null if the number is not valid
// Trace.TraceInformation(result.Status);
// Twilio doesn't currently have an async API, so return success.
return(Task.FromResult(0));
// Twilio End
}
public void TestFetchRequest()
{
var twilioRestClient = Substitute.For <ITwilioRestClient>();
var request = new Request(
HttpMethod.Get,
Twilio.Rest.Domain.IpMessaging,
"/v1/Services/ISaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Channels/CHaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/Messages/IMaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
""
);
twilioRestClient.Request(request).Throws(new ApiException("Server Error, no content"));
try
{
MessageResource.Fetch("ISaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "CHaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "IMaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", client: twilioRestClient);
Assert.Fail("Expected TwilioException to be thrown for 500");
}
catch (ApiException) {}
twilioRestClient.Received().Request(request);
}
public IActionResult OrderConfirmation(int id)
{
OrderHeader orderHeader = _unitOfWork.OrderHeader.GetFirstOrDefault(x => x.Id == id);
TwilioClient.Init(_twilioOptions.AccountSid, _twilioOptions.AuthToken);
try
{
var message = MessageResource.Create(
body: "Order Placed on RNCBook,Your Order ID : " + id + " Order Price : " + orderHeader.OrderTotal + " TL",
from: new Twilio.Types.PhoneNumber(_twilioOptions.PhoneNumber),
to: new Twilio.Types.PhoneNumber(orderHeader.PhoneNumber)
);
}
catch (Exception ex)
{
//
}
return(View(id));
}
