public async Task StartAsync(IDialogContext context) { luis = new LuisService( new LuisModelAttribute( Settings.Instance.LuisAppId, Settings.Instance.LuisSubscriptionKey, LuisApiVersion.V2, domain: Settings.Instance.LuisAPIHostName )); context.Wait(MessageReceivedAsync); }
public void NullOrEmptyIntents_DefaultsTo_TopScoringIntent() { var intent = new IntentRecommendation(); var result = new LuisResult() { TopScoringIntent = intent }; LuisService.Fix(result); Assert.AreEqual(1, result.Intents.Count); Assert.AreEqual(intent, result.Intents[0]); }
/// <summary> /// Query Luis API (Async). /// </summary> /// <param name="query">Luis Query.</param> /// <returns></returns> internal static async Task <dynamic> RunQuery(string query) { // Process message LuisService luisService = new LuisService(new LuisModelAttribute(ConfigurationManager.AppSettings["LuisConfiguration:AppId"], ConfigurationManager.AppSettings["LuisConfiguration:AppSecret"])); LuisResult luisResult = await luisService.QueryAsync(query, CancellationToken.None); IList <EntityRecommendation> luisEntities = luisResult.Entities; IList <IntentRecommendation> luisIntents = luisResult.Intents; return(luisResult); }
/// <summary> /// Converts a Luis service definition into a Luis service. /// </summary> /// <returns>The Luis service.</returns> public LuisService GetLuisService() { LuisService ls = new LuisService { AppId = AppId, AuthoringKey = AuthoringKey, SubscriptionKey = SubscriptionKey, Version = Version, Region = Region }; return(ls); }
/// <summary> /// Demande à luis la comprehension /// </summary> /// <param name="result"></param> /// <returns></returns> public async Task <JsonResult> GetReponse(string result) { var actions = GetJsonModels(); //UserConnect.GetContext(HttpContext); LuisService luisService = new LuisService(); var resultLuis = await luisService.SendRequest(result); var resultRequest = actions.Where(a => a.Intent == resultLuis.TopScoringIntent.Intent).FirstOrDefault(); return(new JsonResult() { Data = "Test", JsonRequestBehavior = JsonRequestBehavior.AllowGet }); }
public async Task <T> GetResultDate(string text) { Result = default(T); //invoke LUIS if (string.IsNullOrEmpty(text)) { return(default(T)); } if ((EqualityComparer <T> .Default.Equals(Result, default(T)))) { LuisService luis = new LuisService(new LuisModelAttribute( modelID: ConfigurationManager.AppSettings["LuisModel"], subscriptionKey: ConfigurationManager.AppSettings["LuisKey"], apiVersion: LuisApiVersion.V2 )); bool hasResult = true; var result = Task.Run(() => luis.QueryAsync(new LuisRequest(text), System.Threading.CancellationToken.None)).Result; EntityRecommendation datetime = null; if (!result.TryFindEntity("builtin.datetimeV2.datetime", out datetime) && !result.TryFindEntity("builtin.datetimeV2.date", out datetime) && !result.TryFindEntity("builtin.datetimeV2.time", out datetime) && !result.TryFindEntity("builtin.datetimeV2.duration", out datetime)) { hasResult = false; } if (!hasResult) { Result = default(T); } else { //Result = datetime.ToDateTime(); if (Result.GetType() == typeof(DateTimeOffset)) { Result = (T)Convert.ChangeType(datetime.ToDateTime(), typeof(DateTimeOffset)); } else if (Result.GetType() == typeof(TimeSpan)) { Result = (T)Convert.ChangeType(datetime.ToTimeSpan(), typeof(TimeSpan)); } else if ((Result.GetType() == typeof(Int64))) { Result = (T)Convert.ChangeType(datetime.ToInt64(), typeof(Int64)); } } } return(Result); }
public static async Task <LuisResult> GetIntentAndEntitiesFromLUIS(string query) { LuisService luisService = new LuisService( new LuisModelAttribute( ConfigurationManager.AppSettings["LuisAppId"], ConfigurationManager.AppSettings["LuisAPIKey"], LuisApiVersion.V2, ConfigurationManager.AppSettings["LuisAPIHostName"], double.Parse(ConfigurationManager.AppSettings["LuisAPIThreshold"], System.Globalization.CultureInfo.InvariantCulture) ) ); LuisResult luisData = await luisService.QueryAsync(query, CancellationToken.None); return(luisData); }
public async Task Query_ReturnsModelWithIntents_WhenCommandQuered() { var settingsMock = new Mock <ISettings>(); settingsMock.Setup(x => x.LuisAppUri) .Returns($"{Config["LuisApp:Uri"]}?subscription-key={Config["LuisApp:Key"]}&verbose=true&timezoneOffset=0"); var luisService = new LuisService(settingsMock.Object); var result = await luisService.Query("Who let the dog out??"); Assert.IsNotNull(result); Assert.IsNotNull(result.Intents); Assert.AreNotEqual(result.Intents.Count, 0); }
public void LuisApplication_Configuration() { var service = new LuisService { AppId = Guid.NewGuid().ToString(), SubscriptionKey = Guid.NewGuid().ToString(), Region = "westus" }; var model = new LuisApplication(service); Assert.AreEqual(service.AppId, model.ApplicationId); Assert.AreEqual(service.SubscriptionKey, model.EndpointKey); Assert.AreEqual(service.GetEndpoint(), model.Endpoint); }
/// <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 static void Validate(this LuisService luisService) { if (string.IsNullOrWhiteSpace(luisService.AppId)) { throw new InvalidOperationException("The LUIS AppId ('appId') is required to run this sample."); } if (string.IsNullOrWhiteSpace(luisService.AuthoringKey)) { throw new InvalidOperationException("The LUIS AuthoringKey ('authoringKey') is required to run this sample."); } if (string.IsNullOrWhiteSpace(luisService.SubscriptionKey)) { throw new InvalidOperationException("The LUIS SubscriptionKey ('subscriptionKey') is required to run this sample."); } }
private static Func <IDialog <object> > MakeRootDialog() { //get the luis app id & key var MicrosoftLuisAppId = ConfigurationManager.AppSettings["MicrosoftLuisAppId"]; var MicrosoftLuisKey = ConfigurationManager.AppSettings["MicrosoftLuisKey"]; Func <IDialog <object> > luisDialog = null; //instantiate the root luis dialog and encapsulate it in a delegate luisDialog = () => { var luisService = new LuisService(new LuisModelAttribute(MicrosoftLuisAppId, MicrosoftLuisKey)); return(new Dialogs.RootLuisDialog(luisService)); }; return(luisDialog); }
public async Task <ActionResult> Index(QueryViewModel model) { if (!model.HasIntent) { var luisService = new LuisService(new LuisModelAttribute(ConfigurationManager.AppSettings["LUIS_ModelId"], ConfigurationManager.AppSettings["LUIS_SubscriptionKey"])); var luisResult = await luisService.QueryAsync(model.Query, CancellationToken.None); var resolver = new LuisActionResolver(typeof(GetTimeInPlaceAction).Assembly); var action = resolver.ResolveActionFromLuisIntent(luisResult); // Triggering Contextual Action from scratch is not supported on this Web Sample if (action != null && !LuisActionResolver.IsContextualAction(action)) { model.LuisAction = action; // TODO: this is dangerous. This should be stored somewhere else, not in the client, or at least encrypted model.LuisActionType = action.GetType().AssemblyQualifiedName; } else { // no action recnogized return(this.View(new QueryViewModel())); } } ModelState.Clear(); var isValid = TryValidateModel(model.LuisAction); if (isValid) { // fulfill var actionResult = await model.LuisAction.FulfillAsync(); if (actionResult == null) { actionResult = "Cannot resolve your query"; } return(this.View("ActionFulfill", actionResult)); } else { // not valid, continue to present form with missing/invalid parameters return(this.View(model)); } }
public async void GetConfigurationTest() { // arrage var storage = new MemoryStorage(); var userState = new UserState(storage); var conversationState = new ConversationState(storage); var adapter = new TestAdapter().Use(new AutoSaveStateMiddleware(conversationState)); var dialogState = conversationState.CreateProperty <DialogState>("dialogState"); var dialogs = new DialogSet(dialogState); var steps = new WaterfallStep[] { async(step, cancellationToken) => { await step.Context.SendActivityAsync("response"); // act ILuisService luisService = new LuisService(EnvironmentName, ContentRootPath, null, null); LuisConfig config = luisService.GetConfiguration(); // assert Assert.Equal(configuration.BingSpellCheckSubscriptionKey, config.BingSpellCheckSubscriptionKey); Assert.Collection <LuisApp>(configuration.LuisApplications, x => Xunit.Assert.Contains("name", x.Name)); Assert.Equal(configuration.LuisRouterUrl, config.LuisRouterUrl); return(Dialog.EndOfTurn); } }; dialogs.Add(new WaterfallDialog( "test", steps)); await new TestFlow(adapter, async(turnContext, cancellationToken) => { var dc = await dialogs.CreateContextAsync(turnContext, cancellationToken); await dc.ContinueDialogAsync(cancellationToken); if (!turnContext.Responded) { await dc.BeginDialogAsync("test", null, cancellationToken); } }) .Send("ask") .AssertReply("response") .StartTestAsync(); }
/// <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) { var attributes = new LuisModelAttribute( ConfigurationManager.AppSettings["LUISModelID"], ConfigurationManager.AppSettings["LUISSubscriptionKey"]); var service = new LuisService(attributes); await Conversation.SendAsync(activity, () => new MyFirstLuisDialog(service)); } else { HandleSystemMessage(activity); } var response = Request.CreateResponse(HttpStatusCode.OK); return(response); }
protected override void Load(ContainerBuilder builder) { builder.Register <RootDialog>(c => { var settings = c.Resolve <LuisModelSettings>(); var service = new LuisService(new LuisModelAttribute(settings.ModelId, settings.SubscriptionKey)); return(new RootDialog(service)); }); builder.RegisterType <OpenOrders>().AsSelf(); builder.RegisterType <OrderStatus>().AsSelf(); builder.RegisterType <Representative>().AsSelf(); builder.RegisterType <DialogFactory>().AsSelf(); base.Load(builder); }
private async Task <DialogTurnResult> FinalStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken = default) { var accessor = _userState.CreateProperty <string>("Solicitacao"); await accessor.SetAsync(stepContext.Context, (string)stepContext.Result, cancellationToken); var luisResult = await LuisService.ExecuteLuisQuery(_configuration, stepContext.Context, cancellationToken); if (luisResult.intent.Equals("None")) { return(await stepContext.BeginDialogAsync(nameof(LearningDialog), null, cancellationToken)); } else { await stepContext.Context.SendActivityAsync(Conversation.Answer(luisResult.intent), cancellationToken : cancellationToken); } return(await stepContext.ReplaceDialogAsync(nameof(LoopDialog), cancellationToken : cancellationToken)); }
public JArrayString ProcessMessage(RbAppMasterCache rbappmc, RbAppRouterCache rbapprc, RbHeader rbh, string rbBodyString) { var appInfo = JsonConvert.DeserializeObject <JObject>(rbappmc.AppInfo); appInfo["DeviceId"] = rbh.SourceDeviceId; var appParams = JsonConvert.DeserializeObject <JObject>(rbBodyString); JArrayString message = null; if (rbh.MessageId == "Speech") { var speechAppBody = new SpeechAppBody(); var personId = (appParams["PersonId"] ?? "").ToString(); var talk = (appParams["talk"] ?? "").ToString(); var luisService = new LuisService(rbh.SourceDeviceId, appInfo); speechAppBody.Behavior = luisService.CreateRobotBehavior(talk); speechAppBody.Behavior.NaturalTalkText = TextOverflow(speechAppBody.Behavior.NaturalTalkText); if (personId != "") { var actionClient = new HwsRobotBehaviorApi.Person.Action.Client(appInfo["SqlConnectionString"].ToString()); foreach (var entity in speechAppBody.Behavior.LuisEntities) { actionClient.CreateTalkLog(rbh.SourceDeviceId, personId, speechAppBody.Behavior.NaturalTalkText, talk, entity); } } message = new JArrayString(MakeProcessMessages(rbh, speechAppBody)); } else if (rbh.MessageId == "RobotSpeech") { var speechAppBody = new SpeechAppBody(); var talk = (appParams["talk"] ?? "").ToString(); var luisService = new LuisService(rbh.SourceDeviceId, appInfo); speechAppBody.Behavior = luisService.CreateRobotBehaviorDirectSpeech(talk); speechAppBody.Behavior.NaturalTalkText = TextOverflow(speechAppBody.Behavior.NaturalTalkText); message = new JArrayString(MakeProcessMessages(rbh, speechAppBody)); } else if (rbh.MessageId == "GetRobotAction") { var speechAppBody = RobotAction(rbh, appInfo, appParams); message = new JArrayString(MakeProcessMessages(rbh, speechAppBody)); } return(message); }
public void Uri_Building() { const string Model = "model"; const string Subscription = "subscription"; const string Domain = "domain"; const string Text = "text"; // TODO: xunit theory var tests = new[] { #pragma warning disable CS0612 new { m = new LuisModelAttribute(Model, Subscription, LuisApiVersion.V1, null) { }, u = new Uri("https://api.projectoxford.ai/luis/v1/application?subscription-key=subscription&q=text&id=model&log=True") }, new { m = new LuisModelAttribute(Model, Subscription, LuisApiVersion.V1, null) { Log = false, SpellCheck = false, Staging = false, TimezoneOffset = 1, Verbose = false }, u = new Uri("https://api.projectoxford.ai/luis/v1/application?subscription-key=subscription&q=text&id=model&log=False&spellCheck=False&staging=False&timezoneOffset=1&verbose=False") }, new { m = new LuisModelAttribute(Model, Subscription, LuisApiVersion.V1, Domain) { Log = true, SpellCheck = true, Staging = true, TimezoneOffset = 2, Verbose = true }, u = new Uri("https://api.projectoxford.ai/luis/v1/application?subscription-key=subscription&q=text&id=model&log=True&spellCheck=True&staging=True&timezoneOffset=2&verbose=True") }, #pragma warning restore CS0612 new { m = new LuisModelAttribute(Model, Subscription, LuisApiVersion.V2, null) { }, u = new Uri("https://westus.api.cognitive.microsoft.com/luis/v2.0/apps/model?subscription-key=subscription&q=text&log=True") }, new { m = new LuisModelAttribute(Model, Subscription, LuisApiVersion.V2, null) { Log = false, SpellCheck = false, Staging = false, TimezoneOffset = 1, Verbose = false }, u = new Uri("https://westus.api.cognitive.microsoft.com/luis/v2.0/apps/model?subscription-key=subscription&q=text&log=False&spellCheck=False&staging=False&timezoneOffset=1&verbose=False") }, new { m = new LuisModelAttribute(Model, Subscription, LuisApiVersion.V2, Domain) { Log = true, SpellCheck = true, Staging = true, TimezoneOffset = 2, Verbose = true }, u = new Uri("https://domain/luis/v2.0/apps/model?subscription-key=subscription&q=text&log=True&spellCheck=True&staging=True&timezoneOffset=2&verbose=True") }, }; foreach (var test in tests) { ILuisService service = new LuisService(test.m); var actual = service.BuildUri(Text); Assert.AreEqual(test.u, actual); } }
public static async System.Threading.Tasks.Task <string> MessageHandler(string inputStr) { string response = String.Empty; // Convert input string to FaqLuis Model LuisObject faqLuis = await LuisService.ParseFaqInput(inputStr); if (faqLuis.topScoringIntent != null) { switch (faqLuis.topScoringIntent.intent) { case "FaqQuery": response = await FaqService.FaqQueryProcessor(faqLuis.topScoringIntent); break; case "Assistance": response = ResponseSet.GetRandomResponse(ResponseSet.Assistance); break; case "DirectAddress": response = await DirectAddressHandler(inputStr); break; case "Farewell": response = ResponseSet.GetRandomResponse(ResponseSet.Farewells); break; case "Politeness": response = ResponseSet.GetRandomResponse(ResponseSet.Emojis); break; //- Could not place request default: response = ResponseSet.GetRandomResponse(ResponseSet.Nones); break; } } return(response); }
private async Task <DialogTurnResult> FinalStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken = default) { var accessor = _userState.CreateProperty <string>("Solicitacao"); var solicitacao = await accessor.GetAsync(stepContext.Context, cancellationToken : cancellationToken); var intencaoSolicitacao = ((FoundChoice)stepContext.Result).Value; var intentName = "None"; switch (intencaoSolicitacao) { case "Nenhuma": intentName = "None"; break; case "Estou apenas te cumprimentando :)": intentName = "Saudacao"; break; case "Fazer uma reserva": intentName = "Reserva"; break; case "Solicitar o serviço de quarto": intentName = "ServicoQuarto"; break; case "Solicitar o serviço de despertador": intentName = "Despertador"; break; case "Sair": return(await stepContext.ReplaceDialogAsync(nameof(RootDialog), cancellationToken : cancellationToken)); } Task.Run(() => LuisService.Learn(_configuration, solicitacao, intentName)); var message = Conversation.Answer(intentName); await stepContext.Context.SendActivityAsync(message, cancellationToken : cancellationToken); return(await stepContext.ReplaceDialogAsync(nameof(LoopDialog), cancellationToken : cancellationToken)); }
private async Task <DialogTurnResult> VerifyLuisIntentionStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken) { var response = stepContext.Context.Activity.CreateReply(); if (Log) { UltimaMensagem = stepContext.Context.Activity.Text; var intencao = LuisService.ObterIntencao(UltimaMensagem); switch (intencao) { case "BancoDeHorasQuery": response.Attachments = new List <Attachment>() { ObterCardAttachment("HorasCard.json") }; await stepContext.Context.SendActivityAsync(response); UltimaMensagem = stepContext.Context.Activity.Text; return(await stepContext.EndDialogAsync(cancellationToken : cancellationToken)); case "ProximasFeriasQuery": response.Attachments = new List <Attachment>() { ObterCardAttachment("FeriasCard.json") }; await stepContext.Context.SendActivityAsync(response); UltimaMensagem = stepContext.Context.Activity.Text; return(await stepContext.EndDialogAsync(cancellationToken : cancellationToken)); default: await stepContext.Context.SendActivityAsync(MessageFactory.Text("Não entendi sua pergunta...")); UltimaMensagem = stepContext.Context.Activity.Text; return(await stepContext.EndDialogAsync(cancellationToken : cancellationToken)); } } else { return(await stepContext.NextAsync("", cancellationToken)); } }
private async Task MessageReceiveAsync(IDialogContext context, IAwaitable <IMessageActivity> result) { var userInput = await result; LuisService luisService = new LuisService(); string intent = await luisService.GetTopIntent(userInput.Text); switch (intent) { case "AskNewinfo": await context.PostAsync($"最新情報が知りたいのですね。[このリンク](https://blogs.technet.microsoft.com/office365-tech-japan/)を確認してみてください。"); break; case "AskHowto": await context.PostAsync($"How toが知りたいのですね。[このリンク](https://blogs.msdn.microsoft.com/lync_support_team_blog_japan/)を確認してみてください。"); break; } context.Done <object>(null); }
/// <summary> /// Initialize the bot's references to external services. /// /// For example, QnaMaker services are created here. /// These external services are configured /// using the <see cref="AppSettings"/> class (based on the contents of your "appsettings.json" file). /// </summary> /// <param name="appSettings"><see cref="AppSettings"/> object based on your "appsettings.json" file.</param> /// <returns>A <see cref="BotServices"/> representing client objects to access external services the bot uses.</returns> /// <seealso cref="AppSettings"/> /// <seealso cref="QnAMaker"/> /// <seealso cref="LuisService"/> public static BotServices InitBotServices(AppSettings appSettings) { var luisIntents = appSettings.luisIntents; var qnaServices = new Dictionary <string, QnAMaker>(); LuisRecognizer luisRecignizerService = null; List <string> IntentsList = appSettings.luisIntents; //Prepare Luis service LuisService luisService = new LuisService() { AppId = appSettings.luisApp.appId, AuthoringKey = appSettings.luisApp.authoringKey, Id = appSettings.luisApp.id, Name = appSettings.luisApp.name, Region = appSettings.luisApp.region, SubscriptionKey = appSettings.luisApp.subscriptionKey, Type = appSettings.luisApp.type, Version = appSettings.luisApp.version }; var luisApp = new LuisApplication(luisService.AppId, luisService.AuthoringKey, luisService.GetEndpoint()); luisRecignizerService = new LuisRecognizer(luisApp); //Prepare QnA service foreach (var qna in appSettings.qnaServices) { var qnaEndpoint = new QnAMakerEndpoint() { KnowledgeBaseId = qna.kbId, EndpointKey = qna.endpointKey, Host = qna.hostname, }; var qnaMaker = new QnAMaker(qnaEndpoint); qnaServices.Add(qna.name, qnaMaker); } //return new BotServices(luisRecignizerService, qnaServices, Intents); return(new BotServices() { Intents = IntentsList, LuisRecognizerService = luisRecignizerService, QnAServices = qnaServices, }); }
private static async Task RunQuery(string query) { // Process message var luisService = new LuisService(new LuisModelAttribute(ConfigurationManager.AppSettings["LUIS_ModelId"], ConfigurationManager.AppSettings["LUIS_SubscriptionKey"])); var luisResult = await luisService.QueryAsync(query, CancellationToken.None); // Try to resolve intent to action var intentName = default(string); var intentEntities = default(IList <EntityRecommendation>); var intentAction = new LuisActionResolver(typeof(GetTimeInPlaceAction).Assembly) .ResolveActionFromLuisIntent(luisResult, out intentName, out intentEntities); if (intentAction != null) { var executionContextChain = new List <ActionExecutionContext> { new ActionExecutionContext(intentName, intentAction) }; while (LuisActionResolver.IsContextualAction(intentAction)) { var luisActionDefinition = default(LuisActionBindingAttribute); if (!LuisActionResolver.CanStartWithNoContextAction(intentAction, out luisActionDefinition)) { Console.WriteLine($"Cannot start contextual action '{luisActionDefinition.FriendlyName}' without a valid context."); return; } intentAction = LuisActionResolver.BuildContextForContextualAction(intentAction, out intentName); if (intentAction != null) { executionContextChain.Insert(0, new ActionExecutionContext(intentName, intentAction)); } } await RunActions(luisService, executionContextChain); } else { Console.WriteLine("Could not understand the input."); } }
/// <summary> /// POST: api/Messages /// Receive a message from a user and reply to it /// </summary> public async Task <HttpResponseMessage> Post([FromBody] Activity activity) { var connector = new ConnectorClient(new Uri(activity.ServiceUrl)); var attributes = new LuisModelAttribute( ConfigurationManager.AppSettings["LuisId"], ConfigurationManager.AppSettings["LuisSubscriptionKey"]); var service = new LuisService(attributes); if (activity.Type == ActivityTypes.Message) { await Conversation.SendAsync(activity, () => new ImageDescriptor(service)); } else { HandleSystemMessage(activity); } var response = Request.CreateResponse(HttpStatusCode.OK); return(response); }
/// <summary> /// POST: api/Messages /// Receive a message from a user and reply to it /// </summary> public async Task <HttpResponseMessage> Post([FromBody] Activity activity) { var connector = new ConnectorClient(new Uri(activity.ServiceUrl)); var luisAttributes = new LuisModelAttribute( ConfigurationManager.AppSettings["LuisID"], ConfigurationManager.AppSettings["LuisSubscriptionKey"]); var luisService = new LuisService(luisAttributes); switch (activity.Type) { case ActivityTypes.Message: // If receive a start command from Telegram... if (activity.Text == "/start") { var telegram = activity.CreateReply(); telegram.Text = "Olá, que bom ver você por aqui no Telegram!"; await connector.Conversations.ReplyToActivityAsync(telegram); break; } // Send to Luis consideration... await Conversation.SendAsync(activity, () => new RootDialog(luisService)); break; case ActivityTypes.ConversationUpdate: if (activity.MembersAdded.Any(o => o.Id == activity.Recipient.Id)) { var reply = activity.CreateReply(); reply.Text = "Olá, que bom ver você por aqui!"; await connector.Conversations.ReplyToActivityAsync(reply); } break; } return(Request.CreateResponse(HttpStatusCode.OK)); }
public LuisTaskRecognizer() { var service = new LuisService() { AppId = "5e7068ca-eaa8-42f8-b6b0-f603b070c5ee", SubscriptionKey = "2760aa3227d8414f9e948ac5eb1849fb", Region = "westus", Version = "2.0", }; var app = new LuisApplication(service); var regOptions = new LuisRecognizerOptionsV2(app) { IncludeAPIResults = true, PredictionOptions = new LuisPredictionOptions() { IncludeAllIntents = true, IncludeInstanceData = true } }; _luisRecognizer = new Microsoft.Bot.Builder.AI.Luis.LuisRecognizer(regOptions); }
/// <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) { //await Conversation.SendAsync(activity, () => new Dialogs.RootDialog()); //para LUIS Bot var luisAttributes = new LuisModelAttribute( ConfigurationManager.AppSettings["LuisId"], ConfigurationManager.AppSettings["LuisSubscriptionKey"] ); var luisService = new LuisService(luisAttributes); await Conversation.SendAsync(activity, () => new Dialogs.PrevisaoTempoDialog(luisService)); } else { HandleSystemMessage(activity); } var response = Request.CreateResponse(HttpStatusCode.OK); return(response); }
public LuisHelper() { var service = new LuisService() { AppId = "a4fe9ae0-be39-4837-b2d9-ed3ca0b33af2", SubscriptionKey = "127183aa64af4de893cc822599f2a4ec", Region = "eastus", Version = "0.1" }; var app = new LuisApplication(service); var regOptions = new LuisRecognizerOptionsV2(app) { IncludeAPIResults = true, PredictionOptions = new LuisPredictionOptions() { IncludeAllIntents = true, IncludeInstanceData = true } }; _luisRecognizer = new LuisRecognizer(regOptions); }