inital

FasdDesktopUi/Basics/UiActions/UiProcessSearchResultAction.cs

@@ -0,0 +1,176 @@
+using C4IT.FASD.Base;
+using C4IT.Logging;
+using C4IT.MultiLanguage;
+using FasdDesktopUi.Basics.Enums;
+using FasdDesktopUi.Basics.Services.RelationService;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Input;
+using static C4IT.Logging.cLogManager;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    public class cUiProcessSearchResultAction : cUiActionBase
+    {
+        private readonly ISearchUiProvider _searchUiProvider;
+        private readonly List<cFasdApiSearchResultEntry> _searchResults;
+
+        private readonly List<cF4sdApiSearchResultRelation> _loadedRelations = new List<cF4sdApiSearchResultRelation>();
+        private readonly TaskCompletionSource<bool> _isSearchUnambigous = new TaskCompletionSource<bool>();
+
+        public cF4sdApiSearchResultRelation PreSelectedSearchRelation { get; set; } = null;
+
+        public cUiProcessSearchResultAction(string name, ISearchUiProvider searchUiProvider, List<cFasdApiSearchResultEntry> searchResults)
+        {
+            Name = name;
+            _searchUiProvider = searchUiProvider;
+            _searchResults = searchResults;
+
+            _searchUiProvider.SearchService.RelationsFound += HandleRelationsFound;
+        }
+
+        ~cUiProcessSearchResultAction()
+        {
+            _searchUiProvider.SearchService.RelationsFound -= HandleRelationsFound;
+        }
+
+        /// <returns>If the search is unfinished.
+        /// False: search is finished.
+        /// True: search is ongoing.</returns>
+        public override async Task<bool> RunUiActionAsync(object sender, UIElement uiLocation, bool isDetailedLayout, cSupportCaseDataProvider dataProvider)
+        {
+            var CM = MethodBase.GetCurrentMethod();
+            LogMethodBegin(CM);
+            try
+            {
+                if (dataProvider != null)
+                {
+                    Debug.Assert(true, "At this moment, we want to create a new support call, so we must not have a dataProvider");
+                    LogEntry("At this moment, we want to create a new support call, so we must not have a dataProvider", LogLevels.Error);
+                    return false;
+                }
+
+                return await ProcessSearchResultDefaultAsync(CancellationToken.None);
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+            finally
+            {
+                LogMethodEnd(CM);
+            }
+
+            return false;
+        }
+
+        /// <returns>If the search is unfinished. 
+        /// False: search is finished.
+        /// True: search is ongoing.</returns>
+        private async Task<bool> ProcessSearchResultDefaultAsync(CancellationToken token)
+        {
+            try
+            {
+                if (_searchResults is null || _searchResults.Count <= 0)
+                    return false;
+                _searchUiProvider.ShowLoadingTextItem(cMultiLanguageSupport.GetItem("Searchbar.Loading.Relations"));
+
+                cF4sdStagedSearchResultRelationTaskId gatherRelationTask = await _searchUiProvider.SearchService.LoadRelationsAsync(_searchResults, token);
+
+                HashSet<enumFasdInformationClass> orderedPendingInfoClasses
+                    = GetInformationClassOrderedByPriority(gatherRelationTask.PendingInformationClasses, cF4sdIdentityEntry.GetFromSearchResult(_searchResults.FirstOrDefault()?.Type ?? enumF4sdSearchResultClass.Unknown));
+                _searchUiProvider.SetPendingInformationClasses(orderedPendingInfoClasses);
+
+                Mouse.OverrideCursor = null;
+
+                if (MatchPreselectedSearchRelation(_loadedRelations))
+                    return await ProcessSearchResultRelationAsync(_searchResults.First().Name, _loadedRelations, PreSelectedSearchRelation);
+
+                if (await _isSearchUnambigous.Task)
+                    return await ProcessSearchResultRelationAsync(_searchResults.First().Name, _loadedRelations, _loadedRelations.FirstOrDefault());
+
+                return true;
+            }
+            catch (Exception ex)
+            {
+                LogException(ex);
+            }
+
+            return false;
+
+            bool MatchPreselectedSearchRelation(IEnumerable<cF4sdApiSearchResultRelation> relations)
+            {
+                if (PreSelectedSearchRelation is null || relations is null)
+                    return false;
+                return relations.Any(entry => entry.Type == PreSelectedSearchRelation.Type && entry.id == PreSelectedSearchRelation.id);
+            }
+        }
+
+        private async Task<bool> ProcessSearchResultRelationAsync(string name, List<cF4sdApiSearchResultRelation> caseRelations, cF4sdApiSearchResultRelation selectedRelation)
+        {
+            var relationSearchResult = new cSearchHistorySearchResultEntry(_searchResults.FirstOrDefault().DisplayName, _searchResults.FirstOrDefault().DisplayName, _searchResults, caseRelations, _searchUiProvider);
+            string displayName = selectedRelation != null ? $"{name} → {selectedRelation.Name}" : name;
+
+            cUiProcessSearchRelationAction action
+                = new cUiProcessSearchRelationAction(displayName, _searchResults, caseRelations, caseRelations.FirstOrDefault(), _searchUiProvider, relationSearchResult)
+                {
+                    DisplayType = enumActionDisplayType.enabled,
+                };
+
+            return await action.RunUiActionAsync(this, null, false, null);
+        }
+
+        private HashSet<enumFasdInformationClass> GetInformationClassOrderedByPriority(HashSet<enumFasdInformationClass> informationClasses, enumFasdInformationClass? excludedInformationClass = null)
+        {
+            try
+            {
+                var informationClassPrio = cFasdCockpitConfig.Instance.Global.InformationClassSearchPriority;
+
+                if (excludedInformationClass.HasValue)
+                    informationClasses.Remove(excludedInformationClass.Value);
+
+                if (informationClassPrio is null || informationClassPrio.Count == 0)
+                    return informationClasses;
+
+                return informationClasses
+                    .OrderBy(infoClass => informationClassPrio.Contains(infoClass) ? informationClassPrio.IndexOf(infoClass) : int.MaxValue)
+                    .ToHashSet();
+            }
+            catch (Exception ex)
+            {
+                LogException(ex);
+            }
+
+            return informationClasses;
+        }
+
+        private void HandleRelationsFound(object sender, StagedSearchResultRelationsEventArgs e)
+        {
+            try
+            {
+                _loadedRelations.AddRange(e.StagedResultRelations.Relations);
+
+                if (!e.StagedResultRelations.IsComplete)
+                    return;
+
+                bool isSearchResultUnambigous = _loadedRelations.Count <= 1;
+
+                if (_loadedRelations.Count == 0)
+                    _loadedRelations.Add(new cF4sdApiSearchResultRelation(_searchResults.FirstOrDefault()));
+
+                _isSearchUnambigous.TrySetResult(isSearchResultUnambigous);
+            }
+            catch (Exception ex)
+            {
+                LogException(ex);
+            }
+        }
+    }
+
+}