public async Task <IActionResult> PostAsync([FromBody] SetupRequest request)
        {
            // Validate data
            if (string.IsNullOrEmpty(request.ConversationId) || string.IsNullOrEmpty(request.ResourceId))
            {
                this.logger.LogWarning("Invalid request object. Either chat id of resource id is null or empty.");
                return(new BadRequestResult());
            }

            // Check if resource exists. (should also check if user is authorized to access resource. Skipped in the sample.)
            var resource = await this.resourceProvider.GetResourceAsync(request.ResourceId);

            if (resource == null)
            {
                this.logger.LogWarning($"Resource not found! Resource Id from incoming request: {request.ResourceId}");
                return(new NotFoundResult());
            }

            // Prepare conversation Context.
            var conversationContext = new ConversationContext()
            {
                ConversationId        = request.ConversationId,
                ConversationType      = request.ConversationType,
                IsMeetingConversation = !string.IsNullOrEmpty(request.MeetingId),
                MeetingId             = request.MeetingId,
                TeamId = request.TeamId,
            };

            var response = await this.SetupReviewMeetingAsync(conversationContext, resource);

            return(new OkObjectResult(response));
        }
 private static void UpdateContextWithNewSuggestions(ConversationContext context, IEnumerable <Document> documents)
 {
     foreach (var document in documents)
     {
         context.SuggestedDocuments.Add(document);
     }
 }
Example #3
0
 public FieldNPCSpeaker(
     ConversationContext context,
     FieldNPC fieldNPC
     ) : base(context)
 {
     _fieldNPC = fieldNPC;
 }
Example #4
0
        private async Task OnUserPortalScriptRequest(IPacket packet)
        {
            packet.Decode <byte>();

            var portalName = packet.Decode <string>();
            var portal     = Field.Template.Portals.Values.FirstOrDefault(p => p.Name.Equals(portalName));

            if (portal == null)
            {
                return;
            }
            if (string.IsNullOrEmpty(portal.Script))
            {
                return;
            }

            var context      = new ConversationContext(Socket);
            var conversation = Socket.WvsGame.ConversationManager.Get(
                portal.Script,
                context,
                new FieldPortalSpeaker(context, portal, Field),
                new FieldUserSpeaker(context, this)
                );

            await Converse(conversation);
        }
Example #5
0
        public Task Converse(IConversation conversation)
        {
            if (ConversationContext != null)
            {
                throw new InvalidOperationException("Already having a conversation");
            }
            ConversationContext = conversation.Context;

            return(Task
                   .Run(conversation.Start, ConversationContext.TokenSource.Token)
                   .ContinueWith(async t =>
            {
                if (t.IsFaulted)
                {
                    var exception = t.Exception?.Flatten().InnerException;

                    if (!(exception is TaskCanceledException))
                    {
                        Logger.Error(exception, "Caught exception when executing conversation");
                    }
                }

                ConversationContext?.Dispose();
                ConversationContext = null;
                await ModifyStats(exclRequest: true);
            }));
        }
Example #6
0
        public async Task TestLoginExpectNoErrors()
        {
            var response = await IgRestService.Authenticate(_conversationContext, _identifier, _password);

            _conversationContext = IgRestService.GetConversationContext();
            Assert.IsTrue(response.StatusCode == HttpStatusCode.OK && _conversationContext.xSecurityToken.Length > 0);
        }
        public void ReplyHandlingTest()
        {
            var text = "hello";
            IConversationContext context = new ConversationContext
            {
                Entry = new Entry
                {
                    Message = new Messaging
                    {
                        Message = new EntryMessage
                        {
                            Text = text
                        }
                    }
                },
                Route = new Route()
            };
            var replyItem = new ReplyItem {
                ReplyType = "raw", Reply = new ReplyMessage()
            };

            this.replyConfigurationMock.Setup(x => x.FetchReplyItem(It.IsAny <IConversationContext>())).Returns(Task.FromResult(replyItem));

            this.replyHandler.InvokeAsync(context).Wait();

            this.replyConfigurationMock.Verify(x => x.FetchReplyItem(context), Times.Exactly(1));
            this.replyFactroyMock.Verify(x => x.CreateReplyAsync(context, replyItem), Times.Exactly(1));
        }
        public void ReplyHandlingTest()
        {
            var text = "hello";
            IConversationContext context = new ConversationContext
            {
                Entry = new Entry
                {
                    Message = new Messaging
                    {
                        Message = new EntryMessage
                        {
                            Text = text
                        }
                    }
                },
                Route = new Route()
            };
            var replyItem = new ReplyItem {
                ReplyType = "raw", Reply = new ReplyMessage()
            };

            this.genericExpressionFactoryMock.Setup(x => x.Create(It.Is <string>(s => s == "raw"), builderFactory, context, It.IsAny <string>())).
            Returns(Task.FromResult(new ReplyMessage
            {
                Text = text
            }));

            this.replyFactory.CreateReplyAsync(context, replyItem).Wait();
            var reply = this.replyFactory.CreateReplyAsync(context, replyItem).Result;

            Assert.True(reply.Message.Text == text);
            this.genericExpressionFactoryMock.VerifyAll();
        }
        internal string CreateQuery(ConversationContext conversationContext)
        {
            var words      = new HashSet <string>(StringComparer.InvariantCultureIgnoreCase);
            var queryWords = new Queue <string>();

            using (var allParsedRelevantQueriesEnumerator = conversationContext.ContextItems
                                                            .Where(c => c.SearchQuery.Type == SearchQuery.MessageType.Customer && c.Relevant)
                                                            .Select(x => x.NlpAnalysis.ParsedQuery).Reverse().GetEnumerator())
            {
                while (words.Count < this._numberOfWordsIntoQ)
                {
                    if (!queryWords.Any())
                    {
                        if (!allParsedRelevantQueriesEnumerator.MoveNext())
                        {
                            break;
                        }

                        var parsedQueryWords = allParsedRelevantQueriesEnumerator.Current.Split(" ");

                        foreach (var word in parsedQueryWords)
                        {
                            queryWords.Enqueue(word);
                        }
                    }
                    else
                    {
                        words.Add(queryWords.Dequeue());
                    }
                }
            }

            return(string.Join(" ", words));
        }
        /// <inheritdoc/>
        public async Task <(string, string)> SetupReviewMeetingAsync(Meeting meeting, ConversationContext conversationContext, Resource resource, string userId)
        {
            ConversationContext meetingConversationContext = default;
            var joinMeetingLink = string.Empty;

            // If the action is invoked in a meeting group chat, read online meeting linked to chat and fetch join meeting url.
            // Note: Teams doesn't support adding application tabs to channel meetings in public ring at the time of writing.
            if (conversationContext.ConversationType == ConversationType.GroupChat && !string.IsNullOrEmpty(conversationContext.MeetingId))
            {
                meetingConversationContext = conversationContext;
                joinMeetingLink            = await this.conversationService.GetJoinMeetingUrlForChatAsync(conversationContext, userId);
            }
            else
            {
                // else Create an online meeting if the request is made from a non-meeting conversation.
                // Note: This may return a meeting instance that was created earlier (with the same external id).
                var newMeeting = await this.CreateOnlineMeetingAsync(meeting, conversationContext, resource);

                joinMeetingLink            = newMeeting.JoinUrl;
                meetingConversationContext = new ConversationContext()
                {
                    ConversationId        = newMeeting.ChatId,
                    ConversationType      = ConversationType.GroupChat,
                    IsMeetingConversation = true,
                    MeetingId             = newMeeting.Id,
                    TeamId = string.Empty,
                };
            }

            // Setup application and tab.
            var tabId = await this.SetupAppAndTabAsync(meetingConversationContext, resource);

            return(joinMeetingLink, tabId);
        }
Example #11
0
        public async Task <T> Prompt <T>(Func <
                                             IConversationSpeaker,
                                             IConversationSpeaker,
                                             T
                                             > function)
        {
            var result = default(T);
            var error  = true;

            var context      = new ConversationContext(this);
            var conversation = new BasicConversation(
                context,
                new BasicSpeaker(context),
                new BasicSpeaker(context, flags: ConversationSpeakerFlags.NPCReplacedByUser),
                (self, target) =>
            {
                result = function.Invoke(self, target);
                error  = false;
            }
                );

            await Converse(conversation);

            if (error)
            {
                throw new TaskCanceledException();
            }

            return(result);
        }
 public FieldUserSpeaker(
     ConversationContext context,
     FieldUser fieldUser
     ) : base(context)
 {
     _fieldUser = fieldUser;
 }
Example #13
0
        public override async Task Handle(RecvPacketOperations operation, IPacket packet, FieldUser user)
        {
            packet.Decode <byte>();

            var name   = packet.Decode <string>();
            var portal = user.Field.Template.Portals.Values
                         .FirstOrDefault(p => p.Name.Equals(name));

            if (portal == null)
            {
                return;
            }
            if (string.IsNullOrEmpty(portal.Script))
            {
                return;
            }

            var context      = new ConversationContext(user.Socket);
            var conversation = await user.Service.ConversationManager.Build(
                portal.Script,
                context,
                new FieldSpeaker(context, user.Field),
                new FieldUserSpeaker(context, user)
                );

            await user.Converse(conversation);
        }
        public void When_having_less_words_into_parsed_query_than_numberOfWordsIntoQ_then_return_all_words()
        {
            var context = new ConversationContext(new Guid("0f8fad5b-d9cb-469f-a165-708677289501"), DateTime.Now)
            {
                ContextItems = new List <ContextItem>
                {
                    ContextItemBuilder.Build
                    .WithSearchQuery(
                        SearchQueryBuilder.Build
                        .WithChatKey(new Guid("0f8fad5b-d9cb-469f-a165-708677289501"))
                        .WithQuery("I need help with coveo search api")
                        .WithMessageType(SearchQuery.MessageType.Customer)
                        .Instance)
                    .WithRelevant(true)
                    .WithNlpAnalysis(
                        NlpAnalysisBuilder.Build
                        .WithQuery("search api")
                        .Instance)
                    .Instance
                }
            };

            var query = this._suggestionsService.CreateQuery(context);

            query.Split(" ").Length.Should().Be(2);
        }
Example #15
0
        /// <inheritdoc/>
        public async Task <string> AddApplicationToConversationAsync(ConversationContext conversationContext)
        {
            var teamsAppInstallation = new TeamsAppInstallation
            {
                AdditionalData = new Dictionary <string, object>()
                {
                    { "*****@*****.**", $"https://graph.microsoft.com/v1.0/appCatalogs/teamsApps/{this.appSettings.CatalogAppId}" },
                },
            };

            try
            {
                var result = await this.graphServiceClient.Chats[conversationContext.ConversationId].InstalledApps
                             .Request()
                             .AddAsync(teamsAppInstallation);

                return(result?.Id);
            }
            catch (ServiceException exception)
            {
                if (exception.StatusCode == HttpStatusCode.Conflict)
                {
                    this.logger.LogInformation($"App is already installed. Inner error code: {exception.Error.Code}");
                    return(string.Empty);
                }

                throw exception;
            }
        }
        private IEnumerable <FacetQuestionResult> GetQuestionsFromDocument(ConversationContext conversationContext, IEnumerable <Document> documents)
        {
            var questionResults = this._documentFacets.GetQuestions(documents.Select(x => x.Uri));

            AssociateKnownQuestionsWithId(conversationContext, questionResults.Select(q => q.FacetQuestion).Cast <Question>().ToList());
            return(FilterOutChosenQuestions(conversationContext, questionResults));
        }
        public Suggestion GetNewSuggestion(ConversationContext conversationContext, SuggestionQuery query)
        {
            var documents = this.GetDocuments(conversationContext).ToList();

            conversationContext.LastNotFilteredDocuments            = documents;
            conversationContext.FilterDocumentsParameters.Documents = documents.Select(x => x.Uri).ToList();
            return(this.GetSuggestion(conversationContext, query));
        }
		public void DefaultConversationIsUsedWhenNoScopeIsActive()
		{
			IConversation conv = MockRepository.GenerateStub<IConversation>();
			IConversationContext cc = new ConversationContext();

			cc.SetDefaultConversation(conv);
			Assert.That(cc.CurrentConversation, Is.SameAs(conv));
		}
		public void UsefulExceptionOnCallingEndDefaultConversationContextWithoutDefaultConversation()
		{
			IConversationContext cc = new ConversationContext();
			var e = Assert.Throws<InvalidOperationException>(() => cc.UnsetDefaultConversation());

			Assert.That(e.Message, Contains.Substring("default"));
			Assert.That(e.Message, Contains.Substring("conversation"));
		}
Example #20
0
        public void When_retrieving_existing_conversation_context_then_return_the_context(string chatKey)
        {
            ConversationContext conversationContext = this._contexts[new Guid(chatKey)];

            conversationContext.SuggestedDocuments.Count.Should().Be(1);
            conversationContext.SuggestedDocuments.Should().Contain(GetDocument());
            conversationContext.ChatKey.Should().Be(chatKey);
        }
 private static void AssociateKnownQuestionsWithId(ConversationContext conversationContext, List <Question> questions)
 {
     foreach (var question in questions)
     {
         var associatedQuestion = conversationContext.Questions.SingleOrDefault(contextQuestion => contextQuestion.Text.Equals(question.Text));
         question.Id = associatedQuestion?.Id ?? question.Id;
     }
 }
Example #22
0
        public void When_retrieving_non_existing_conversation_context_then_return_new_one(string chatKey)
        {
            ConversationContext conversationContext = this._contexts[new Guid(chatKey)];

            conversationContext.SuggestedDocuments.Add(GetDocument());

            conversationContext.Should().NotBeNull();
            conversationContext.ChatKey.Should().Be(chatKey);
        }
Example #23
0
        /* Eg: balance */
        public static void EasterEggResponse(ConversationContext cContext, TokenEaserEgg p1)
        {
            ErpResultWrapper wrapper = new ErpResultWrapper();

            wrapper.IsQuestion = true;
            wrapper.QuestionText = "I'm sorry, Dave. I'm afraid I can't do that.";

            cContext.Say(wrapper, null);
        }
        public void ContextHandlingTest()
        {
            IConversationContext context = new ConversationContext();

            this.contextHandler.InvokeAsync(context).Wait();

            Assert.NotNull(context);
            this.stateManager.Verify(x => x.FetchContextAsync(context), Times.Once);
        }
 public void UpdateContextWithNewItem(ConversationContext context, NlpAnalysis nlpAnalysis, SearchQuery searchQuery, bool isRelevant)
 {
     context.ContextItems.Add(new ContextItem
     {
         NlpAnalysis = nlpAnalysis,
         SearchQuery = searchQuery,
         Relevant    = isRelevant,
     });
 }
Example #26
0
        public void ContextNoKeepHandlingTest()
        {
            IConversationContext context = new ConversationContext();

            this.contextKeeperHandler.InvokeAsync(context).Wait();

            Assert.NotNull(context);
            this.stateManager.Verify(x => x.SaveContextAsync(context), Times.Never);
        }
 private static void UpdateContextWithNewQuestions(ConversationContext context, IEnumerable <Question> questions)
 {
     context.LastSuggestedQuestions.Clear();
     foreach (var question in questions)
     {
         context.Questions.Add(question);
         context.LastSuggestedQuestions.Add(question);
     }
 }
 private static IEnumerable <Facet> GetActiveFacets(ConversationContext conversationContext)
 {
     return(conversationContext.AnsweredQuestions.OfType <FacetQuestion>().Select(a => new Facet
     {
         Id = a.Id,
         Name = a.FacetName,
         Value = a.Answer
     }).ToList());
 }
		public void CannotSetDefaultConversationTwice()
		{
			IConversation conv1 = MockRepository.GenerateStub<IConversation>();
			IConversation conv2 = MockRepository.GenerateStub<IConversation>();
			IConversationContext cc = new ConversationContext();

			cc.SetDefaultConversation(conv1);
			Assert.Throws<InvalidOperationException>(() => cc.SetDefaultConversation(conv2));
		}
        public Suggestion GetNewSuggestion(ConversationContext conversationContext, SuggestionQuery query)
        {
            var allRecommendedQuestions = new List <IEnumerable <Recommendation <Question> > >();

            if (query.OverridenRecommenderSettings != null)
            {
                this._recommenderSettings = query.OverridenRecommenderSettings;
            }

            var tasks = new Dictionary <RecommenderType, Task <IEnumerable <Recommendation <Document> > > >();

            if (this._recommenderSettings.UseLongQuerySearchRecommender)
            {
                tasks.Add(RecommenderType.LongQuerySearch, this.GetLongQuerySearchRecommendations(conversationContext));
            }

            if (this._recommenderSettings.UsePreprocessedQuerySearchRecommender)
            {
                tasks.Add(RecommenderType.PreprocessedQuerySearch, this.GetQuerySearchRecommendations(conversationContext));
            }

            if (this._recommenderSettings.UseAnalyticsSearchRecommender)
            {
                tasks.Add(RecommenderType.LastClickAnalytics, this.GetLastClickAnalyticsRecommendations(conversationContext));
            }

            if (this._recommenderSettings.UseNearestDocumentsRecommender)
            {
                var recommendations = this._recommenderSettings.UsePreprocessedQuerySearchRecommender
                    ? tasks[RecommenderType.PreprocessedQuerySearch].Result
                    : this.GetQuerySearchRecommendations(conversationContext).Result;

                tasks.Add(RecommenderType.NearestDocuments, this.GetNearestDocumentsRecommendations(conversationContext, recommendations.Select(r => r.Value)));
            }

            var allRecommendedDocuments = Task.WhenAll(tasks.Values).Result.ToList();
            var mergedDocuments         = this.MergeRecommendedDocuments(allRecommendedDocuments);

            if (mergedDocuments.Any() && this._recommenderSettings.UseFacetQuestionRecommender)
            {
                allRecommendedQuestions.Add(this.GenerateQuestions(conversationContext, mergedDocuments.Select(d => d.Value)).Take(query.MaxQuestions));
            }

            var mergedQuestions = this.MergeRecommendedQuestions(allRecommendedQuestions).Take(query.MaxQuestions);

            var suggestion = new Suggestion
            {
                ActiveFacets = conversationContext.MustHaveFacets,
                Documents    = mergedDocuments.Take(query.MaxDocuments).ToList(),
                Questions    = mergedQuestions.Select(r => r.ConvertValue(QuestionToClient.FromQuestion)).ToList()
            };

            UpdateContextWithNewSuggestions(conversationContext, suggestion.Documents.Select(r => r.Value));

            return(suggestion);
        }
		public void CanAccessRegisteredScope()
		{
			var scope = MockRepository.GenerateStub<IScope>();
			scope.Stub(s => s.IsValid).Return(true);
			scope.Stub(s => s.AssociatedConversation).Return(MockRepository.GenerateMock<IConversation>());
			var cc = new ConversationContext();

			cc.RegisterScope(scope);
			Assert.That(cc.CurrentScope, Is.SameAs(scope));
		}
Example #32
0
        public void SetUp()
        {
            this._indexSearchMock    = new Mock <IIndexSearch>();
            this._nlpCallMock        = new Mock <INlpCall>();
            this._documentFacetsMock = new Mock <IDocumentFacets>();
            this._filterDocuments    = new Mock <IFilterDocuments>();

            this._suggestionsService  = new SuggestionsService(this._indexSearchMock.Object, this._nlpCallMock.Object, this._documentFacetsMock.Object, this._filterDocuments.Object, this.GetIrrelevantIntents());
            this._conversationContext = new ConversationContext(new Guid("a21d07d5-fd5a-42ab-ac2c-2ef6101e58d9"), DateTime.Now);
        }
Example #33
0
        public void When_life_span_expired_then_context_is_deleted(string chatKey)
        {
            ConversationContext conversationContext = this._contexts[new Guid(chatKey)];

            conversationContext.StartDate = conversationContext.StartDate.Subtract(new TimeSpan(2, 0, 0, 0));

            IEnumerable <ConversationContext> removedContext = this._contexts.RemoveOldContext();

            removedContext.Should().OnlyContain(x => x.Equals(conversationContext));
        }
Example #34
0
        public void When_adding_duplicate_suggestion_only_one_is_added(string chatKey)
        {
            ConversationContext conversationContext = this._contexts[new Guid(chatKey)];
            Document            query1 = GetDocument();
            Document            query2 = GetDocument();

            conversationContext.SuggestedDocuments.Add(query1);
            conversationContext.SuggestedDocuments.Add(query2);
            conversationContext.SuggestedDocuments.Should().HaveCount(1);
        }
        private static IEnumerable <FacetQuestionResult> FilterOutChosenQuestions(
            ConversationContext conversationContext,
            IEnumerable <FacetQuestionResult> questions)
        {
            var questionsText = conversationContext.
                                Questions.Where(question => question.Status != QuestionStatus.None && question.Status != QuestionStatus.Clicked)
                                .Select(x => x.Text);

            return(questions.Where(x => !questionsText.Any(y => y.Contains(x.FacetQuestion.Text))));
        }
		public void CanSetDefaultConversationAfterAPreviousOneHasEnded()
		{
			IConversation conv1 = MockRepository.GenerateStub<IConversation>();
			IConversation conv2 = MockRepository.GenerateStub<IConversation>();
			IConversationContext cc = new ConversationContext();

			cc.SetDefaultConversation(conv1);
			cc.UnsetDefaultConversation();

			cc.SetDefaultConversation(conv2);
		}
		public void TwiceEndDefaultConversationThrows()
		{
			IConversation conv = MockRepository.GenerateStub<IConversation>();
			IConversationContext cc = new ConversationContext();

			cc.SetDefaultConversation(conv);

			cc.UnsetDefaultConversation();

			Assert.Throws<InvalidOperationException>(() => cc.UnsetDefaultConversation());
		}
		public void ThrowsOnRegisteringInvalidScope()
		{
			var scope = MockRepository.GenerateStub<IScope>();
			var cc = new ConversationContext();

			scope.Stub(s => s.IsValid).Return(false);
			scope.Stub(s => s.AssociatedConversation).Return(MockRepository.GenerateMock<IConversation>());

			var e = Assert.Throws<InvalidOperationException>(() => cc.RegisterScope(scope));
			Assert.That(e.Message, Contains.Substring("invalid"));
			Assert.That(e.Message, Contains.Substring("scope"));
			Assert.That(e.Message, Contains.Substring("internal"));
			Assert.That(e.Message, Contains.Substring("dispose"));
			Assert.That(e.Message, Contains.Substring("conversation"));
		}
		public async Task<IgResponse<AuthenticationResponse>> SecureAuthenticate(AuthenticationRequest ar, string apiKey)
        {
            _conversationContext = new ConversationContext(null, null, apiKey);           
            var encryptedPassword = await SecurePassword(ar.password);

            if (encryptedPassword == ar.password)
            {               
               ar.encryptedPassword = false;
            }
            else               
            {
                ar.encryptedPassword = true;                
            }
            ar.password = encryptedPassword;
            return await authenticate(ar);
        }	
		public void ThrowsOnAccessingInvalidScope()
		{
			var scope = MockRepository.GenerateMock<IScope>();
			var valid = true;
			scope.Stub(s => s.IsValid).Do((Func<bool>)(() => valid));
			scope.Stub(s => s.AssociatedConversation).Return(MockRepository.GenerateMock<IConversation>());

			var cc = new ConversationContext();

			cc.RegisterScope(scope);
			valid = false;

			IScope x;
			var e = Assert.Throws<InvalidOperationException>(() => x = cc.CurrentScope);
			Assert.That(e.Message, Contains.Substring("invalid"));
			Assert.That(e.Message, Contains.Substring("scope"));
			Assert.That(e.Message, Contains.Substring("internal"));
			Assert.That(e.Message, Contains.Substring("dispose"));
			Assert.That(e.Message, Contains.Substring("conversation"));
		}
Example #41
0
 /* Eg: give me phone number XYZ */
 public static void PhoneNoResponse(ConversationContext cContext, TokenRequest p1, TokenQueryPhoneNo p2, TokenQuotedPhrase p3)
 {
     cContext.Say(CreateResponse(p3.Value.ToString()), null);
 }
Example #42
0
 /* Eg: address for XYZ */
 public static void AddressResponse(ConversationContext cContext, TokenQueryAddress p1, TokenFor p2, TokenQuotedPhrase p3)
 {
     cContext.Say(CreateResponse(p3.Value.ToString()), null);
 }
Example #43
0
 /* Eg: give me address for customer */
 public static void AddressResponse(ConversationContext cContext, TokenRequest p1, TokenQueryAddress p2, TokenFor p3, TokenCustomer p4)
 {
     // Ask for which customer
     cContext.AskQuestion(CreateResponse(null));
 }
Example #44
0
 /* Eg: address */
 public static void AddressResponse(ConversationContext cContext, TokenQueryAddress p1)
 {
     // Ask for which customer
     cContext.AskQuestion(CreateResponse(null));
 }
Example #45
0
 /* Eg: give me customeraddress for xyz*/
 public static void AddressResponse(ConversationContext cContext, TokenRequest p1, TokenCustomer p2, TokenQueryAddress p3, TokenFor p4, TokenQuotedPhrase p5)
 {
     cContext.Say(CreateResponse(p5.Value.ToString()), null);
 }
Example #46
0
 /* Eg: give me the top sales customers */
 public static void TopResponse(ConversationContext cContext, TokenRequest p1, TokenQueryTop p2, TokenSales p3, TokenCustomers p4)
 {
     cContext.Say(CreateResponse(p3), null);
 }
Example #47
0
 /* Eg: give me the top overdue customers */
 public static void TopResponse(ConversationContext cContext, TokenWhoIs p1, TokenQueryTop p2, TokenOverdue p3, TokenCustomers p4)
 {
     cContext.Say(CreateResponse(p3), null);
 }
		public void ScopesCanBeNested()
		{
			var outerConv = MockRepository.GenerateMock<IConversation>();
			var innerConv = MockRepository.GenerateMock<IConversation>();

			var outerScope = MockRepository.GenerateMock<IScope>();
			var innerScope = MockRepository.GenerateMock<IScope>();
			innerScope.Stub(s => s.AssociatedConversation).Return(innerConv);
			outerScope.Stub(s => s.AssociatedConversation).Return(outerConv);
			innerScope.Stub(s => s.IsValid).Return(true);
			outerScope.Stub(s => s.IsValid).Return(true);

			var cc = new ConversationContext();

			cc.RegisterScope(outerScope);
			Assert.That(cc.CurrentScope, Is.SameAs(outerScope));
			Assert.That(cc.CurrentConversation, Is.SameAs(outerConv));
			cc.RegisterScope(innerScope);
			Assert.That(cc.CurrentScope, Is.SameAs(innerScope));
			Assert.That(cc.CurrentConversation, Is.SameAs(innerConv));
			cc.ReleaseScope(innerScope);
			Assert.That(cc.CurrentScope, Is.SameAs(outerScope));
			Assert.That(cc.CurrentConversation, Is.SameAs(outerConv));
			cc.ReleaseScope(outerScope);
			Assert.That(cc.CurrentScope, Is.Null);
			Assert.That(cc.CurrentConversation, Is.Null);
		}
		public async Task<IgResponse<AuthenticationResponse>> Authenticate(AuthenticationRequest ar, string apiKey)
        {
            _conversationContext = new ConversationContext(null, null, apiKey);                    
            return await authenticate(ar);
        }
Example #50
0
 /* Eg: customer phone number for xyz*/
 public static void PhoneNoResponse(ConversationContext cContext, TokenCustomer p1, TokenQueryPhoneNo p2, TokenFor p3, TokenQuotedPhrase p4)
 {
     cContext.Say(CreateResponse(p4.Value.ToString()), null);
 }
Example #51
0
 /* Eg: balance XYZ */
 public static void BalanceResponse(ConversationContext cContext, TokenQueryBalance p1, TokenQuotedPhrase p2)
 {
     cContext.Say(CreateResponse(p2.Value.ToString()), null);
 }
Example #52
0
 /* Eg: give me customer phone number */
 public static void PhoneNoResponse(ConversationContext cContext, TokenRequest p1, TokenCustomer p2, TokenQueryPhoneNo p3)
 {
     // Ask for which customer
     cContext.AskQuestion(CreateResponse(null));
 }
		public void ScopesMustBeRegisteredBeforeRelease()
		{
			var outerConv = MockRepository.GenerateMock<IConversation>();
			var innerConv = MockRepository.GenerateMock<IConversation>();

			var outerScope = MockRepository.GenerateMock<IScope>();
			var innerScope = MockRepository.GenerateMock<IScope>();
			innerScope.Stub(s => s.AssociatedConversation).Return(innerConv);
			outerScope.Stub(s => s.AssociatedConversation).Return(outerConv);
			innerScope.Stub(s => s.IsValid).Return(true);
			outerScope.Stub(s => s.IsValid).Return(true);

			var cc = new ConversationContext();

			cc.RegisterScope(outerScope);
			var e = Assert.Throws<InvalidOperationException>(() => cc.ReleaseScope(innerScope));
			Assert.That(e.Message, Contains.Substring("release"));
			Assert.That(e.Message, Contains.Substring("not"));
			Assert.That(e.Message, Contains.Substring("register"));
		}
		public void DefaultConversationMustNotBeNull()
		{
			IConversationContext cc = new ConversationContext();
			Assert.Throws<ArgumentNullException>(() => cc.SetDefaultConversation(null));
		}
		public void WhenAScopeIsRegisteredItIsUsedForCurrentConversation()
		{
			var defConv = MockRepository.GenerateMock<IConversation>();
			var conv = MockRepository.GenerateMock<IConversation>();

			var scope = MockRepository.GenerateMock<IScope>();
			scope.Stub(s => s.AssociatedConversation).Return(conv);
			scope.Stub(s => s.IsValid).Return(true);

			var cc = new ConversationContext();
			cc.SetDefaultConversation(defConv);

			Assert.That(cc.CurrentConversation, Is.SameAs(defConv));
			cc.RegisterScope(scope);
			Assert.That(cc.CurrentScope, Is.SameAs(scope));
			Assert.That(cc.CurrentConversation, Is.SameAs(conv));
			cc.ReleaseScope(scope);
			Assert.That(cc.CurrentConversation, Is.SameAs(defConv));
		}
Example #56
0
 /* Eg: what's my cash flow look like today */
 public static void CashFlowResponse(ConversationContext cContext, TokenRequest p1, TokenCashFlow p2, TokenLook p3, TokenQuotedPhrase p4)
 {
     cContext.Say(CreateResponse(p2.Value.ToString()), null);
 }
Example #57
0
 /* Eg: cash flow */
 public static void CashFlowResponse(ConversationContext cContext, TokenCashFlow p1)
 {
     cContext.Say(CreateResponse(p1.Value.ToString()), null);
 }
		public void ThrowsOnReleasingNull()
		{
			var cc = new ConversationContext();
			var e = Assert.Throws<ArgumentNullException>(() => cc.ReleaseScope(null));
			Assert.That(e.ParamName, Is.EqualTo("scope"));
		}
		public void ScopesCannotBeRegisteredTwice()
		{
			var scope = MockRepository.GenerateStub<IScope>();
			var cc = new ConversationContext();

			scope.Stub(s => s.IsValid).Return(true);
			scope.Stub(s => s.AssociatedConversation).Return(MockRepository.GenerateMock<IConversation>());

			cc.RegisterScope(scope);
			var e = Assert.Throws<InvalidOperationException>(() => cc.RegisterScope(scope));
			Assert.That(e.Message, Contains.Substring("scope"));
			Assert.That(e.Message, Contains.Substring("register"));
			Assert.That(e.Message, Contains.Substring("twice"));
		}
		public void ThrowsOnRegisteringScopeWithoutConversation()
		{
			var scope = MockRepository.GenerateStub<IScope>();
			var cc = new ConversationContext();

			scope.Stub(s => s.IsValid).Return(true);

			var e = Assert.Throws<InvalidOperationException>(() => cc.RegisterScope(scope));
			Assert.That(e.Message, Contains.Substring("conversation"));
			Assert.That(e.Message, Contains.Substring("null"));
			Assert.That(e.Message, Contains.Substring("internal"));
		}