public async Task QnaMaker_ReturnsAnswer_Configuration() { var mockHttp = new MockHttpMessageHandler(); mockHttp.When(HttpMethod.Post, GetRequestUrl()) .Respond("application/json", GetResponse("QnaMaker_ReturnsAnswer.json")); var service = new QnAMakerService { KbId = _knowlegeBaseId, EndpointKey = _endpointKey, Hostname = _hostname }; var options = new QnAMakerOptions { Top = 1 }; var client = new HttpClient(mockHttp); var qna = new QnAMaker(service, options, client); var results = await qna.GetAnswersAsync(GetContext("how do I clean the stove?")); Assert.IsNotNull(results); Assert.AreEqual(results.Length, 1, "should get one result"); StringAssert.StartsWith(results[0].Answer, "BaseCamp: You can use a damp rag to clean around the Power Pack"); }
private static IQnAService CreateQnAService(string subscriptionKey, string knowledgeBaseId, string defaultMessage = null, double scoreThreshhold = 0.3, int top = 1) { var qnaAttribute = new QnAMakerAttribute(subscriptionKey, knowledgeBaseId, defaultMessage, scoreThreshhold, top); IQnAService qnAService = new QnAMakerService(qnaAttribute); return(qnAService); }
public async Task None(IDialogContext context, LuisResult result) { context.SendTypingAcitivity(); var k = new QnAMakerService(new QnAMakerAttribute(WebConfigurationManager.AppSettings["QNAAuthKey"], WebConfigurationManager.AppSettings["QNAKnowledgeBaseId"], "Sorry Could not get that", .3, endpointHostName: WebConfigurationManager.AppSettings["QNAEndpointUrl"])); await context.Forward(new QnADialog(k), this.ResumeAfter, context.Activity, CancellationToken.None); }
public async Task <IActionResult> Edit(string id, [Bind("Id,ServiceId,BaseAddress,Key,DisplayName,DisplayCategory")] QnAMakerService qnAMakerService) { if (id != qnAMakerService.Id) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(qnAMakerService); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!QnAMakerServiceExists(qnAMakerService.Id)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(qnAMakerService)); }
QnAMaker QnA(string EndpointKey, string KbId, string Hostname) { QnAMakerService Q = new QnAMakerService(); Q.EndpointKey = EndpointKey; Q.KbId = KbId; Q.Hostname = Hostname; return(new QnAMaker(Q)); }
public async Task QnAs(IDialogContext context, LuisResult result) { var answers = await QnAMakerService.GenerateAnswer(result.Query); var answer = JObject.Parse(answers)["answers"][0]["answer"].ToString(); await context.PostAsync(answer); context.Done <IArticle>(null); // 不返回文段 }
/// <summary> /// Initializes a new instance of the <see cref="HomeController"/> class. /// </summary> /// <param name="httpClient">Http client to be used.</param> /// <param name="tokenHelper">Token Helper.</param> /// <param name="kbInfoHelper">Knowledge base helper</param> /// <param name="graphHelper">Graph api helper</param> /// <param name="qnaMakerService">QnAMaker service</param> /// <param name="knowledgeBaseRefreshHelper"> Knowledge Base Refresh Helper </param> public HomeController(HttpClient httpClient, TokenHelper tokenHelper, KBInfoHelper kbInfoHelper, GraphHelper graphHelper, QnAMakerService qnaMakerService, KnowledgeBaseRefreshHelper knowledgeBaseRefreshHelper) { this.httpClient = httpClient; this.tokenHelper = tokenHelper; this.kbInfoHelper = kbInfoHelper; this.graphHelper = graphHelper; this.qnaMakerService = qnaMakerService; this.knowledgeBaseRefreshHelper = knowledgeBaseRefreshHelper; }
public async Task Cumprimento(IDialogContext context, LuisResult result) { ConversationStarter.TextReference = string.Empty; await context.PostAsync($"Texto enviado: {result.Query}"); var qnaService = new QnAMakerService(new QnAMakerAttribute(qnaSubscriptionKey, qnaKnowledgebaseId, "Buguei aqui, pera! ¯\(º_o)/¯")); var qnaMaker = new QnAMakerDialog(qnaService); await qnaMaker.MessageReceivedAsync(context, Awaitable.FromItem(activity)); }
/// <summary> /// Initializes a new instance of the <see cref="SearchController"/> class. /// </summary> /// <param name="jwtHelper">JWT Helper.</param> /// <param name="kbInfoHelper">KB helper to use</param> /// <param name="qnaMakerService">QnA Maker service to use</param> /// <param name="logProvider">Log provider to use</param> public SearchController(JwtHelper jwtHelper, KBInfoHelper kbInfoHelper, QnAMakerService qnaMakerService, ILogProvider logProvider) { this.jwtHelper = jwtHelper; this.tenantId = ConfigurationManager.AppSettings["TenantId"]; this.kbInfoHelper = kbInfoHelper; this.qnaMakerService = qnaMakerService; this.logProvider = logProvider; this.topResultsToBeFetched = Convert.ToInt32(ConfigurationManager.AppSettings["TopResultCount"]); this.minimumConfidenceScore = Convert.ToInt32(ConfigurationManager.AppSettings["MinimumConfidenceScore"]); }
public async Task <TextAndAudioWrapper> InputQuestionAndReturnAnswer(TextInput textInput) { var luisService = new LuisService(); var wrapper = new TextAndAudioWrapper(); var question = textInput.Text; var generalKB = new QnAMakerService(_qnaHostName, "d282ad63-9701-4548-afac-a421f0ec43ed", _endPointKey); var groupKB = new QnAMakerService(_qnaHostName, "b51f7e68-706b-42e4-8b31-0dd34d392a54", _endPointKey); var postKB = new QnAMakerService(_qnaHostName, "92e0fe0c-8826-4e60-8c47-9a4d36cb629e", _endPointKey); var intent = await luisService.GetIntent(question); string answer; switch (intent) { case "Group": answer = await groupKB.GetAnswer(question); break; case "Post": answer = await postKB.GetAnswer(question); break; case "None": answer = await generalKB.GetAnswer(question); break; default: answer = "Sorry, I don't know that."; break; } if (answer == "") { answer = "Sorry, I don't know that."; } var textToSpeechService = new TextToSpeechService(); var audioAnswer = await textToSpeechService.GenerateAudioSpeech(answer); wrapper.Text = answer; wrapper.Audio = audioAnswer; return(wrapper); }
public async Task <IActionResult> Create([Bind("Id,ServiceId,BaseAddress,Key,DisplayName,DisplayCategory")] QnAMakerService qnAMakerService) { if (ModelState.IsValid) { _context.Add(qnAMakerService); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(qnAMakerService)); }
public async void AskForATopicTest() { var storage = new MemoryStorage(); var userState = new UserState(storage); var conversationState = new ConversationState(storage); var adapter = new TestAdapter() .Use(new AutoSaveStateMiddleware(conversationState)); var handler = new HttpClientHandler(); handler.ServerCertificateCustomValidationCallback = (message, cert, chain, errors) => true; var httpClient = new HttpClient(handler); // adding LUIS Router service LuisRouterService luisRouterService = new LuisRouterService(httpClient, Startup.EnvironmentName, Startup.ContentRootPath, userState, null); // adding QnAMaker service QnAMakerService qnaMakerService = new QnAMakerService(httpClient, Startup.EnvironmentName, Startup.ContentRootPath); var accessors = new BotAccessor(new LoggerFactory(), conversationState, userState) { ConversationDialogState = conversationState.CreateProperty <DialogState>("DialogState"), AskForExamplePreference = conversationState.CreateProperty <bool>("AskForExamplePreference"), IsAuthenticatedPreference = userState.CreateProperty <bool>("IsAuthenticatedPreference") }; await new TestFlow(adapter, async(turnContext, cancellationToken) => { var state = await accessors.ConversationDialogState.GetAsync(turnContext, () => new DialogState()); var dialogs = new DialogSet(accessors.ConversationDialogState); dialogs.Add(new LuisQnADialog(accessors, luisRouterService, qnaMakerService)); var dc = await dialogs.CreateContextAsync(turnContext, cancellationToken); var results = await dc.ContinueDialogAsync(cancellationToken); if (results.Status == DialogTurnStatus.Empty) { await dc.BeginDialogAsync(nameof(LuisQnADialog), null, cancellationToken); } else if (results.Status == DialogTurnStatus.Complete) { //no additional send activities. } }) .Send("") .AssertReply("What topic would you like to know more about?") .Send("what do i need to consider for an interview?") .AssertReply("In interviews, your job is to convince a recruiter that you have the skills, knowledge and experience for the job. Show motivation and convince a recruiter that you fit the organization's culture and job description, and you get that much closer to an offer.") .StartTestAsync(); }
private async Task QnaMakerMessage(IDialogContext context, string query) { var qnaService = new QnAMakerService(); string respuesta = qnaService.GetAnswer(query); if (respuesta.Equals(QnAMakerConstantes.AnswerNotFound)) { await context.PostAsync("Lo siento, no estoy preparado para este tipo de preguntas."); } else { await context.PostAsync(respuesta); } }
private async Task QnaMakerMessage(IDialogContext context, string query) { var qnaService = new QnAMakerService(); string respuesta = qnaService.GetAnswer(query); if (respuesta.Equals(QnaMakerConstants.AnswerNotFound)) { await context.PostAsync("Lo siento pero no tengo una respuesta para esa pregunta."); } else { await context.PostAsync(respuesta); } }
private async Task MessageReceivedAsync(IDialogContext context, IAwaitable <object> result) { var message = await result as Activity; var serviceQnaMaker = new QnAMakerService(); var respuesta = serviceQnaMaker.GetAnswer(message.Text); if (respuesta.Equals(QnaMakerConstants.AnswerNotFound)) { await context.PostAsync("Lo siento, pero no estoy preparado para este tipo de preguntas."); } else { await context.PostAsync(respuesta); } }
public void QnaMakerSuffixTest() { var qnamaker = new QnAMakerService { Hostname = "http://foo.azurewebsites.net" }; Assert.Equal("http://foo.azurewebsites.net/qnamaker", qnamaker.Hostname); qnamaker = new QnAMakerService { Hostname = "http://foo.azurewebsites.net/asdf?x=15" }; Assert.Equal("http://foo.azurewebsites.net/qnamaker", qnamaker.Hostname); qnamaker = JsonConvert.DeserializeObject <QnAMakerService>("{\"hostname\":\"http://foo.azurewebsites.net/asdf?x=15\"}"); Assert.Equal("http://foo.azurewebsites.net/qnamaker", qnamaker.Hostname); }
public async void GetConfigurationTest() { // arrage HttpClient httpClient = new HttpClient(); 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 IQnAMakerService qnAMakerService = new QnAMakerService(httpClient, EnvironmentName, ContentRootPath); QnAMakerConfig config = qnAMakerService.GetConfiguration(); // assert Assert.Equal(configuration.KbId, config.KbId); Assert.Equal(configuration.Name, config.Name); Assert.Equal(configuration.EndpointKey, config.EndpointKey); Assert.Equal(configuration.Hostname, config.Hostname); 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(); }
public static void Validate(this QnAMakerService qnaService) { if (string.IsNullOrWhiteSpace(qnaService.KbId)) { throw new InvalidOperationException("The QnA KnowledgeBaseId ('kbId') is required to run this sample. Please update your 'appsettings.json' file."); } if (string.IsNullOrWhiteSpace(qnaService.EndpointKey)) { throw new InvalidOperationException("The QnA EndpointKey ('endpointKey') is required to run this sample. Please update your 'appsettings.json' file."); } if (string.IsNullOrWhiteSpace(qnaService.Hostname)) { throw new InvalidOperationException("The QnA Host ('hostname') is required to run this sample. Please update your 'appsettings.json' file."); } }
/// <inheritdoc/> public QnAMaker GetQnAMaker(string knowledgeBaseId, string endpointKey) { return(this.qnaMakerInstances.GetOrAdd(knowledgeBaseId, (kbId) => { var serviceConfig = new QnAMakerService { KbId = kbId, EndpointKey = endpointKey, Hostname = this.configuration["QnAMakerHostUrl"] }; var options = new QnAMakerOptions { Top = 1, ScoreThreshold = float.Parse(this.configuration["ScoreThreshold"], CultureInfo.InvariantCulture), }; return new QnAMaker(serviceConfig, options, this.httpClient); })); }
/// <summary> /// Creates Knowledge base /// </summary> /// <param name="kbName">Knowledge base name</param> /// <param name="qnAMakerService">QnAMaker service</param> /// <returns>Returns kbId</returns> private async Task <string> CreateEmptyKB(string kbName, QnAMakerService qnAMakerService) { string kbId = string.Empty; CreateKBRequest createKBRequest = new CreateKBRequest() { Name = kbName, }; var qnaMakerResponse = await qnAMakerService.CreateKB(createKBRequest); var operationResponse = await qnAMakerService.AwaitOperationCompletionResponse(qnaMakerResponse); if (qnAMakerService.IsOperationSuccessful(operationResponse.OperationState)) { kbId = operationResponse.ResourceLocation.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries)[1]; } return(kbId); }
public async Task OnTurnAsync(ITurnContext turnContext, CancellationToken cancellationToken = default(CancellationToken)) { if (turnContext.Activity.Type == ActivityTypes.Message) { // Check LUIS model var recognizerResult = await _services.LuisServices[LuisKey].RecognizeAsync(turnContext, cancellationToken); var topIntent = recognizerResult?.GetTopScoringIntent(); var Itent = topIntent.Value.intent; QnAMakerService qna = new QnAMakerService("https://luischatbotteste.azurewebsites.net", "3edfd898-ca35-444b-acc7-0d160c01fd1d", "fb4792a0-7297-4961-9c87-17db2a2b4e21"); if (topIntent != null && topIntent.HasValue && topIntent.Value.intent != "None") { var qnaMakerAnswer = await qna.GetAnswer(Itent); await turnContext.SendActivityAsync(qnaMakerAnswer); await turnContext.SendActivityAsync($"==>LUIS Top Scoring Intent: {topIntent.Value.intent}, Score: {ans.answer}\n"); } else { var msg = @"No LUIS intents were found. This sample is about identifying two user intents: 'Calendar.Add' 'Calendar.Find' Try typing 'Add Event' or 'Show me tomorrow'."; await turnContext.SendActivityAsync(msg); } } else if (turnContext.Activity.Type == ActivityTypes.ConversationUpdate) { // Send a welcome message to the user and tell them what actions they may perform to use this bot await SendWelcomeMessageAsync(turnContext, cancellationToken); } else { await turnContext.SendActivityAsync($"{turnContext.Activity.Type} event detected", cancellationToken : cancellationToken); } }
public BotConfig(IConfiguration config) { Padlock = ""; Name = "AisBot"; Description = "Generated bot file for emulator reference"; CosmosStorage = new CosmosDbService(); config.Bind("botSettings:cosmosDb", CosmosStorage); Services.Add(CosmosStorage); QnAMaker = new QnAMakerService(); config.Bind("botSettings:qna", QnAMaker); Services.Add(QnAMaker); AppInsights = new AppInsightsService(); config.Bind("botSettings:appInsights", AppInsights); Services.Add(AppInsights); Secret = config["botSettings:secret"]; }
/// <summary> /// Handles the users input and sends it to the QnA Maker database for handling /// </summary> /// <param name="context"></param> /// <param name="result"></param> /// <returns></returns> private async Task MessageReceivedAsync(IDialogContext context, IAwaitable <object> result) { var activity = await result as Activity; // We create a new QnAMaker service for handling the small talk. This is hard coded here for now // TODO Remove before publishing the source code publicly var smallTalkService = new QnAMakerService("", "", SupportBot.Models.ServiceRegion.WestUS, "Small Talk"); try { // If the service returns and answer we post it to the conversation, we use a standard confidence of 0.0 to get an answer var answer = await smallTalkService.GenerateAnswerStringAsync(activity.Text); if (answer != null && answer != string.Empty && answer != "No good match found in the KB") { await context.PostAsync(answer); } else { // If we don't have an appropriate response we provide a default answer await context.PostAsync(Resources.BotTexts.NoAnswerSmallTalk); } } catch (Exception e) { //TODO Remove await context.PostAsync(e.Message); // Tell the user if the QnA maker service is not available or any other problem occors await context.PostAsync(Resources.BotTexts.DatebaseNotAvailable); } finally { // End the dialog context.Done(String.Empty); } }
/// <summary> /// Initializes a new instance of the <see cref="QnAMakerEndpoint"/> class. /// </summary> /// <param name="service">QnA service details from configuration.</param> public QnAMakerEndpoint(QnAMakerService service) { KnowledgeBaseId = service.KbId; EndpointKey = service.EndpointKey; Host = service.Hostname; }
/// Initializes a new instance of the <see cref="QnAMaker"/> class. /// </summary> /// <param name="service">QnA service details from configuration.</param> /// <param name="options">The options for the QnA Maker knowledge base.</param> /// <param name="httpClient">An alternate client with which to talk to QnAMaker. /// If null, a default client is used for this instance.</param> public QnAMaker(QnAMakerService service, QnAMakerOptions options = null, HttpClient httpClient = null) : this(new QnAMakerEndpoint(service), options, httpClient, null) { }
/// Initializes a new instance of the <see cref="QnAMaker"/> class. /// </summary> /// <param name="service">QnA service details from configuration.</param> /// <param name="options">The options for the QnA Maker knowledge base.</param> /// <param name="httpClient">An alternate client with which to talk to QnAMaker. /// If null, a default client is used for this instance.</param> /// <param name="telemetryClient">The IBotTelemetryClient used for logging telemetry events.</param> /// <param name="logPersonalInformation">Set to true to include personally indentifiable information in telemetry events.</param> public QnAMaker(QnAMakerService service, QnAMakerOptions options, HttpClient httpClient, IBotTelemetryClient telemetryClient, bool logPersonalInformation = false) : this(new QnAMakerEndpoint(service), options, httpClient, telemetryClient, logPersonalInformation) { }
public async Task Apresentacao(IDialogContext context, LuisResult result) { var qnaService = new QnAMakerService(new QnAMakerAttribute(qnaSubscriptionKey, qnaKnowledgebaseId, "Buguei aqui, pera! ¯\(º_o)/¯")); var qnaMaker = new QnAMakerDialog(qnaService); await qnaMaker.MessageReceivedAsync(context, Awaitable.FromItem(ArgumentoStatic.Argument)); }
public QnaDialog(QnAMakerService qnaService) : base(qnaService) { }
public static bool IsValid(this QnAMakerService qnaService) { return(!(string.IsNullOrWhiteSpace(qnaService.KbId) || string.IsNullOrWhiteSpace(qnaService.EndpointKey) || string.IsNullOrWhiteSpace(qnaService.Hostname))); }
public void EncryptWithEmptyPropertiesOK() { // all of these objects should have null properties, this should not cause secret to blow up var secret = Guid.NewGuid().ToString("n"); try { var generic = new GenericService(); generic.Configuration["test"] = string.Empty; generic.Encrypt(secret); generic.Decrypt(secret); } catch (Exception) { Assert.Fail("generic failed with empty values"); } try { var file = new FileService { Path = string.Empty, }; file.Encrypt(secret); file.Decrypt(secret); } catch (Exception) { Assert.Fail("file failed with empty values"); } try { var luis = new LuisService { SubscriptionKey = string.Empty, }; luis.Encrypt(secret); luis.Decrypt(secret); } catch (Exception) { Assert.Fail("luis failed with empty values"); } try { var dispatch = new DispatchService { SubscriptionKey = string.Empty, }; dispatch.Encrypt(secret); dispatch.Decrypt(secret); } catch (Exception) { Assert.Fail("dispatch failed with empty values"); } try { var insights = new AppInsightsService { InstrumentationKey = string.Empty, }; insights.Encrypt(secret); insights.Decrypt(secret); } catch (Exception) { Assert.Fail("insights failed with empty values"); } try { var bot = new BotService(); bot.Encrypt(secret); bot.Decrypt(secret); } catch (Exception) { Assert.Fail("bot failed with empty values"); } try { var cosmos = new CosmosDbService { Key = string.Empty, }; cosmos.Encrypt(secret); cosmos.Decrypt(secret); } catch (Exception) { Assert.Fail("cosmos failed with empty values"); } try { var qna = new QnAMakerService { SubscriptionKey = string.Empty, }; qna.Encrypt(secret); qna.Decrypt(secret); } catch (Exception) { Assert.Fail("qna failed with empty values"); } try { var blob = new BlobStorageService { ConnectionString = string.Empty, }; blob.Encrypt(secret); blob.Decrypt(secret); } catch (Exception) { Assert.Fail("blob failed with empty values"); } try { var endpoint = new EndpointService { AppPassword = string.Empty, }; endpoint.Encrypt(secret); endpoint.Decrypt(secret); } catch (Exception) { Assert.Fail("endpoint failed with empty values"); } }