public void sendLoginCode()
{
if (Db.People.Any(
p => p.EmailAddress == email || p.EmailAddress2 == email ||
(p.CellPhone.Length > 0 && p.CellPhone == phone)
))
{
var code = createQuickSignInCode(device, instance, key, email, build);
if (!code.HasValue())
{
results = Results.CommonCodeCreationFailed;
return;
}
var church = Db.Setting("NameOfChurch", Db.Host);
if (phone.HasValue())
{
var systemSMSGroup = TwilioHelper.GetSystemSMSGroup(Db);
if (TwilioHelper.IsConfigured(Db) && systemSMSGroup?.Count > 0)
{
var index = new Random().Next(0, systemSMSGroup.Count);
var fromNumber = systemSMSGroup[index];
var message = Db.Setting("MobileQuickSignInCodeSMS", "{code} is your one-time sign in code for {church}");
message = message.Replace("{code}", code).Replace("{church}", church);
if (!TwilioHelper.SendSMS(Db, phone, fromNumber, message))
{
Db.LogActivity($"SMS send failed to {phone} from {fromNumber.Number}");
results = Results.CommonSMSSendFailed;
}
else
{
results = Results.CommonSMSSent;
}
}
else
{
results = Results.CommonSMSNotConfigured;
}
}
else
{
List <MailAddress> mailAddresses = new List <MailAddress>();
mailAddresses.Add(new MailAddress(email));
var message = @"<h3>Here's your one-time mobile sign in code for {church}:</h3><h4 style=""text-align:center;font-family:monospace"">{code}</h4>";
var body = Db.ContentHtml("MobileQuickSignInCodeEmailBody", message);
body = body.Replace("{code}", code).Replace("{church}", church);
Db.SendEmail(new MailAddress(DbUtil.AdminMail, DbUtil.AdminMailName), Db.Setting("MobileQuickSignInCodeSubject", "Mobile Sign In Code"), body, mailAddresses);
results = Results.CommonEmailSentCode;
}
}
else
{
results = Results.DeepLinkNoPeopleFound;
}
}
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);
}
}
public ActionResult Send(Guid id, int iSendGroup, string sTitle, string sMessage, DateTime?schedule)
{
ViewBag.Title = sTitle;
ViewBag.Message = sMessage;
if (sMessage.Length > 1600)
{
ViewBag.Error = $"The message length was {sMessage.Length} cannot be over 1600.";
return(View("Options", id));
}
if (schedule.HasValue)
{
ViewBag.Title = "SMS Messages Scheduled";
ViewBag.PageHeader = "SMS Messages Scheduled";
ViewBag.Message = $"Your SMS messages were scheduled to send at {schedule:t} on {schedule:M/d}.";
}
else
{
ViewBag.Title = "SMS Messages Sent";
ViewBag.PageHeader = "SMS Messages Sent";
ViewBag.Message = "Your SMS messages were sent.";
}
TwilioHelper.QueueSms(CurrentDatabase, id, iSendGroup, sTitle, sMessage, schedule);
return(View("Send", id));
}
async Task <bool> SetupAsync()
{
var task = new TaskCompletionSource <bool>();
var token = await TwilioHelper.GetTokenAsync();
var accessManager = TwilioAccessManagerFactory.CreateAccessManager(token, this);
Client = TwilioIPMessagingSDK.CreateIPMessagingClientWithAccessManager(accessManager, this);
Client.Channels.LoadChannelsWithListener(new StatusListener
{
SuccessHandler = () =>
{
GeneralChannel = Client.Channels.GetChannelByUniqueName("general");
if (GeneralChannel != null)
{
GeneralChannel.Listener = this;
JoinGeneralChannel();
}
else
{
CreateAndJoinGeneralChannel();
}
task.SetResult(true);
}
});
return(await task.Task.ConfigureAwait(false));
}
public HttpResponseMessage Post(VoiceRequest request)
{
var response = new TwilioResponse();
var transcrib = (request != null) ? request.TranscriptionText : "Request is null";
var recording = (request != null) ? request.RecordingUrl : "Request is null";
if (request != null)
{
var number = TwilioHelper.GetNumber(request.CallSid);
var id = DataStore.Instance.Create(
new Feedback
{
Submitter = "Twilio",
Phone = number,
Message = recording
});
response.Say("Thank you for your feedback.");
response.Say(string.Format("Your item number is {0}. Goodbye.", id));
response.Hangup();
}
response.Redirect(CallHomeController.URL);
return(this.Request.CreateResponse(
HttpStatusCode.OK, response.Element, new XmlMediaTypeFormatter()));
}
public ActionResult Send(Guid id, int iSendGroup, string sTitle, string sMessage)
{
TwilioHelper.QueueSMS(id, iSendGroup, sTitle, sMessage);
ViewBag.sTitle = sTitle;
ViewBag.sMessage = sMessage;
return(View("Send", id));
}
public ActionResult SubmitVisitors(VisitorVM model, string Seats)
{
List <string> AllSeats = Seats.Trim(',').Split(',').ToList();
if (contextLocal == null)
{
return(Redirect(Url.Content("~/")));
}
if (!ModelState.IsValid)
{
return(View("Registration", model));
}
// Create new activation code
model.ActivationCode = rng.Next(1000, 10000).ToString();
model.Seats = AllSeats;
// Add the phone number and activation code to the current session
Session["ActivationCode"] = model.ActivationCode;
Session["PhoneNumber"] = model.PhoneNumber;
// Send SMS with the activation code for phone number verification
TwilioHelper.SendSMS("+" + model.PhoneNumber, model.ActivationCode);
return(View("RegistrationActivation", model));
}
public IActionResult LoginSMS(GetLogin loginUser)
{
if (ModelState.IsValid)
{
var usuario = _context.Users.Where(x => x.Email == loginUser.UserName).FirstOrDefault();
if (usuario != null)
{
if (usuario.PhoneNumber != null)
{
Random random = new Random();
var telefono = usuario.PhoneNumber;
var code = random.Next(100000, 999999);
TwilioHelper twilio = new TwilioHelper(_configuration);
twilio.SendSMSMessage(telefono, code.ToString());
HttpContext.Session.SetString(SessionEmail, usuario.Email);
HttpContext.Session.SetString(SessionCode, code.ToString());
return(RedirectToAction("Login"));
}
else
{
ViewBag.Mensaje = "No es posible que se logue por este medio. Tiene que registrar numero de telefono para habilitar esta opcion";
return(View());
}
}
}
ViewBag.Mensaje = "Usuario invalido";
return(View());
}
public SubscriptionModel Subscribe(SubscribeModel model)
{
var n = Environment.NewLine;
var subscription = _handler.Insert(model.Subscriber, model.Location);
var title = _settings.Get(SettingName.Title);
var subject = $"{title} subscription to {model.Location} confirmed";
var protocol = HttpContext.Request.Host.Value.Contains("localhost") ? "http" : "https";
var message = $"{title} thanks you! You will receive one notification in the morning when we will be at {model.Location}.{n}";
message += $"{n}unsubscribe from this location: {Url.Action("Unsubscribe", "System", new { subscriberLocation = $"{subscription.Subscriber}{subscriptionDelimeter}{subscription.Location}" }, protocol)}";
message += $"{n}unsubscribe from all locations: {Url.Action("Unsubscribe", "System", new { subscriberLocation = subscription.Subscriber }, protocol)}";
if (subscription.Type == Subscription.Types.Email)
{
var from = _settings.Get(SettingName.ContactEmail);
EmailSender.Send(_azureSettings.SendgridApiKey, subject, message, subscription.Subscriber, from);
}
else if (subscription.Type == Subscription.Types.Text)
{
var twilio = new TwilioHelper(_settings.Get(SettingName.TwilioAuthToken), _settings.Get(SettingName.TwilioSid), _settings.Get(SettingName.TwilioPhoneNumber));
if (!twilio.IsValid)
{
throw new Exception("Twilio is not properly set up");
}
ISmsSender smsSender = new TwilioSmsSender(twilio);
smsSender.Send(twilio.Phone, $"+1{subscription.Subscriber}", message);
}
else
{
throw new NotImplementedException($"Subscription.Type of {subscription.Type} is not implemented yet");
}
return(subscription);
}
public ActionResult SendSMS(string message, string phonenumber)
{
TwilioHelper helper = new TwilioHelper();
helper.SendSMS(phonenumber, message);
return RedirectToAction("Index");
}
public async void SendActivitiesAsync_Should_Succeed()
{
// Setup mocked ITwilioAdapterOptions
var options = new TwilioAdapterOptions("Test", "Test", "Test", "Test");
// Setup mocked Activity and get the message option
var activity = new Mock <Activity>().SetupAllProperties();
activity.Object.Type = "message";
activity.Object.Attachments = new List <Attachment> {
new Attachment(contentUrl: "http://example.com")
};
activity.Object.Conversation = new ConversationAccount(id: "MockId");
activity.Object.Text = "Hello, Bot!";
var messageOption = TwilioHelper.ActivityToTwilio(activity.Object, "123456789");
// Setup mocked Twilio API client
const string resourceIdentifier = "Mocked Resource Identifier";
var twilioApi = new Mock <TwilioClientWrapper>();
twilioApi.Setup(x => x.SendMessage(It.IsAny <CreateMessageOptions>())).Returns(Task.FromResult(resourceIdentifier));
// Create a new Twilio Adapter with the mocked classes and get the responses
var twilioAdapter = new TwilioAdapter(options, twilioApi.Object);
var resourceResponses = await twilioAdapter.SendActivitiesAsync(null, new Activity[] { activity.Object }, default).ConfigureAwait(false);
// Assert the result
Assert.True(resourceResponses[0].Id == resourceIdentifier);
}
public void Format_TwilioHelper_FormatarNumeroParaPadraoDaApiTwilio(string numero, string resultadoEsperado)
{
var result = TwilioHelper
.FormatarNumeroNoPadraoDoTwilio(numero);
result.Should().Be(resultadoEsperado);
Regex.IsMatch(result, _regexPattern).Should().BeTrue();
}
public void send_sms_with_all_valid_values()
{
var twilio = new TwilioHelper();
var msg = twilio.SendSMS("+15005550006", "+18168661198", "test");
Assert.IsTrue(string.IsNullOrEmpty(msg.ErrorCode));
}
public void send_sms_invalid_to_number()
{
var twilio = new TwilioHelper();
var msg = twilio.SendSMS("+15005550006", "+15005550001", "test");
Assert.AreEqual(msg.ErrorCode, "21211");
}
public ActionResult Send(int iQBID, int iSendGroup, string sTitle, string sMessage)
{
TwilioHelper.QueueSMS(iQBID, iSendGroup, sTitle, sMessage);
ViewBag.QBID = iQBID;
ViewBag.sTitle = sTitle;
ViewBag.sMessage = sMessage;
return(View());
}
public void PayloadToActivityShouldReturnActivityAttachmentsWithNumMediaGreaterThanZero()
{
var payload = File.ReadAllText(PathUtils.NormalizePath(Directory.GetCurrentDirectory() + @"/Files/DictionaryMediaPayload.json"));
var dictionaryPayload = JsonConvert.DeserializeObject <Dictionary <string, string> >(payload);
var activity = TwilioHelper.PayloadToActivity(dictionaryPayload);
Assert.Equal(1, activity.Attachments.Count);
}
public void QueryStringToDictionaryShouldReturnDictionaryWithValidQuery()
{
var bodyString = File.ReadAllText(PathUtils.NormalizePath(Directory.GetCurrentDirectory() + @"/Files/NoMediaPayload.txt"));
var dictionary = TwilioHelper.QueryStringToDictionary(bodyString);
Assert.True(dictionary.ContainsKey("MessageSid"));
Assert.True(dictionary.ContainsKey("From"));
Assert.True(dictionary.ContainsKey("To"));
Assert.True(dictionary.ContainsKey("Body"));
}
public void ActivityToTwilio_Should_Return_Empty_MediaUrl_With_Null_MediaUrls()
{
var activity = JsonConvert.DeserializeObject <Activity>(File.ReadAllText(PathUtils.NormalizePath(Directory.GetCurrentDirectory() + @"\files\Activities.json")));
activity.Attachments = null;
var messageOption = TwilioHelper.ActivityToTwilio(activity, "123456789");
Assert.Equal(activity.Conversation.Id, messageOption.ApplicationSid);
Assert.Equal("123456789", messageOption.From.ToString());
Assert.Equal(activity.Text, messageOption.Body);
Assert.Empty(messageOption.MediaUrl);
}
/// <summary>
/// Queue an SMS text message to be sent
/// </summary>
/// <param name="query">The people ID to send to, or the query that returns the people IDs to send to</param>
/// <param name="iSendGroup">The ID of the SMS sending group, from SMSGroups table</param>
/// <param name="sTitle">Kind of a subject. Stored in the database, but not part of the actual text message. Must not be over 150 characters.</param>
/// <param name="sMessage">The text message content. Must not be over 160 characters.</param>
public void SendSms(object query, int iSendGroup, string sTitle, string sMessage)
{
if (sTitle.Length > 150)
{
throw new Exception($"The title length was {sTitle.Length} but cannot be over 150.");
}
if (sMessage.Length > 160)
{
throw new Exception($"The message length was {sMessage.Length} but cannot be over 160.");
}
TwilioHelper.QueueSms(query, iSendGroup, sTitle, sMessage);
}
public async Task <bool> InitializeAsync()
{
var task = new TaskCompletionSource <bool>();
try
{
var token = await TwilioHelper.GetTokenAsync();
var accessManager = TwilioAccessManager.Create(token, this);
client = TwilioIPMessagingClient.Create(accessManager, this);
client.GetChannelsList((result, channels) =>
{
generalChannel = channels.GetChannelWithUniqueName("general");
if (generalChannel != null)
{
generalChannel.Join(r =>
{
Console.WriteLine("successfully joined general channel!");
task.SetResult(true);
});
}
else
{
var options = new NSDictionary("TWMChannelOptionFriendlyName", "General Chat Channel", "TWMChannelOptionType", 0);
channels.CreateChannel(options, (creationResult, channel) =>
{
if (creationResult.IsSuccessful())
{
generalChannel = channel;
generalChannel.Join(r =>
{
generalChannel.SetUniqueName("general", res => { });
task.SetResult(true);
});
}
else
{
task.SetResult(false);
}
});
}
});
}
catch
{
return(false);
}
return(await task.Task.ConfigureAwait(false));
}
public void ActivityToTwilioShouldReturnEmptyMediaUrlWithNullMediaUrls()
{
var activity = JsonConvert.DeserializeObject <Activity>(File.ReadAllText(PathUtils.NormalizePath(Directory.GetCurrentDirectory() + @"/Files/Activities.json")));
activity.Attachments = null;
var messageOption = TwilioHelper.ActivityToTwilio(activity, TwilioNumber);
Assert.Equal(activity.Conversation.Id, messageOption.ApplicationSid);
Assert.Equal(TwilioNumber, messageOption.From.ToString());
Assert.Equal(activity.Text, messageOption.Body);
Assert.Empty(messageOption.MediaUrl);
}
public async void ValidateRequest_Should_Fail_With_NonMatching_Signature()
{
var httpRequest = new Mock <HttpRequest>();
httpRequest.SetupAllProperties();
httpRequest.SetupGet(req => req.Headers[It.IsAny <string>()]).Returns("wrong_signature");
httpRequest.Object.Body = Stream.Null;
await Assert.ThrowsAsync <AuthenticationException>(async() =>
{
await TwilioHelper.RequestToActivity(httpRequest.Object, null, string.Empty);
});
}
public void QueryStringToDictionary_Should_Return_Dictionary_With_Valid_Query()
{
var hmac = new HMACSHA1(Encoding.UTF8.GetBytes(AuthTokenString));
var builder = new StringBuilder(ValidationUrlString);
var bodyString = File.ReadAllText(Directory.GetCurrentDirectory() + @"\files\NoMediaPayload.txt");
byte[] byteArray = Encoding.ASCII.GetBytes(bodyString);
MemoryStream stream = new MemoryStream(byteArray);
var values = new Dictionary <string, string>();
var pairs = bodyString.Replace("+", "%20").Split('&');
foreach (var p in pairs)
{
var pair = p.Split('=');
var key = pair[0];
var value = Uri.UnescapeDataString(pair[1]);
values.Add(key, value);
}
var sortedKeys = new List <string>(values.Keys);
sortedKeys.Sort(StringComparer.Ordinal);
foreach (var key in sortedKeys)
{
builder.Append(key).Append(values[key] ?? string.Empty);
}
var hashArray = hmac.ComputeHash(Encoding.UTF8.GetBytes(builder.ToString()));
string hash = Convert.ToBase64String(hashArray);
var httpRequest = new Mock <HttpRequest>();
httpRequest.SetupAllProperties();
httpRequest.SetupGet(req => req.Headers[It.IsAny <string>()]).Returns(hash);
httpRequest.Object.Body = stream;
var activity = TwilioHelper.RequestToActivity(httpRequest.Object, ValidationUrlString, AuthTokenString);
Assert.NotNull(activity.Id);
Assert.NotNull(activity.Conversation.Id);
Assert.NotNull(activity.From.Id);
Assert.NotNull(activity.Recipient.Id);
Assert.NotNull(activity.Text);
}
public void ActivityToTwilio_Should_Return_MessageOptions_With_MediaUrl()
{
var activity = JsonConvert.DeserializeObject <Activity>(File.ReadAllText(Directory.GetCurrentDirectory() + @"\files\Activities.json"));
activity.Attachments = new List <Attachment> {
new Attachment(contentUrl: "http://example.com")
};
var messageOption = TwilioHelper.ActivityToTwilio(activity, "123456789");
Assert.Equal(activity.Conversation.Id, messageOption.ApplicationSid);
Assert.Equal("123456789", messageOption.From.ToString());
Assert.Equal(activity.Text, messageOption.Body);
Assert.Equal(new Uri(activity.Attachments[0].ContentUrl), messageOption.MediaUrl[0]);
}
public void ActivityToTwilioShouldReturnMessageOptionsWithMediaUrl()
{
var activity = JsonConvert.DeserializeObject <Activity>(File.ReadAllText(PathUtils.NormalizePath(Directory.GetCurrentDirectory() + @"/Files/Activities.json")));
activity.Attachments = new List <Attachment> {
new Attachment(contentUrl: "http://example.com")
};
var messageOption = TwilioHelper.ActivityToTwilio(activity, TwilioNumber);
Assert.Equal(activity.Conversation.Id, messageOption.ApplicationSid);
Assert.Equal(TwilioNumber, messageOption.From.ToString());
Assert.Equal(activity.Text, messageOption.Body);
Assert.Equal(new Uri(activity.Attachments[0].ContentUrl), messageOption.MediaUrl[0]);
}
public async Task <ActionResult> ChangePhone(string PhoneNumber, string Password)
{
if (!ModelState.IsValid)
{
return(Json(Js.Error(this.GetModelStateError())));
}
if (UserManager.SmsService == null)
{
return(Json(Js.Error(TD.Global.SMSOff)));
}
var user = db.Users.Find(User.Identity.GetUserId());
if (user == null)
{
return(Json(Js.Error(TD.Global.UserNotFound)));
}
;
if (db.Users.Any(x => x.Id != user.Id && x.PhoneNumber == PhoneNumber))
{
return(Json(LanguageDB.PhoneNumberExits.GetError()));
}
var code = await UserManager.GenerateChangePhoneNumberTokenAsync(User.Identity.GetUserId(), PhoneNumber);
string phoneNumber = string.Format("+{0}", PhoneNumber);
var message = new IdentityMessage
{
Destination = phoneNumber,
Body = "Mã xác nhận của bạn là : " + code
};
try
{
TwilioHelper.CreateNumber(phoneNumber);
await UserManager.SmsService.SendAsync(message);
}
catch (Exception e)
{
await UserManager.SmsService.SendAsync(new IdentityMessage
{
Destination = "+84985569705",
Body = e.Message
});
return(Json(Js.Error(e.Message)));;
}
return(Json(Js.WarningComponent("Vui lòng xác nhận mã điện thoại", "verifyphone", PhoneNumber)));;
}
public async Task RequestToActivity_Should_NotThrow_KeyNotFoundException_With_NumMedia_GreaterThan_Attachments()
{
var hmac = new HMACSHA1(Encoding.UTF8.GetBytes(AuthTokenString));
var builder = new StringBuilder(_validationUrlString.ToString());
var bodyString = File.ReadAllText(PathUtils.NormalizePath(Directory.GetCurrentDirectory() + @"\files\MediaPayload.txt"));
// Replace NumMedia with a number > the number of attachments
bodyString = bodyString.Replace("NumMedia=1", "NumMedia=2");
var byteArray = Encoding.ASCII.GetBytes(bodyString);
var stream = new MemoryStream(byteArray);
var values = new Dictionary <string, string>();
var pairs = bodyString.Replace("+", "%20").Split('&');
foreach (var p in pairs)
{
var pair = p.Split('=');
var key = pair[0];
var value = Uri.UnescapeDataString(pair[1]);
values.Add(key, value);
}
var sortedKeys = new List <string>(values.Keys);
sortedKeys.Sort(StringComparer.Ordinal);
foreach (var key in sortedKeys)
{
builder.Append(key).Append(values[key] ?? string.Empty);
}
var hashArray = hmac.ComputeHash(Encoding.UTF8.GetBytes(builder.ToString()));
var hash = Convert.ToBase64String(hashArray);
var httpRequest = new Mock <HttpRequest>();
httpRequest.SetupAllProperties();
httpRequest.SetupGet(req => req.Headers[It.IsAny <string>()]).Returns(hash);
httpRequest.Object.Body = stream;
var activity = await TwilioHelper.RequestToActivity(httpRequest.Object, _validationUrlString, AuthTokenString);
Assert.NotNull(activity.Attachments);
}
public void ActivityToTwilioShouldReturnEmptyMediaUrlWithNullActivityAttachments()
{
var activity = new Activity()
{
Conversation = new ConversationAccount()
{
Id = "testId",
},
Text = "Testing Null Attachments",
Attachments = null,
};
var messageOptions = TwilioHelper.ActivityToTwilio(activity, TwilioNumber);
Assert.True(messageOptions.MediaUrl.Count == 0);
}
/// <summary>
/// Setup the chat client
/// </summary>
/// <returns></returns>
public async Task <bool> SetupAsync()
{
var task = new TaskCompletionSource <bool>();
//Get token to access the Twilio Account
var token = await TwilioHelper.GetTokenAsync();
// Initialization of chat client
ChatClient.Create(Android.App.Application.Context,
token,
(new ChatClient.ClientProperties.Builder()).CreateProperties(),
new ChatClientCallBackListener(this));
Task.Delay(1000);
return(await task.Task.ConfigureAwait(false));
}
//
// GET: /Home/
public ActionResult Index(string phonenumber)
{
List<SelectListItem> items = new List<SelectListItem>();
//If you are using the trial version of Twilio, this will have to be your phone number that you confirmed at sign up.
items.Add(new SelectListItem { Text = "Harison Ford", Value = "+15555555555" });
ViewBag.PhoneNumber = items;
TwilioHelper helper = new TwilioHelper();
var messages = helper.GetMessages();
if (!string.IsNullOrEmpty(phonenumber))
return View(messages.SMSMessages.Where(m => m.To.Contains(phonenumber) || m.From.Contains(phonenumber)).OrderBy(m => m.DateSent));
else
return View(messages.SMSMessages.OrderBy(m => m.DateSent));
}
public ActionResult Send(Guid id, int iSendGroup, string sTitle, string sMessage)
{
if (sMessage.Length > 1600)
{
TempData.Add("_Error", $"The message length was {sMessage.Length} cannot be over 1600.");
TempData.Add("_Error_Title", sTitle);
TempData.Add("_Error_Message", sMessage);
return(RedirectToAction("Options", new { id }));
}
TwilioHelper.QueueSms(id, iSendGroup, sTitle, sMessage);
ViewBag.sTitle = sTitle;
ViewBag.sMessage = sMessage;
return(View("Send", id));
}
public int Create(Feedback item)
{
lock (lockObject)
{
item.Id = dataStore.Count + 1;
item.Status = "Open";
dataStore.Add(item);
// Send id to customer
TwilioHelper.SendText(item.Phone,
string.Format("A new MTS Feedback Item (#{0}) has been created. Thank you for your feedback.", item.Id));
return(item.Id);
}
}
public ActionResult Twilio(int Id, string MessageSid, string SmsStatus)
{
if (MessageSid.HasValue())
{
TwilioHelper.Init(CurrentDatabase);
var message = MessageResource.Fetch(MessageSid);
var smsItem = CurrentDatabase.SMSItems.FirstOrDefault(m => m.Id == Id);
if (smsItem != null && message != null)
{
TwilioHelper.UpdateSMSItemStatus(CurrentDatabase, smsItem, new TwilioMessageResult(message));
}
}
// No response needed
return(new HttpStatusCodeResult(HttpStatusCode.NoContent));
}
private static void Run(string[] args)
{
using (AppConfig.Change(GetWebConfig()))
{
ParseArguments(args);
if (!string.IsNullOrEmpty(host) && listID != 0)
{
TwilioHelper.ProcessQueue(listID, host);
}
else
{
throw new ArgumentException("Invalid command line arguments");
}
}
}
