public async Task SendToConverstionData(string converstationId, IActivity activity, Dictionary <string, string> dataToSend)
{
using (var scope = DialogModule.BeginLifetimeScope(Conversation.Container, (IMessageActivity)activity))
{
MicrosoftAppCredentials.TrustServiceUrl(ServiceUrl, DateTime.MaxValue);
var botDataStore = scope.Resolve <IBotDataStore <BotData> >();
var key = new AddressKey
{
BotId = BotId,
ChannelId = ChannelId,
ConversationId = converstationId,
ServiceUrl = ServiceUrl
};
var conversationData = await botDataStore.LoadAsync(key, BotStoreType.BotConversationData, CancellationToken.None);
foreach (var data in dataToSend)
{
conversationData.SetProperty(data.Key, data.Value);
}
await botDataStore.SaveAsync(key, BotStoreType.BotConversationData, conversationData, CancellationToken.None);
await botDataStore.FlushAsync(key, CancellationToken.None);
}
}
/// <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.Type == ActivityTypes.Message)
{
if (!string.IsNullOrEmpty(activity.Text))
{
//detect language of input text
var userLanguage = await TranslateService.DetermineLanguageAsync(activity.Text);
//save user's LanguageCode to Azure Table Storage
var message = activity as IMessageActivity;
try
{
using (var scope = DialogModule.BeginLifetimeScope(Conversation.Container, message))
{
var botDataStore = scope.Resolve <IBotDataStore <BotData> >();
var key = new AddressKey()
{
BotId = message.Recipient.Id,
ChannelId = message.ChannelId,
UserId = message.From.Id,
ConversationId = message.Conversation.Id,
ServiceUrl = message.ServiceUrl
};
var userData = await botDataStore.LoadAsync(key, BotStoreType.BotUserData, CancellationToken.None);
var storedLanguageCode = userData.GetProperty <string>(AppSettings.UserLanguageKey);
//update user's language in Azure Table Storage
if (storedLanguageCode != userLanguage)
{
userData.SetProperty(AppSettings.UserLanguageKey, userLanguage);
await botDataStore.SaveAsync(key, BotStoreType.BotUserData, userData, CancellationToken.None);
await botDataStore.FlushAsync(key, CancellationToken.None);
}
}
}
catch (Exception ex)
{
throw ex;
}
activity.Text = await TranslateService.TranslateTextToDefaultLanguage(activity, userLanguage);
await Conversation.SendAsync(activity, MakeRoot);
}
}
else
{
await HandleSystemMessage(activity);
}
var response = Request.CreateResponse(HttpStatusCode.OK);
return(response);
}
internal string GetAddressValue(AddressKey key, string address)
{
var addresses = GetOrCreateAddressMap(key);
string value = string.Empty;
if (addresses.TryGetValue(address, out value))
{
return(value);
}
return(string.Empty);
}
private Dictionary <string, string> GetOrCreateAddressMap(AddressKey key)
{
Dictionary <string, string> addresses;
if (m_Addresses.TryGetValue(key, out addresses))
{
return(addresses);
}
addresses = new Dictionary <string, string>();
m_Addresses[key] = addresses;
return(addresses);
}
// private static readonly bool IsSpellCorrectionEnabled = bool.Parse(WebConfigurationManager.AppSettings["IsSpellCorrectionEnabled"]);
// private readonly BingSpellCheckService spellService = new BingSpellCheckService();
/// <summary>
/// POST: api/Messages
/// Receive a message from a user and reply to it
/// </summary>
public async Task <HttpResponseMessage> Post([FromBody] Activity activity)
{
Trace.TraceInformation($"Incoming Activity is {activity.ToJson()}");
if (activity.Type == ActivityTypes.Message)
{
if (!String.IsNullOrEmpty(activity.Text))
{
//detect language of input text
var userLanguage = TranslationHandler.DetectLanguage(activity);
// save user´s languagecode
var message = activity as IMessageActivity;
try
{
using (var scope = DialogModule.BeginLifetimeScope(Conversation.Container, message))
{
var botDataStore = scope.Resolve <IBotDataStore <BotData> >();
var key = new AddressKey()
{
BotId = message.Recipient.Id,
ChannelId = message.ChannelId,
UserId = message.From.Id,
ConversationId = message.Conversation.Id,
ServiceUrl = message.ServiceUrl
};
var userData = await botDataStore.LoadAsync(key, BotStoreType.BotUserData, CancellationToken.None);
var storedLanguageCode = userData.GetProperty <string>(StringConstants.UserLanguageKey);
//update user's language in Azure Table Storage
if (storedLanguageCode != userLanguage && !Regex.IsMatch(activity.Text, @"[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?"))
{
userData.SetProperty(StringConstants.UserLanguageKey, userLanguage);
await botDataStore.SaveAsync(key, BotStoreType.BotUserData, userData, CancellationToken.None);
await botDataStore.FlushAsync(key, CancellationToken.None);
}
}
}
catch (Exception ex)
{
throw ex;
}
//translate activity.Text to Spanish before sending to LUIS for intent
activity.Text = TranslationHandler.TranslateTextToDefaultLanguage(activity, userLanguage);
// activity.Text = TranslationHandler.TranslateText(String ,"es",userLanguage);
// await Conversation.SendAsync(activity, MakeRoot);
await Conversation.SendAsync(activity, () => new RootLuisDialog());
}
}
else
{
HandleSystemMessage(activity);
}
var response = Request.CreateResponse(HttpStatusCode.OK);
return(response);
}
public async Task <HttpResponseMessage> Callback([FromUri] string code, [FromUri] string state, CancellationToken cancellationToken)
{
try
{
// Use the state parameter to get correct IAuthProvider and ResumptionCookie
var decoded = Encoding.UTF8.GetString(HttpServerUtility.UrlTokenDecode(state));
var queryString = HttpUtility.ParseQueryString(decoded);
var assembly = Assembly.Load(queryString["providerassembly"]);
var type = assembly.GetType(queryString["providertype"]);
var providername = queryString["providername"];
IAuthProvider authProvider;
if (type.GetConstructor(new Type[] { typeof(string) }) != null)
{
authProvider = (IAuthProvider)Activator.CreateInstance(type, providername);
}
else
{
authProvider = (IAuthProvider)Activator.CreateInstance(type);
}
// Get the conversation reference
var conversationRef = UrlToken.Decode <ConversationReference>(queryString["conversationRef"]);
Activity message = conversationRef.GetPostToBotMessage();
using (var scope = DialogModule.BeginLifetimeScope(Conversation.Container, message))
{
// Get the UserData from the original conversation
IBotDataStore <BotData> stateStore = scope.Resolve <IBotDataStore <BotData> >();
var key = new AddressKey()
{
BotId = message.Recipient.Id,
ChannelId = message.ChannelId,
UserId = message.From.Id,
ConversationId = message.Conversation.Id,
ServiceUrl = message.ServiceUrl
};
var userData = await stateStore.LoadAsync(key, BotStoreType.BotUserData, CancellationToken.None);
// Get Access Token using authorization code
var authOptions = userData.GetProperty <AuthenticationOptions>($"{authProvider.Name}{ContextConstants.AuthOptions}");
var token = await authProvider.GetTokenByAuthCodeAsync(authOptions, code);
// Generate magic number and attempt to write to userdata
int magicNumber = GenerateRandomNumber();
bool writeSuccessful = false;
uint writeAttempts = 0;
while (!writeSuccessful && writeAttempts++ < MaxWriteAttempts)
{
try
{
userData.SetProperty($"{authProvider.Name}{ContextConstants.AuthResultKey}", token);
if (authOptions.UseMagicNumber)
{
userData.SetProperty($"{authProvider.Name}{ContextConstants.MagicNumberKey}", magicNumber);
userData.SetProperty($"{authProvider.Name}{ContextConstants.MagicNumberValidated}", "false");
}
await stateStore.SaveAsync(key, BotStoreType.BotUserData, userData, CancellationToken.None);
await stateStore.FlushAsync(key, CancellationToken.None);
writeSuccessful = true;
}
catch (Exception)
{
writeSuccessful = false;
}
}
var resp = new HttpResponseMessage(HttpStatusCode.OK);
if (!writeSuccessful)
{
message.Text = String.Empty; // fail the login process if we can't write UserData
await Conversation.ResumeAsync(conversationRef, message);
resp.Content = new StringContent("<html><body>Could not log you in at this time, please try again later</body></html>", System.Text.Encoding.UTF8, @"text/html");
}
else
{
await Conversation.ResumeAsync(conversationRef, message);
resp.Content = new StringContent($"<html><body>Almost done! Please copy this number and paste it back to your chat so your authentication can complete:<br/> <h1>{magicNumber}</h1>.</body></html>", System.Text.Encoding.UTF8, @"text/html");
}
return(resp);
}
}
catch (Exception ex)
{
// Callback is called with no pending message as a result the login flow cannot be resumed.
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ex));
}
}
/// <summary>
/// POST: api/Messages
/// Receive a message from a user and reply to it
/// </summary>
//[ResponseType(typeof(void))]
public async Task <HttpResponseMessage> Post([FromBody] Activity activity)
{
//trust Webchat & SMS channel
MicrosoftAppCredentials.TrustServiceUrl(@"https://webchat.botframework.com", DateTime.MaxValue);
MicrosoftAppCredentials.TrustServiceUrl(@"https://sms.botframework.com", DateTime.MaxValue);
Trace.TraceInformation($"Incoming Activity is {activity.ToJson()}");
if (activity.Type == ActivityTypes.Message)
{
if (!string.IsNullOrEmpty(activity.Text))
{
//detect language of input text
var userLanguage = TranslationHandler.DetectLanguage(activity);
//save user's LanguageCode to Azure Table Storage
var message = activity as IMessageActivity;
try
{
using (var scope = DialogModule.BeginLifetimeScope(Conversation.Container, message))
{
var botDataStore = scope.Resolve <IBotDataStore <BotData> >();
var key = new AddressKey()
{
BotId = message.Recipient.Id,
ChannelId = message.ChannelId,
UserId = message.From.Id,
ConversationId = message.Conversation.Id,
ServiceUrl = message.ServiceUrl
};
var userData = await botDataStore.LoadAsync(key, BotStoreType.BotUserData, CancellationToken.None);
var storedLanguageCode = userData.GetProperty <string>(StringConstants.UserLanguageKey);
//update user's language in Azure Table Storage
if (storedLanguageCode != userLanguage)
{
userData.SetProperty(StringConstants.UserLanguageKey, userLanguage);
await botDataStore.SaveAsync(key, BotStoreType.BotUserData, userData, CancellationToken.None);
await botDataStore.FlushAsync(key, CancellationToken.None);
}
}
}
catch (Exception ex)
{
throw ex;
}
//translate activity.Text to English before sending to LUIS for intent
activity.Text = TranslationHandler.TranslateTextToDefaultLanguage(activity, userLanguage);
await Conversation.SendAsync(activity, MakeRoot);
}
}
else
{
HandleSystemMessage(activity);
}
var response = Request.CreateResponse(HttpStatusCode.OK);
return(response);
}
internal IReadOnlyList <string> GetAllAddresses(AddressKey key)
{
return(m_Addresses[key].Keys.ToArray());
}
internal void SetAddressValue(AddressKey key, string address, string value)
{
var addresses = GetOrCreateAddressMap(key);
addresses[address] = value;
}
internal void CreateAddressEntry(AddressKey key, string address)
{
var addresses = GetOrCreateAddressMap(key);
addresses[address] = string.Empty;
}
public void DeleteAddress([FromBody] AddressKey key)
{
_addressService.Delete(key);
}
public Address GetAddress([FromBody] AddressKey key)
{
var address = _addressService.Get(key);
return(address);
}
public virtual async Task <HttpResponseMessage> Post([FromBody] Activity activity)
{
var connector = new ConnectorClient(new Uri(activity.ServiceUrl));
// check if activity is of type message
if (activity != null && activity.GetActivityType() == ActivityTypes.Message)
{
var message = activity as IMessageActivity;
using (var scope = DialogModule.BeginLifetimeScope(Conversation.Container, message))
{
var botDataStore = scope.Resolve <IBotDataStore <BotData> >();
var key = new AddressKey()
{
BotId = message.Recipient.Id,
ChannelId = message.ChannelId,
UserId = message.From.Id,
ConversationId = message.Conversation.Id,
ServiceUrl = message.ServiceUrl
};
var userData = await botDataStore.LoadAsync(key, BotStoreType.BotUserData, CancellationToken.None);
userData.SetProperty("key 1", "value1");
userData.SetProperty("key 2", "value2");
await botDataStore.SaveAsync(key, BotStoreType.BotUserData, userData, CancellationToken.None);
await botDataStore.FlushAsync(key, CancellationToken.None);
}
if (activity.Text.ToLower() == BotMessageType.Notification)
{
await HandleNotificationMessages(activity, connector);
}
else
{
var authRestService = new AuthRestService();
if (activity.ChannelId == Channel.Sms)
{
int accessCode;
bool isNumeric = int.TryParse(activity.Text, out accessCode);
if (isNumeric)
{
var otpSmsService = new OTPSmsService();
var isAccessCodeValid = await otpSmsService.CheckOneTimePasswordCode(activity.From.Id, accessCode.ToString(), activity.ChannelId);
if (!isAccessCodeValid)
{
Activity reply = activity.CreateReply("el codigo es invalido ");
await connector.Conversations.ReplyToActivityAsync(reply);
}
else
{
Activity reply = activity.CreateReply("Autenticación realizada con éxito");
await connector.Conversations.ReplyToActivityAsync(reply);
}
}
else
{
var smsUserAuthenticated = await authRestService.CheckSmsUserIsAuthenticated(activity.From.Id);
if (!smsUserAuthenticated)
{
Activity reply = activity.CreateReply(MessagesDialog.SmsUserNotLogged);
await connector.Conversations.ReplyToActivityAsync(reply);
}
else
{
await HandleSmsMessages(activity, connector);
}
}
}
else
{
var userIsAuthenticated = false;
if (activity.ChannelId == "directline")
{
userIsAuthenticated = await authRestService.CheckDirectLineUserIsAuthenticated(activity.From.Id);
}
else
{
userIsAuthenticated = await authRestService.CheckUserIsAuthenticated(activity.From.Name);
}
if (activity.Text == BotMessageType.Notification)
{
await HandleNotificationMessages(activity, connector);
}
if (activity.Text == BotMessageType.Userlogged)
{
Activity reply = activity.CreateReply(Resources.MessagesDialog.AuthLoginSucceded);
await connector.Conversations.ReplyToActivityAsync(reply);
}
if (userIsAuthenticated)
{
await Conversation.SendAsync(activity, () => new BotHomeDialog());
}
else
{
if (activity.ChannelId == Channel.DirectLine)
{
//check number
int accessCode;
bool isNumeric = int.TryParse(activity.Text, out accessCode);
if (isNumeric)
{
var otpSmsService = new OTPSmsService();
var isAccessCodeValid = await otpSmsService.CheckOneTimePasswordCode(activity.From.Id, accessCode.ToString(), activity.ChannelId);
if (!isAccessCodeValid)
{
Activity reply = activity.CreateReply("El código es inválido: " + activity.From.Id);
await connector.Conversations.ReplyToActivityAsync(reply);
}
else
{
Activity reply = activity.CreateReply("Autenticación realizada con éxito");
await connector.Conversations.ReplyToActivityAsync(reply);
}
}
else
{
Activity reply = activity.CreateReply(MessagesDialog.DirectLineMessageLogin);
await connector.Conversations.ReplyToActivityAsync(reply);
}
}
else
{
var urlLogin = WebConfigurationManager.AppSettings["authLoginUrl"];
var codeAccessUrl = "?codeaccess=" + DateTime.Now.Ticks.ToString();
var channelId = "&channelId=" + activity.ChannelId;
var definitiveUrlLogin = urlLogin + codeAccessUrl + channelId;
Activity reply = activity.CreateReply(MessagesDialog.AuthLoginRequired + activity.From.Name + System.Environment.NewLine + definitiveUrlLogin);
await connector.Conversations.ReplyToActivityAsync(reply);
}
}
}
}
}
else
{
HandleSystemMessage(activity);
}
var response = Request.CreateResponse(HttpStatusCode.OK);
return(response);
}
