public async Task RecordsFeedback()
            {
                var model = new SearchSideBySideViewModel
                {
                    SearchTerm          = " json ",
                    OldHits             = 23,
                    NewHits             = 42,
                    BetterSide          = " new ",
                    MostRelevantPackage = " NuGet.Core ",
                    ExpectedPackages    = " NuGet.Packaging,  NuGet.Versioning ",
                    Comments            = " comments ",
                    EmailAddress        = " [email protected] ",
                };
                var searchUrl = "https://localhost/experiments/search-sxs?q=json";

                await Target.RecordFeedbackAsync(model, searchUrl);

                TelemetryService.Verify(
                    x => x.TrackSearchSideBySideFeedback(
                        "json",
                        23,
                        42,
                        "new",
                        "NuGet.Core",
                        "NuGet.Packaging,  NuGet.Versioning",
                        true,
                        true),
                    Times.Once);
                MessageService.Verify(
                    x => x.SendMessageAsync(It.IsAny <SearchSideBySideMessage>(), false, false),
                    Times.Once);
            }
Ejemplo n.º 2
0
        public async Task RecordFeedbackAsync(SearchSideBySideViewModel viewModel, string searchUrl)
        {
            _telemetryService.TrackSearchSideBySideFeedback(
                Trim(viewModel.SearchTerm),
                viewModel.OldHits,
                viewModel.NewHits,
                Trim(viewModel.BetterSide),
                Trim(viewModel.MostRelevantPackage),
                Trim(viewModel.ExpectedPackages),
                !string.IsNullOrWhiteSpace(viewModel.Comments),
                !string.IsNullOrWhiteSpace(viewModel.EmailAddress));

            await _messageService.SendMessageAsync(
                new SearchSideBySideMessage(_messageServiceConfiguration, viewModel, searchUrl));
        }
Ejemplo n.º 3
0
        public async Task <SearchSideBySideViewModel> SearchAsync(string searchTerm, User currentUser)
        {
            SearchSideBySideViewModel viewModel;

            if (!string.IsNullOrWhiteSpace(searchTerm))
            {
                searchTerm = searchTerm.Trim();

                var oldTask = SearchAsync(_oldSearchService, searchTerm);
                var newTask = SearchAsync(_newSearchService, searchTerm);

                await Task.WhenAll(oldTask, newTask);

                var oldResults = await oldTask;
                var newResults = await newTask;

                viewModel = new SearchSideBySideViewModel
                {
                    SearchTerm = searchTerm,
                    OldSuccess = SearchResults.IsSuccessful(oldResults),
                    OldHits    = oldResults.Hits,
                    OldItems   = oldResults.Data.Select(x => new ListPackageItemViewModel(x, currentUser)).ToList(),
                    NewSuccess = SearchResults.IsSuccessful(newResults),
                    NewHits    = newResults.Hits,
                    NewItems   = newResults.Data.Select(x => new ListPackageItemViewModel(x, currentUser)).ToList(),
                };

                _telemetryService.TrackSearchSideBySide(
                    viewModel.SearchTerm,
                    viewModel.OldSuccess,
                    viewModel.OldHits,
                    viewModel.NewSuccess,
                    viewModel.NewHits);
            }
            else
            {
                viewModel = new SearchSideBySideViewModel();
            }

            viewModel.EmailAddress = currentUser?.EmailAddress;

            return(viewModel);
        }