public TwiMLResult Index(SmsRequest incomingMessage)
{
var messagingResponse = new MessagingResponse();
messagingResponse.Message("The Knative copy cat says: " + incomingMessage.Body);
return(TwiML(messagingResponse));
}
public ActionResult Index(SmsRequest request)
{
var response = new TwilioResponse();
response.Message("The Robots are coming! Head for the hills!");
return(TwiML(response));
}
public TwiMLResult Index(SmsRequest userRequest)
{
var response = new MessagingResponse();
DateTime currentDate = DateTime.Today;
var currentMonth = currentDate.Month.ToString();
var requestNumber = (userRequest.From).ToString().Split("+1")[1];
var userCategory = _context.UserCategories
.Include(x => x.Category)
.Include(x => x.ApplicationUser)
.FirstOrDefault(x => x.Category.Name == userRequest.Body && x.ApplicationUser.PhoneNumber == requestNumber);
var budgetedAmount = _context.UserCategories.Where(x => x.Category.Name == userRequest.Body).Sum(y => y.BudgetedAmount);
var actualAmount = _context.Transaction.Where(x => x.Category.Name == userRequest.Body && x.DateOccurred.Month.ToString() == currentMonth).Sum(y => y.Amount);
var remainingAmount = budgetedAmount - actualAmount;
if (userCategory != null)
{
response.Message("You have " + remainingAmount.ToString("c") + " remaining in your " + userCategory.Category.Name + " budget.");
}
else
{
response.Message("Sorry, you got the wrong number.");
}
return(TwiML(response));
}
public Message SmartReply(SmsRequest incomingMessage)
{
int companyId = FindCompanyId(incomingMessage.To);
var chat = unitOfWork.Chat.Find(f => f.PhoneNumber == incomingMessage.From && f.CompanyId == companyId).FirstOrDefault();
if (chat.SmartReplyState = Enums.SmartReplyActive)
{
var smartReplies = unitOfWork.SmartReply.Find(w => w.CompanyId == companyId);
if (smartReplies != null)
{
foreach (var item in smartReplies)
{
if (item.FullMatchOrContains == Enums.SmartReplyFullMatch)
{
if (item.Keyword.ToLower().Equals(incomingMessage.Body.ToLower()))
{
return(new Message(item.Answer));
}
}
else if (item.FullMatchOrContains == Enums.SmartReplyContains)
{
if (item.Keyword.ToLower().Contains(incomingMessage.Body.ToLower()))
{
return(new Message(item.Answer));
}
}
}
}
}
return(null);
}
public IActionResult Post([FromBody] SmsRequest data)
{
var senderService = new MessageSender();
var result = senderService.SendSMS(data.Number, data.Content);
return(this.Ok(result));
}
// handles incoming messages from users
public TwiMLResult Index(SmsRequest incomingMessage)
{
MessagingResponse messagingResponse = new MessagingResponse();
switch (incomingMessage.Body.ToLower().Trim())
{
case "reminders":
messagingResponse.Message("Work at 4:30PM");
break;
case "commands":
messagingResponse.Message(CommandListToString());
break;
case "time":
messagingResponse.Message(DateTime.Now.ToString());
break;
case "hello":
messagingResponse.Message("Whats up dude?");
break;
default:
messagingResponse.Message("No Command Exists");
break;
}
return(TwiML(messagingResponse));
}
public SmsResponse PingmePleasebySms(SmsRequest smsRequest)
{
SmsResponse smsResponse = new SmsResponse();
DatabaseStuff databaseStuff = new DatabaseStuff();
string request, response, streamResponse;
try
{
#region for wcf basic auth services
var hostIdentity = WindowsIdentity.GetCurrent().Name;
var primaryIdentity = ServiceSecurityContext.Current.PrimaryIdentity.Name;
var windowsIdentity = ServiceSecurityContext.Current.WindowsIdentity.Name;
var threadIdentity = Thread.CurrentPrincipal.Identity.Name;
//var isAdmin = Thread.CurrentPrincipal.IsInRole("admin");
#endregion
//todo: Implement the sms stuff in the wcf service
}
catch (Exception ex)
{
smsResponse.Success = false;
smsResponse.Message = "An error has occurred: " + ex.Message;
smsResponse.ApiMessageId = null;
smsResponse.SubmittedDateTime = null;
}
return(smsResponse);
}
public HttpResponseMessage Post(SmsRequest request)
{
var response = new TwilioResponse();
if (request.From == MyCell)
{
if (request.Body.ToLower().StartsWith("+1"))
{
response.Sms(request.Body.Substring(12),
new
{
to = request.Body.Substring(0, 12),
from = ThisNumber
});
}
response.Reject("invalid command");
}
else
{
response.Sms(request.From + ": " + request.Body,
new
{
to = MyCell,
from = ThisNumber
});
}
return(TWiML(response));
}
public void ShouldThrowWhenToNumberIsMissingOrInvalid()
{
// Arrange.
var restClient = new Mock <IRestClient>();
var restResponse = new RestResponse
{
StatusCode = HttpStatusCode.OK,
Content = RestResponses.Valid
};
restClient.Setup(mock => mock.Execute(It.IsAny <IRestRequest>())).Returns(restResponse);
var dispatcher = new ReachSmsDispatcher(
_logService.Object, restClient.Object, _configurationService.Object, _smsNumberFormatter, _smsMessageFormatters);
_smsRequest = new SmsRequestBuilder()
.WithMessageType(MessageTypes.SendAccountUnlockCode)
.WithTokens(_communicationTokens)
.WithToNumber(null)
.Build();
// Act.
Action action = () => dispatcher.SendSms(_smsRequest);
// Assert.
var exception = action.ShouldThrowExactly <DomainException>();
exception.WithMessage(ErrorCodes.SmsError);
exception.WithInnerException <ArgumentNullException>();
}
public ActionResult Index(SmsRequest request)
{
var response = new TwilioResponse();
response.Message("Hello, Mobile Monkey");
return(TwiML(response));
}
public TwiMLResult ReceiveSMS(SmsRequest incomingMessage)
{
var messagingResponse = new MessagingResponse();
messagingResponse.Message("The Magic 8 Ball has decided your question is worthy. To hear the answer, call +1PhoneNumber");
return(TwiML(messagingResponse));
}
public TwiMLResult Index(SmsRequest request)
{
var response = new MessagingResponse();
response.Message("Response received successfully");
//You have to enable login from other timezone / ip for your google account.
//to do this follow the link https://g.co/allowaccess and allow access by clicking the continue button.
//And that's it. Here you go. Now you will be able to login from any of the computer and by any means of app to your google account.
//https://www.google.com/settings/security/lesssecureapps
//
//
var smtpClient = new SmtpClient("smtp.gmail.com")
{
DeliveryMethod = SmtpDeliveryMethod.Network,
Host = "smtp.gmail.com",
Port = 587,
Credentials = new NetworkCredential("*****@*****.**", "strongpassword"),
EnableSsl = true,
};
var mailMessage = new MailMessage
{
From = new MailAddress("*****@*****.**"),
Subject = "Twilio WebHook " + DateTime.UtcNow.AddHours(-3),
Body = "<h3>SmsSid</h3><span>" + request.SmsSid + "</span></br><h3>From</h3><span>" + request.From + "</span></br><h3>Body</h3><span>" + request.Body + "</span></br><h3>OptOutType</h3><span>" + request.OptOutType + "</span></br>",
IsBodyHtml = true,
};
mailMessage.To.Add("*****@*****.**");
smtpClient.Send(mailMessage);
return(TwiML(response));
}
public SmsResult SendSms(string recipientMobileNumber, string message)
{
var settings = new JsonSerializerSettings {
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
request.AddHeader("Accept", "application/json");
request.AddHeader("Authorization", "############################"); //ToDo: Register on ClickATell and get your key - https://portal.clickatell.com/
var payload = new SmsRequest {
Messages = new List <MessageRequest>()
};
var messageRequest = new MessageRequest()
{
Channel = "sms", To = recipientMobileNumber, Content = message
};
payload.Messages.Add(messageRequest);
var jsonPayload = JsonConvert.SerializeObject(payload, Formatting.Indented, settings);
request.AddParameter("application/json", jsonPayload, ParameterType.RequestBody);
var response = _restClient.Execute(request);
var result = JsonConvert.DeserializeObject <SmsResult>(response.Content);
return(result);
}
public ActionResult Index(SmsRequest request)
{
var response = new TwilioResponse();
var zip = getValidZip(request, response);
if (zip == null)
{
response.Message("Please text your ZIP code.");
}
else
{
var legislators = getLegislators(zip);
if (legislators == null)
{
response.Message("Error getting results for " + zip);
}
else if (legislators.count == 0)
{
response.Message("Could not find results for " + zip);
}
else
{
foreach (var legislator in legislators.results)
{
response.Message("Your " + labelDict[legislator.chamber] + ": " +
getFullName(legislator) + " - " + legislator.phone + " - " +
legislator.oc_email);
}
}
}
return(TwiML(response));
}
private async Task <Uri> CreateSmsAsync(SmsRequest sms)
{
var response = await _client.PostAsJsonAsync(ControllerPath, sms);
response.EnsureSuccessStatusCode();
if (response.IsSuccessStatusCode)
{
var result = await response.Content.ReadAsAsync <MessageStateEnum>();
if (result == MessageStateEnum.Sent)
{
Console.WriteLine(" Sms successfully added");
}
else
{
Console.WriteLine(" Sms add failed");
}
}
else
{
Console.WriteLine(" Sms add failed");
}
// return URI of the created resource.
return(response.Headers.Location);
}
/// <summary>
/// Method for receicing replies via WebHook. Configure https://yourdomain.com/ in your twilio console
/// </summary>
/// <param name="incomingMessage"></param>
/// <returns></returns>
public async Task <TwiMLResult> Index(SmsRequest incomingMessage)
{
//Return message
var messagingResponse = new MessagingResponse();
try
{
//Convert input to message
var message = new MessageModel()
{
To = incomingMessage.To,
From = incomingMessage.From,
Body = incomingMessage.Body,
CreatedDate = DateTime.Now
};
//Process request
var reponse = await LoanRequestService.Process(message);
messagingResponse.Message(reponse.Body);
}
catch (Exception e)
{
Console.WriteLine(e);
messagingResponse.Message(e.Message);
}
return(TwiML(messagingResponse));
}
public TwiMLResult Index(SmsRequest request)
{
var response = new MessagingResponse();
response.Message("LA HACKS");
return(TwiML(response));
}
public TwiMLResult ReceiveSms([FromForm] SmsRequest req)
{
var curUser = csSettings.GetUserByPhone(req.From);
if (curUser == null)
{
return(SendMsgResp("I don't know you. "));
}
var name = !string.IsNullOrEmpty(curUser.Alias) ? curUser.Alias : CSSettings.GetDefAlias(curUser.EMail);
curUser.SetPersonIDByEmail(Context);
if (string.IsNullOrEmpty(req.Body))
{
return(SendMsgResp(name, "How can I help?"));
}
string reqStr = req.Body.Trim();
if (reqStr.Length == 0)
{
return(SendMsgResp(name, "How can I help?"));
}
var cmdMgr = new CmdMgr(Context, csSettings, HostEnv, Config, UserManager, curUser);
return(SendMsgResp(cmdMgr.ExecuteCmd(reqStr)));
}
public async System.Threading.Tasks.Task <TwiMLResult> IndexAsync(SmsRequest incomingMessage)
{
var messagingResponse = new MessagingResponse();
messagingResponse.Message("Thank you for using our rating system! You gave your event a " + incomingMessage.Body);
return(TwiML(messagingResponse));
}
public static void LogNumber(SmsRequest request)
{
if (request == null) return;
string from = request.From;
LogNumber(from);
}
private void Broadcast(SmsRequest request)
{
var message = request.Body;
var adminNumber = request.From;
this.broadcaster.Broadcast(message, this.groupManager.GetGroupByAdminPhoneNumber(adminNumber));
}
private async Task <string> GetXmlResultFromLookupAsync(string lookupString)
{
var ctrl = GetTestController();
var messageDict = new Dictionary <string, string> {
{ "body", lookupString }
};
var responseMock = new Response(System.Net.HttpStatusCode.Created, JsonConvert.SerializeObject(messageDict));
var twilioClientMock = new Mock <ITwilioRestClient>();
twilioClientMock.Setup(c => c.AccountSid).Returns("AccountSID");
twilioClientMock.Setup(c => c.Request(It.IsAny <Request>()))
.Returns(responseMock);
TwilioClient.SetRestClient(twilioClientMock.Object);
var message = new SmsRequest
{
To = "fakenumber",
Body = lookupString
};
var result = (await ctrl.Lookup(message)) as TwiMLResult;
Assert.IsNotNull(result);
return(result.Data.ToString());
}
public ActionResult Index(SmsRequest request)
{
// get the session varible if it exists
var counter = Session["counter"] != null ? (int)Session["counter"] : 0;
// increment it
counter++;
// save it
Session["counter"] = counter;
// make an associative array of senders we know, indexed by phone number
var people = new Dictionary <string, string>()
{
{ "+14158675308", "Curious George" },
{ "+12349013030", "Boots" },
{ "+12348134522", "Virgil" }
};
// if the sender is known, then greet them by name
var name = people.ContainsKey(Request.Form["From"])
? people[Request.Form["From"]]
: "Monkey";
var response = new TwilioResponse();
response.Message($"{name} has messaged {request.To} {counter} times");
return(TwiML(response));
}
static void Main(string[] args)
{
string username = GetInput("Username");
string password = GetInput("Password", true);
// Create a new SpryngHttpClient with the given Username and Password.
SpryngHttpClient client = SpryngHttpClient.CreateClientWithPassword(username, password);
// Get the amount of credits left in the account.
Console.WriteLine("Available Credits: {0}", client.GetCreditAmount());
// Make a new SmsRequest
SmsRequest request = new SmsRequest()
{
Destinations = new string[] { GetInput("Destination") },
Sender = GetInput("Sender"),
Body = GetInput("Body")
};
// Execute the Sms Request.
try
{
client.ExecuteSmsRequest(request);
Console.WriteLine("SMS has been send!");
}
catch (Exception ex)
{
Console.WriteLine("An Exception occured!\n{0}", ex.Message);
}
Console.ReadKey(true);
}
public void CreateGroup(SmsRequest incomingMessage)
{
bool unknownUser = false;
try
{
UserInfo userInfo = _context.UserInfo.Where(x => x.PhoneNumber == incomingMessage.From).First();
var user = _context.AspNetUsers.Where(x => x.Id == userInfo.UserId).First();
if (userInfo == null)
{
unknownUser = true;
throw new Exception();
}
StringReader reader = new StringReader(incomingMessage.Body);
string line = reader.ReadLine();
List <string> textParts = new List <string>();
while (line != null)
{
textParts.Add(line);
line = reader.ReadLine();
}
List <string> memberNames = new List <string>();
List <string> memberNumbers = new List <string>();
for (int i = 2; i < textParts.Count; i++)
{
if (i % 2 == 0)
{
memberNames.Add(textParts[i]);
}
else
{
memberNumbers.Add(textParts[i]);
}
}
Groups newGroup = new Groups(textParts[1], user.Id);
_context.Groups.Add(newGroup);
_context.SaveChanges();
for (int i = 0; i < memberNames.Count; i++)
{
GroupMembers newMember = new GroupMembers(memberNames[i], newGroup.GroupId, memberNumbers[i]);
_context.GroupMembers.Add(newMember);
_context.SaveChanges();
}
SendSuccessText(incomingMessage, $"You created the group '{textParts[1]}'");
}
catch (Exception)
{
if (unknownUser)
{
SendRegisterText(incomingMessage);
}
}
}
public void AddRSVPToDataBase(SmsRequest incomingMessage)
{
bool notANumber = false;
try
{
string[] textParts = incomingMessage.Body.Split(" ");
bool userRsvp = false;
var foundGroupMember = _context.GroupMembers.Where(x => x.PhoneNumber == incomingMessage.From).First();
int memberId = foundGroupMember.MemberId;
var foundEvent = _context.EventTable.Where(y => y.EventId == Int32.Parse(textParts[1])).First();
if (foundEvent == null)
{
notANumber = true;
throw new Exception();
}
int eventId = foundEvent.EventId;
string rsvpResponse = textParts[0].ToLower();
if (rsvpResponse.Contains("yes") || rsvpResponse == "y")
{
userRsvp = true;
}
//find if rsvp already exists in database
List <MemberRsvp> rsvpDupes = _context.MemberRsvp.Where(x => x.MemberId == memberId).Where(x => x.EventId == eventId).ToList();
//delete all found duplicates (should only be one).
if (rsvpDupes.Count > 0)
{
foreach (var r in rsvpDupes)
{
_context.MemberRsvp.Remove(r);
_context.SaveChanges();
}
}
MemberRsvp newRsvp = new MemberRsvp(memberId, eventId, userRsvp, foundGroupMember.MemberName);
_context.MemberRsvp.Add(newRsvp);
_context.SaveChanges();
}
catch (Exception)
{
if (notANumber)
{
SendText("That event number you entered wasn't valid. Could you try that again, please?", incomingMessage.From);
}
else
{
SendErrorText(incomingMessage, null);
}
}
}
public static BaseRequest GetRequest(this SMSSendEntity entity)
{
SmsRequest request = new SmsRequest(SmsCommandType.MT_REQUEST);
request.Sm = entity.SMSContent;
request.Da = entity.MobileNO.ToString();
return(request);
}
public async Task <TwiMLResult> IncomingMessage([FromForm] SmsRequest incomingMessage)
{
var response = await _messageProcessor.Process(new bitsmonkey.common.Models.IncomingMessage {
Query = incomingMessage.Body
});
return(TwiML(new MessagingResponse().Message(response)));
}
// GET: /<controller>/
public void Index(SmsRequest incomingMessage)
{
var messagingResponse = new MessagingResponse();
messagingResponse.Message(incomingMessage.Body);
_smsSender.ReceiveMessage(TwiML(messagingResponse));
}
public TwiMLResult ReceiveSms(SmsRequest incomingMessage)
{
var messagingResponse = new MessagingResponse();
messagingResponse.Message("Response: Hi how may I help you? : " + incomingMessage.Body);
return(TwiML(messagingResponse));
}
public TwiMLResult ReceiveSms([FromForm] SmsRequest incomingMessage)
{
var messagingResponse = new MessagingResponse();
messagingResponse.Message("Thank you. Your message was received.");
return(TwiML(messagingResponse));
}
public ActionResult txt2(SmsRequest request)
{
Demo.LogNumber(request);
TwilioRestClient t = new TwilioRestClient(Constants.SID, Constants.AuthToken);
t.InitiateOutboundCall(request.To, request.From, "http://onetugdemo.apphb.com/reftwilio/voice2");
TwilioResponse response = new TwilioResponse();
return TwiML(response);
}
public ActionResult txt1(SmsRequest request)
{
Demo.LogNumber(request);
var response = new TwilioResponse();
response.Sms(string.Format("You said '{0}'", request.Body));
Demo.Log("{0} says '{1}'", request.From, request.Body);
return TwiML(response);
}
public ActionResult chuck(SmsRequest request)
{
Demo.LogNumber(request);
var roundhouse = ChuckNorris.API.Random(null, new string[] { "explicit" });
var joke = roundhouse.Result.Text;
var response = new TwilioResponse();
response.Sms(joke);
Demo.Log("{0} got roundhoused '{1}'", request.From, joke);
return TwiML(response);
}
protected override SmsResponse SendSms(SmsRequest smsRequest)
{
try
{
Console.WriteLine("{0} numarasına - {1} içerik ile {2} Sms gönderildi.", smsRequest.Number, smsRequest.Content, ProviderName);
return new SmsResponse { ProviderMessage = "Success", SmsStatus = SmsStatus.Success };
}
catch (Exception e)
{
return new SmsResponse
{
ProviderMessage = string.Format("Fail..! - {0}", e),
SmsStatus = SmsStatus.Fail
};
}
}
