public virtual async Task <HttpResponseMessage> Post([FromBody] Microsoft.Bot.Connector.Activity activity)
{
if (activity != null)
{
switch (activity.GetActivityType())
{
case ActivityTypes.Message:
await Conversation.SendAsync(activity, () => new RootDialog(_userService));
//await Conversation.SendAsync(activity, MakeRootDialog);
break;
case ActivityTypes.ConversationUpdate:
case ActivityTypes.ContactRelationUpdate:
case ActivityTypes.Typing:
case ActivityTypes.DeleteUserData:
default:
Trace.TraceError($"Unknown activity type ignored: {activity.GetActivityType()}");
break;
}
}
var response = Request.CreateResponse(HttpStatusCode.OK);
return(response);
}
/// <summary>
/// POST: api/Messages
/// receive a message from a user and send replies
/// </summary>
/// <param name="activity"></param>
public virtual async Task <HttpResponseMessage> Post([FromBody] Microsoft.Bot.Connector.Activity activity)
{
if (activity != null)
{
// Check if activity is of type message
if (activity.GetActivityType() == ActivityTypes.Message)
{
await Conversation.SendAsync(activity, () => new RootDialog(appointment, shop));
}
else
{
Trace.TraceError($"Unknown activity type ignored: {activity.GetActivityType()}");
}
// one of these will have an interface and process it
//switch (activity.GetActivityType())
//{
// case ActivityTypes.Message:
// await Conversation.SendAsync(activity, MakeRootDialog);
// break;
// case ActivityTypes.ConversationUpdate:
// case ActivityTypes.ContactRelationUpdate:
// case ActivityTypes.Typing:
// case ActivityTypes.DeleteUserData:
// default:
// Trace.TraceError($"Unknown activity type ignored: {activity.GetActivityType()}");
// break;
//}
}
return(new HttpResponseMessage(System.Net.HttpStatusCode.Accepted));
}
/// <summary>
/// POST: api/Messages
/// Receive a message from a user and reply to it
/// </summary>
//public async Task<HttpResponseMessage> Post([FromBody]Activity activity)
//{
// if (activity.GetActivityType() == ActivityTypes.Message)
// {
// await Conversation.SendAsync(activity, () => new Dialogs.RootDialog());
// }
// else
// {
// HandleSystemMessage(activity);
// }
// var response = Request.CreateResponse(HttpStatusCode.OK);
// return response;
//}
private Microsoft.Bot.Connector.Activity HandleSystemMessage(Microsoft.Bot.Connector.Activity message)
{
string messageType = message.GetActivityType();
if (messageType == ActivityTypes.DeleteUserData)
{
// Implement user deletion here
// If we handle user deletion, return a real message
}
else if (messageType == ActivityTypes.ConversationUpdate)
{
// Handle conversation state changes, like members being added and removed
// Use Activity.MembersAdded and Activity.MembersRemoved and Activity.Action for info
// Not available in all channels
}
else if (messageType == ActivityTypes.ContactRelationUpdate)
{
// Handle add/remove from contact lists
// Activity.From + Activity.Action represent what happened
}
else if (messageType == ActivityTypes.Typing)
{
// Handle knowing that the user is typing
}
else if (messageType == ActivityTypes.Ping)
{
}
return(null);
}
public virtual async Task <HttpResponseMessage> Post([FromBody] Microsoft.Bot.Connector.Activity activity)
{
try
{
if (activity != null && activity.GetActivityType() == ActivityTypes.Message)
{
// Get and process
IMessageActivity message = activity.AsMessageActivity();
ActivityRequest request = new ActivityRequest(
recipient: message.Recipient.Name,
text: message.Text,
from: message.From.Name,
fromId: message.From.Id,
channelId: message.ChannelId,
conversationId: message.Conversation.Id,
isGroup: message.Conversation.IsGroup,
attachments: message.Attachments?.Select(
attachment => new AttachmentRequest(attachment.ContentUrl, attachment.ContentType)
));
ActivityResponse response = await this.ActivityProcessor.ProcessActivityAsync(this.Store, request).ConfigureAwait(false);
// Reply (on a new network connection) back.
Microsoft.Bot.Connector.Activity reply = activity.CreateReply();
reply.Text = response.Text;
foreach (AttachmentResponse attachment in response.Attachments)
{
reply.Attachments.Add(new Attachment(attachment.ContentType, attachment.ContentUrl, null, attachment.Name));
}
// Send it either as a group message or individually, depending on how we received the message,
using (ConnectorClient connector = new ConnectorClient(new Uri(activity.ServiceUrl)))
{
if (message.Conversation.IsGroup.HasValue && message.Conversation.IsGroup.Value)
{
await connector.Conversations.SendToConversationAsync(reply);
}
else
{
await connector.Conversations.ReplyToActivityAsync(reply);
}
}
}
}
catch (Exception ex)
{
using (ConnectorClient connector = new ConnectorClient(new Uri(activity.ServiceUrl)))
{
Microsoft.Bot.Connector.Activity reply = activity.CreateReply();
reply.Text = ex.Message + " " + ex.StackTrace;
await connector.Conversations.ReplyToActivityAsync(reply);
}
}
// We always accept the message and send the response using the bot framework on another channel.
return(new HttpResponseMessage(HttpStatusCode.Accepted));
}
public async Task <IHttpActionResult> Post([FromBody] Activity activity)
{
// check if activity is of type message
if (activity != null && activity.GetActivityType() == ActivityTypes.Message)
{
await Conversation.SendAsync(activity, () => new RootDialog());
}
else
{
HandleSystemMessage(activity);
}
return(Ok());
}
public virtual async Task <HttpResponseMessage> Post([FromBody] Activity activity)
{
// check if activity is of type message
if (activity.GetActivityType() == ActivityTypes.Message)
{
await Conversation.SendAsync(activity, () => new RootDialog());
}
else
{
HandleSystemMessage(activity);
}
return(new HttpResponseMessage(System.Net.HttpStatusCode.Accepted));
}
public virtual async Task <IActionResult> Post([FromBody] Activity activity)
{
if (activity != null)
{
// one of these will have an interface and process it
switch (activity.GetActivityType())
{
case ActivityTypes.Message:
await Conversation.SendAsync(activity, () => new EchoDialog());
break;
case ActivityTypes.ConversationUpdate:
case ActivityTypes.ContactRelationUpdate:
case ActivityTypes.Typing:
case ActivityTypes.DeleteUserData:
default:
Trace.TraceError($"Unknown activity type ignored: {activity.GetActivityType()}");
break;
}
}
return(StatusCode((int)HttpStatusCode.Accepted));
}
/// <summary>
/// Handles activity of all types except for messages
/// TODO: Note sure why / how this function ever gets called
/// </summary>
/// <param name="activity"></param>
private async void HandleSystemMessage(Activity activity)
{
if (activity == null)
{
return;
}
switch (activity.Type)
{
case ActivityTypes.Message:
await PostMessage(activity);
break;
case ActivityTypes.DeleteUserData:
// Implement user deletion here
// If we handle user deletion, return a real activity
break;
case ActivityTypes.ConversationUpdate:
// Handle conversation state changes, like members being added and removed
// Use Activity.MembersAdded and Activity.MembersRemoved and Activity.Action for info
// Not available in all channels
await WelcomeNewUser(activity);
break;
case ActivityTypes.ContactRelationUpdate:
// Handle add/remove from contact lists
// Activity.From + Activity.Action represent what happened
break;
case ActivityTypes.Typing:
// Handle knowing tha the user is typing
await ResponseTyping(activity);
break;
case ActivityTypes.Ping:
await ResponsePing(activity);
break;
default:
Trace.TraceError($"Unknown activity type ignored: {activity.GetActivityType()}");
break;
}
}
/// <summary>
/// POST: api/Messages
/// Receive a message from a user and reply to it
/// </summary>
public async Task <HttpResponseMessage> Post([FromBody] Activity activity)
{
switch (activity.GetActivityType())
{
// all messages pass through one dialog for now
case ActivityTypes.Message:
LuisModelAttribute attr = new LuisModelAttribute(ConfigurationManager.AppSettings[Constants.LuisModelIdKey], ConfigurationManager.AppSettings[Constants.LuisSubscriptionKey]);
LuisService luisSvc = new LuisService(attr);
await Conversation.SendAsync(activity, () => new GitHubLuisDialog(luisSvc));
break;
// send a "hello" to someone who just joined the conversation (not all channels support this)
case ActivityTypes.ConversationUpdate:
IConversationUpdateActivity update = activity;
using (ILifetimeScope scope = DialogModule.BeginLifetimeScope(Conversation.Container, activity))
{
IConnectorClient client = scope.Resolve <IConnectorClient>();
if (update.MembersAdded.Any())
{
Activity reply = activity.CreateReply();
IEnumerable <ChannelAccount> newMembers = update.MembersAdded?.Where(t => t.Id != activity.Recipient.Id);
foreach (var newMember in newMembers)
{
reply.Text = Constants.DemoText + $"Welcome {newMember.Name}! I can help you with getting information about your GitHub repos.";
IBotData data = scope.Resolve <IBotData>();
await data.LoadAsync(CancellationToken.None);
if (data.UserData.ContainsKey(Constants.AuthTokenKey))
{
reply.Text += " It looks like you're already logged in, so what can I help you with?";
}
else
{
reply.Text += " To get started, type **login** to authorize me to talk to GitHub on your behalf, or type **help** to get more information.";
}
await client.Conversations.ReplyToActivityAsync(reply);
}
}
}
break;
}
return(new HttpResponseMessage(HttpStatusCode.Accepted));
}
public virtual async Task <HttpResponseMessage> Post([FromBody] Microsoft.Bot.Connector.Activity activity)
{
// check if activity is of type message
if (activity != null && activity.GetActivityType() == ActivityTypes.Message)
{
BotDbAnalytics.AddSession(
activity.ChannelId,
activity.Conversation.Id,
DateTime.UtcNow,
activity.Locale);
await Conversation.SendAsync(activity, () => new ViaSportDialog());
}
else
{
HandleSystemMessage(activity);
}
return(new HttpResponseMessage(System.Net.HttpStatusCode.Accepted));
}
public async Task <object> Post([FromBody] Activity activity)
{
try
{
// Initialize the azure bot
using (BotService.Initialize())
{
// BotBuilder insists on getting from the default config - this overrides it
Conversation.UpdateContainer(b =>
{
b.RegisterInstance(new MicrosoftAppCredentials(
Config.GetAppSetting("MicrosoftAppId"),
Config.GetAppSetting("MicrosoftAppPassword")
));
});
// use this to check what the registered value is
// ((MicrosoftAppCredentials)(Conversation.Container.ComponentRegistry.TryGetRegistration(new Autofac.Core.TypedService(typeof(MicrosoftAppCredentials)), out var xxx) ? Conversation.Container.ResolveComponent(xxx, new Autofac.Core.Parameter[0]) : null)).MicrosoftAppId
// Deserialize the incoming activity
//string jsonContent = await req.Content.ReadAsStringAsync();
//var activity = JsonConvert.DeserializeObject<Activity>(jsonContent);
// authenticate incoming request and add activity.ServiceUrl to MicrosoftAppCredentials.TrustedHostNames
// if request is authenticated
var authHeader = this.Request.Headers.GetCommaSeparatedValues(HeaderNames.Authorization);
var authParts = authHeader[0].Split(new[] { ' ' }, 2);
var identityToken = await BotService.Authenticator.TryAuthenticateAsync(authParts[0], authParts[1], CancellationToken.None);
if (null == identityToken || !identityToken.Authenticated)
{
this.Response.Headers.Add("WWW-Authenticate", $"Bearer realm=\"{Request.Host}\"");
return(Unauthorized());
}
identityToken.ValidateServiceUrlClaim(new[] { activity });
MicrosoftAppCredentials.TrustServiceUrl(activity.ServiceUrl);
if (activity != null)
{
// one of these will have an interface and process it
switch (activity.GetActivityType())
{
case ActivityTypes.Message:
var text = activity.AsMessageActivity().Text ?? "";
Trace.WriteLine($"Recieved message: '{text}' from {activity.From.Id}/{activity.From.Name} on {activity.ChannelId}/{activity.Conversation.IsGroup.GetValueOrDefault()}");
Trace.WriteLine($" ChannelData: {(activity.ChannelData as JObject)}");
Trace.WriteLine($" Conversation: {activity.Conversation.ConversationType}, id: {activity.Conversation.Id}, name: {activity.Conversation.Name}, role: {activity.Conversation.Role}, properties: {activity.Conversation.Properties}");
Trace.WriteLine($" From: {activity.From.Id}/{activity.From.Name}, role: {activity.From.Role}, properties: {activity.From.Properties}");
Trace.WriteLine($" Recipient: {activity.Recipient.Id}/{activity.Recipient.Name}, role: {activity.Recipient.Role}, properties: {activity.Recipient.Properties}");
if (text.Contains("</at>") && activity.ChannelId == "msteams")
{
// ignore the mention of us in the reply
text = new Regex("<at>.*</at>").Replace(text, "").Trim();
}
if (activity.ChannelId == "slack")
{
var mentions = activity.Entities.Where(i => i.Type == "mention").Select(i =>
i.Properties.ToAnonymousObject(new
{
mentioned = new { id = "", name = "" },
text = ""
}))
.ToList();
// ignore any group messages that don't mention us
if (activity.Conversation.IsGroup.GetValueOrDefault() &&
!mentions.Any(i => i.mentioned.name == activity.Recipient.Name))
{
break;
}
// filter out any mentions - we don't really care about them...
foreach (var mention in mentions)
{
if (!string.IsNullOrEmpty(mention.text))
{
text = text.Replace(mention.text, "");
}
}
// set up the conversation so we'll be in the thread
string thread_ts = ((dynamic)activity.ChannelData)?.SlackMessage?.@event?.thread_ts;
string ts = ((dynamic)activity.ChannelData)?.SlackMessage?.@event?.ts;
if (string.IsNullOrEmpty(thread_ts) && !string.IsNullOrEmpty(ts) && activity.Conversation.Id.Split(':').Length == 3)
{
// this is a main-channel conversation - pretend it came in on a thread
activity.Conversation.Id += $":{ts}";
Trace.WriteLine($" Modified Conversation: {activity.Conversation.ConversationType}, id: {activity.Conversation.Id}, name: {activity.Conversation.Name}, role: {activity.Conversation.Role}, properties: {activity.Conversation.Properties}");
}
}
activity.AsMessageActivity().Text = text.Trim();
Trace.WriteLine($"Processing message: '{text}' from {activity.From.Id}/{activity.From.Name} on {activity.ChannelId}/{activity.Conversation.IsGroup.GetValueOrDefault()}");
await Conversation.SendAsync(activity, () => new ExceptionHandlerDialog <object>(new BotDialog(Request.GetRequestUri()), true));
break;
case ActivityTypes.ConversationUpdate:
var client = new ConnectorClient(new Uri(activity.ServiceUrl), new MicrosoftAppCredentials(
Config.GetAppSetting("MicrosoftAppId"),
Config.GetAppSetting("MicrosoftAppPassword")
));
IConversationUpdateActivity update = activity;
if (update.MembersAdded?.Any() ?? false)
{
var reply = activity.CreateReply();
var newMembers = update.MembersAdded?.Where(t => t.Id != activity.Recipient.Id);
foreach (var newMember in newMembers)
{
reply.Text = "Welcome";
if (!string.IsNullOrEmpty(newMember.Name))
{
reply.Text += $" {newMember.Name}";
}
reply.Text += ", this is a bot from Rightpoint Labs Beta - say 'info' for more.";
await client.Conversations.ReplyToActivityAsync(reply);
}
}
break;
case ActivityTypes.ContactRelationUpdate:
case ActivityTypes.Typing:
case ActivityTypes.DeleteUserData:
case ActivityTypes.Ping:
default:
Trace.WriteLine($"Unknown activity type ignored: {activity.GetActivityType()}");
break;
}
}
return(Accepted());
}
}
catch (Exception ex)
{
TelemetryClient.TrackException(ex);
throw;
}
}
public virtual async Task <HttpResponseMessage> Post([FromBody] Microsoft.Bot.Connector.Activity message)
{
ConnectorClient connector = new ConnectorClient(new Uri(message.ServiceUrl));
IBotDataStore <BotData> dataStore = botStateStore;
storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("piglatinbotsjameslew_AzureStorageConnectionString"));
botStateStore = new TableBotDataStore(storageAccount, "botdata");
Microsoft.Bot.Connector.Activity replyMessage = message.CreateReply();
replyMessage.Locale = "en-Us";
replyMessage.TextFormat = TextFormatTypes.Plain;
if (message.GetActivityType() != ActivityTypes.Message)
{
replyMessage = await handleSystemMessagesAsync(message, connector, botStateStore);
if (replyMessage != null)
{
var reply = await connector.Conversations.ReplyToActivityAsync(replyMessage);
}
}
else
{
if (message.Text.Contains("MessageTypesTest"))
{
Microsoft.Bot.Connector.Activity mtResult = await messageTypesTest(message, connector);
await connector.Conversations.ReplyToActivityAsync(mtResult);
}
else if (message.Text.Contains("DataTypesTest"))
{
Microsoft.Bot.Connector.Activity dtResult = await dataTypesTest(message, connector, botStateStore);
await connector.Conversations.ReplyToActivityAsync(dtResult);
}
else if (message.Text.Contains("CardTypesTest"))
{
Microsoft.Bot.Connector.Activity ctResult = await cardTypesTest(message, connector);
await connector.Conversations.ReplyToActivityAsync(ctResult);
}
try
{
if (await isNewUser(message.From.Id, message, botStateStore))
{
Microsoft.Bot.Connector.Activity introMessage = message.CreateReply();
introMessage.Locale = "en-Us";
introMessage.TextFormat = TextFormatTypes.Plain;
introMessage.InputHint = InputHints.IgnoringInput;
introMessage.Text = string.Format(translateToPigLatin("Hey there, I'm PigLatinBot. I make intelligible text unintelligible. Ask me how by typing 'Help', and for terms and info, click ") + "[erehay](http://www.piglatinbot.com)", message.From.Name);
var reply = await connector.Conversations.ReplyToActivityAsync(introMessage);
}
replyMessage.InputHint = InputHints.AcceptingInput;
replyMessage.Speak = message.Text;
replyMessage.Text = translateToPigLatin(message.Text);
var httpResponse = await connector.Conversations.ReplyToActivityAsync(replyMessage);
}
catch (HttpResponseException e)
{
Trace.WriteLine(e.Message);
var Response = Request.CreateResponse(HttpStatusCode.InternalServerError);
return(Response);
}
}
var responseOtherwise = Request.CreateResponse(HttpStatusCode.OK);
return(responseOtherwise);
}
private async Task <Microsoft.Bot.Connector.Activity> handleSystemMessagesAsync(Microsoft.Bot.Connector.Activity message, ConnectorClient connector, TableBotDataStore botStateStore)
{
Microsoft.Bot.Connector.Activity replyMessage = message.CreateReply();
message.Locale = "en";
IBotDataStore <BotData> dataStore = botStateStore;
switch (message.GetActivityType())
{
case ActivityTypes.DeleteUserData:
//In this case the DeleteUserData message comes from the user so we can clear the data and set it back directly
BotData currentBotData = (BotData)await dataStore.LoadAsync(new Address(message.Recipient.Id, message.ChannelId, message.From.Id, message.Conversation.Id, message.ServiceUrl), BotStoreType.BotUserData, default(CancellationToken));
pigLatinBotUserData deleteUserData = new pigLatinBotUserData();
currentBotData.SetProperty("v1", deleteUserData);
await dataStore.SaveAsync(new Address(message.Recipient.Id, message.ChannelId, message.From.Id, message.Conversation.Id, message.ServiceUrl), BotStoreType.BotUserData, currentBotData, default(CancellationToken));
replyMessage.Text = translateToPigLatin("I have deleted your data oh masterful one");
Trace.TraceInformation("Clearing user's BotUserData");
return(replyMessage);
//if they're new or haven't seen the updated legal documents, send them a message
//use the incoming message to set up the outgoing message
case ActivityTypes.ConversationUpdate:
foreach (ChannelAccount added in message.MembersAdded)
{
Microsoft.Bot.Connector.Activity addedMessage = message.CreateReply();
bool needToSendWelcomeText = false;
pigLatinBotUserData addedUserData = new pigLatinBotUserData();
BotData botData = new BotData();
// is the added member me?
if (added.Id == message.Recipient.Id)
{
addedMessage.Text = string.Format(translateToPigLatin("Hey there, I'm PigLatinBot. I make intelligible text unintelligible. Ask me how by typing 'Help', and for terms and info, click ") + "[erehay](http://www.piglatinbot.com)", added.Name);
var reply = await connector.Conversations.ReplyToActivityAsync(addedMessage);
continue;
}
if (await isNewUser(added.Id, message, botStateStore))
{
addedUserData.isNewUser = false;
needToSendWelcomeText = true;
}
if (addedUserData.lastReadLegalese < lastModifiedPolicies)
{
addedUserData.lastReadLegalese = DateTime.UtcNow;
needToSendWelcomeText = true;
}
if (needToSendWelcomeText)
{
addedMessage.Text = string.Format(translateToPigLatin("Welcome to the chat") + " {0}, " + translateToPigLatin("I'm PigLatinBot. I make intelligible text unintelligible. Ask me how by typing 'Help', and for terms and info, click ") + "[erehay](http://www.piglatinbot.com)", added.Name);
addedMessage.Recipient = added;
addedMessage.Conversation = null;
try
{
botData.SetProperty("v1", addedUserData);
await dataStore.SaveAsync(new Address(message.Recipient.Id, message.ChannelId, added.Id, message.Conversation.Id, message.ServiceUrl), BotStoreType.BotUserData, botData, default(CancellationToken));
}
catch (Exception e)
{
Trace.WriteLine(e.Message);
}
var ConversationId = await connector.Conversations.CreateDirectConversationAsync(message.Recipient, message.From);
addedMessage.Conversation = new ConversationAccount(id: ConversationId.Id);
var reply = await connector.Conversations.SendToConversationAsync(addedMessage);
}
}
//maybe someone got removed
foreach (ChannelAccount removed in message.MembersRemoved)
{
Microsoft.Bot.Connector.Activity removedMessage = message.CreateReply();
removedMessage.Locale = "en";
removedMessage.Text = string.Format("{0}", removed.Name) + translateToPigLatin(" has Left the building");
var reply = await connector.Conversations.ReplyToActivityAsync(removedMessage);
}
return(null);
default:
return(null);
}
}
/// <summary>
/// Return the "major" portion of the activity
/// </summary>
/// <param name="activity"></param>
/// <returns>normalized major portion of the activity, aka message/... will return "message"</returns>
public static string GetActivityType(this IActivity activity)
{
var type = activity.Type.Split('/').First();
return(Activity.GetActivityType(type));
}
/// <summary>
/// Normalize ActivityType
/// </summary>
/// <param name="activity"></param>
/// <returns>normalized activity type</returns>
public static string GetActivityType(this IActivity activity)
{
return(Activity.GetActivityType(activity.Type));
}