inital

2025-11-11 11:03:42 +01:00
commit dc3e8a2e4c
582 changed files with 191465 additions and 0 deletions
--- a/FasdDesktopUi/Basics/UiActions/ChangeHealthCardAction.cs
+++ b/FasdDesktopUi/Basics/UiActions/ChangeHealthCardAction.cs
@@ -0,0 +1,72 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+using System.Security.Cryptography.X509Certificates;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Input;
+
+using C4IT.FASD.Base;
+using C4IT.FASD.Cockpit.Communication;
+using C4IT.Logging;
+using C4IT.MultiLanguage;
+
+using FasdDesktopUi.Basics.Models;
+
+using FasdDesktopUi.Basics.UserControls;
+using FasdDesktopUi.Pages.DetailsPage;
+using FasdDesktopUi.Pages.DetailsPage.UserControls;
+
+using static C4IT.Logging.cLogManager;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    public class cChangeHealthCardAction : cUiActionBase
+    {
+        public cF4sdApiSearchResultRelation ResultRelation { get; private set; } = null;
+
+        public cChangeHealthCardAction(cF4sdApiSearchResultRelation resultRelation)
+        {
+            ResultRelation = resultRelation;
+        }
+
+        public override async Task<bool> RunUiActionAsync(object sender, UIElement UiLocation, bool isDetailedLayout, cSupportCaseDataProvider dataProvider)
+        {
+
+            var CM = MethodBase.GetCurrentMethod();
+            LogMethodBegin(CM);
+            try
+            {
+                if (dataProvider == null)
+                    return false;
+                if (ResultRelation == null)
+                    return false;
+                if (!(UiLocation is DetailsPageView detailsPage))
+                    return false;
+
+                Mouse.OverrideCursor = Cursors.Wait;
+
+                detailsPage.NavigationHeadingUc.ResetSelectors();
+
+                await dataProvider.ExchangeCaseIdentitiesAsync(ResultRelation);
+
+                return true;
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+            finally
+            {
+                Mouse.OverrideCursor = null;
+                LogMethodEnd(CM);
+            }
+
+            return false;
+        }
+
+    }
+}
--- a/FasdDesktopUi/Basics/UiActions/CopyQuickActionProtocolAction.cs
+++ b/FasdDesktopUi/Basics/UiActions/CopyQuickActionProtocolAction.cs
@@ -0,0 +1,49 @@
+using C4IT.FASD.Base;
+using C4IT.Logging;
+using C4IT.MultiLanguage;
+using F4SD_AdaptableIcon.Enums;
+using FasdDesktopUi.Basics.Services.ProtocollService;
+using FasdDesktopUi.Basics.UserControls;
+using FasdDesktopUi.Basics.UserControls.AdaptableIcon;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Media;
+using static C4IT.Logging.cLogManager;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    public class cCopyQuickActionProtocolAction : cUiActionBase
+    {
+        public override async Task<bool> RunUiActionAsync(object sender, UIElement UiLocation, bool isDetailedLayout, cSupportCaseDataProvider dataProvider)
+        {
+            try
+            {
+                if (dataProvider is null)
+                    return false;
+
+                var protocolItems = F4SDProtocoll.Instance.GetAllAsDataObject(false); // dataProvider.QuickActionProtocollHelper.GetFullProtocollQuickActionResult();
+
+                if (protocolItems is null || string.IsNullOrWhiteSpace(protocolItems.GetText()))
+                    protocolItems.SetText(cMultiLanguageSupport.GetItem("QuickAction.Copy.Protocol.Empty"));
+
+                System.Windows.Forms.Clipboard.SetDataObject(protocolItems, true);
+
+                if (sender is CustomMenuItem senderElement)
+                    await cUtility.ChangeIconToCheckAsync(senderElement.MenuItemIcon);
+
+                return true;
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+
+            return false;
+        }
+    }
+}
--- a/FasdDesktopUi/Basics/UiActions/ShowCustomDialog.cs
+++ b/FasdDesktopUi/Basics/UiActions/ShowCustomDialog.cs
@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using System.Web.Caching;
+using System.Windows;
+using System.Windows.Controls;
+using FasdDesktopUi.Basics.Helper;
+using FasdDesktopUi.Basics.Models;
+using FasdDesktopUi.Basics.UserControls;
+using FasdDesktopUi.Config;
+using FasdDesktopUi.Pages.DetailsPage;
+using FasdDesktopUi.Pages.DetailsPage.ViewModels;
+using static C4IT.Logging.cLogManager;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    public class cShowCustomDialog : cUiActionBase
+    {
+        private string dialogName;
+
+        public cShowCustomDialog(string dialogName)
+        {
+            this.dialogName = dialogName;
+        }
+
+        private List<cContainerData> GetDialogDataByName(string name, cSupportCaseDataProvider dataProvider)
+        {
+            List<cContainerData> output = null;
+
+            try
+            {
+                if (string.IsNullOrEmpty(name) || dataProvider is null)
+                    return null;
+
+                if (cF4SDCustomDialogConfig.Instance?.CustomDialogContainers is null)
+                    return null;
+
+                if (cF4SDCustomDialogConfig.Instance.CustomDialogContainers.TryGetValue(name, out var containerConfig))
+                    output = dataProvider.HealthCardDataHelper.GetContainerDataFromConfig(containerConfig);
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+
+            return output;
+        }
+
+        public override async Task<bool> RunUiActionAsync(object sender, UIElement UiLocation, bool isDetailedLayout, cSupportCaseDataProvider dataProvider)
+        {
+            try
+            {
+                var dialogData = GetDialogDataByName(dialogName, dataProvider);
+
+                if (dialogData is null)
+                    return false;
+
+                var dialogElement = new CustomDialog() { ContainerData = dialogData.FirstOrDefault(), HasYesNoButtons = true, HasYesNoText = true };
+
+                if (UiLocation is Decorator locationElement)
+                {
+                    dialogElement.ParentElement = locationElement;
+                    locationElement.Child = dialogElement;
+                }
+
+                if (cSupportCaseDataProvider.detailsPage?.QuickActionDecorator?.Child is null)
+                    return false;
+
+                cSupportCaseDataProvider.detailsPage.QuickActionDecorator.Child = dialogElement;
+                cSupportCaseDataProvider.detailsPage.QuickActionDecorator.Visibility = Visibility.Visible;
+
+                await Task.CompletedTask;
+
+                return true;
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+
+            return false;
+        }
+    }
+}
--- a/FasdDesktopUi/Basics/UiActions/ShowDetailedDataAction.cs
+++ b/FasdDesktopUi/Basics/UiActions/ShowDetailedDataAction.cs
@@ -0,0 +1,538 @@
+using C4IT.F4SD.DisplayFormatting;
+using C4IT.FASD.Base;
+using C4IT.FASD.Cockpit.Communication;
+using C4IT.Logging;
+using C4IT.MultiLanguage;
+using FasdDesktopUi.Basics.Models;
+using FasdDesktopUi.Basics.UserControls;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+
+using static C4IT.FASD.Base.cF4SDHealthCardRawData;
+using static C4IT.Logging.cLogManager;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    public class cShowDetailedDataAction : cUiActionBase
+    {
+        private static readonly Dictionary<cF4sdIdentityList, Dictionary<string, cF4SDHealthCardRawData.cHealthCardDetailsTable>> CachedDetails = new Dictionary<cF4sdIdentityList, Dictionary<string, cF4SDHealthCardRawData.cHealthCardDetailsTable>>();
+
+        private cSupportCaseDataProvider DataProvider;
+
+        private readonly cHealthCardStateBase StateDefinition;
+
+        private int DayIndex { get; set; }
+
+        private string DetailsTitle { get; set; }
+
+        private string Recommendation { get; set; }
+
+        private cHealthCardDetailsTable ValuedDetailsData = null;
+
+        public cShowDetailedDataAction(cHealthCardStateBase StateDefinition, int DayIndex = 0, cHealthCardDetailsTable ValuedDetailsData = null)
+        {
+            this.StateDefinition = StateDefinition;
+            this.DayIndex = DayIndex;
+            this.DetailsTitle = StateDefinition.Names.GetValue();
+            this.Recommendation = StateDefinition.Descriptions.GetValue();
+            if (this.Recommendation == String.Empty)
+                this.Recommendation = null;
+            this.ValuedDetailsData = ValuedDetailsData;
+        }
+
+        public override async Task<bool> RunUiActionAsync(object sender, UIElement UiLocation, bool isDetailedLayout, cSupportCaseDataProvider dataProvider)
+        {
+            try
+            {
+                if (!(UiLocation is Decorator decorator))
+                    return false;
+
+                DataProvider = dataProvider;
+                DataProvider.HealthCardDataHelper.DataRefreshed += (s, e) => CachedDetails.Clear();
+
+                Mouse.OverrideCursor = Cursors.Wait;
+
+                if (StateDefinition.Details is cHealthCardDetailsValued)
+                {
+                    if (ValuedDetailsData == null)
+                        return false;
+                }
+                else
+                {
+                    if (!await LoadDetailsDataAsync())
+                        return false;
+                }
+
+                cDetailedDataModel detailedData = null;
+                cDetailedChartModel detailedChartData = null;
+                cChartModel chartData = null;
+                if (StateDefinition.Details is cHealthCardDetailsValued)
+                {
+                    detailedData = GetValuedDataModel();
+                }
+                else
+                {
+                    detailedData = GetDetailedData();
+                    detailedChartData = GetDetailedChartData();
+                    chartData = GetChartData();
+                }
+                cRecommendationDataModel recommendationDataModel = Recommendation != null ? new cRecommendationDataModel() { Category = DetailsTitle, Recommendation = Recommendation } : null;
+
+                if (decorator.Child is DataCanvas existingDataCanvas)
+                {
+                    var tempDataCanvasData = new cDataCanvasDataModel() { QuickActionStatusMonitorData = null, DetailedData = detailedData, DetailedChartData = detailedChartData, ChartData = chartData, RecommendationData = recommendationDataModel };
+                    if (!(StateDefinition.Details is cHealthCardDetailsValued))
+                    {
+                        tempDataCanvasData.GetDetailedDataAsync = GetRefreshedDetailedDataAsync;
+                        tempDataCanvasData.GetChartDataAsync = GetRefreshedChartDataAsync;
+                        tempDataCanvasData.GetDatailedChartDataAsync = GetRefreshedDetailsChartDataAsync;
+                    }
+
+                    existingDataCanvas.DataCanvasData = tempDataCanvasData;
+                    existingDataCanvas.IsDetailedLayout = isDetailedLayout;
+                    existingDataCanvas.DataProvider = DataProvider;
+                    existingDataCanvas.Visibility = Visibility.Visible;
+                }
+                else
+                {
+                    DataCanvas dataCanvas = new DataCanvas() { DataCanvasData = new cDataCanvasDataModel() { DetailedData = detailedData, DetailedChartData = detailedChartData, ChartData = chartData, RecommendationData = recommendationDataModel }, IsDetailedLayout = isDetailedLayout, DataProvider = DataProvider };
+                    if (!(StateDefinition.Details is cHealthCardDetailsValued))
+                    {
+                        dataCanvas.DataCanvasData.GetDetailedDataAsync = GetRefreshedDetailedDataAsync;
+                        dataCanvas.DataCanvasData.GetChartDataAsync = GetRefreshedChartDataAsync;
+                        dataCanvas.DataCanvasData.GetDatailedChartDataAsync = GetRefreshedDetailsChartDataAsync;
+                    }
+
+                    decorator.Child = dataCanvas;
+                }
+
+                decorator.Visibility = Visibility.Visible;
+
+                return true;
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+            finally
+            {
+                Mouse.OverrideCursor = null;
+            }
+            return false;
+        }
+
+        private async Task<bool> LoadDetailsDataAsync()
+        {
+            try
+            {
+                if (StateDefinition == null || StateDefinition.Details == null)
+                    return false;
+
+                if (!(StateDefinition.Details is cHealthCardDetails _details) || _details.Table == null)
+                    return false;
+
+                if (CachedDetails.TryGetValue(DataProvider.Identities, out var cachedDetailsForIdentities))
+                {
+                    if (cachedDetailsForIdentities.TryGetValue(_details.Table, out _))
+                        return true;
+                }
+                else
+                    cachedDetailsForIdentities = new Dictionary<string, cF4SDHealthCardRawData.cHealthCardDetailsTable>();
+
+                cF4sdHealthCardRawDataRequest requestData = new cF4sdHealthCardRawDataRequest()
+                {
+                    Identities = DataProvider.Identities,
+                    MaxAge = cF4SDCockpitXmlConfig.Instance.HealthCardConfig.SearchResultAge,
+                    Tables = StateDefinition.GetRequiredTables()
+                };
+
+                var detailsData = await cFasdCockpitCommunicationBase.Instance.GetDetailsData(requestData);
+
+                if (detailsData.Any(data => data.Name == _details.Table) || detailsData.Any(data => data.Name == StateDefinition.DetailedChartDetails?.ValueTable) || detailsData.Any(data => data.Name == StateDefinition.ChartDetails?.ValueTable))
+                {
+                    if (StateDefinition.Details != null && detailsData.Any(data => data.Name == _details.Table))
+                    {
+                        if (!cachedDetailsForIdentities.ContainsKey(_details.Table))
+                            cachedDetailsForIdentities.Add(_details.Table, detailsData.First(data => data.Name == _details.Table));
+                        if (!CachedDetails.ContainsKey(DataProvider.Identities))
+                            CachedDetails.Add(DataProvider.Identities, cachedDetailsForIdentities);
+                    }
+                    if (StateDefinition.DetailedChartDetails != null && detailsData.Any(data => data.Name == StateDefinition.DetailedChartDetails.ValueTable))
+                    {
+                        if (!cachedDetailsForIdentities.ContainsKey(StateDefinition.DetailedChartDetails.ValueTable))
+                            cachedDetailsForIdentities.Add(StateDefinition.DetailedChartDetails.ValueTable, detailsData.First(data => data.Name == StateDefinition.DetailedChartDetails.ValueTable));
+                        if (!CachedDetails.ContainsKey(DataProvider.Identities))
+                            CachedDetails.Add(DataProvider.Identities, cachedDetailsForIdentities);
+                    }
+                    if (StateDefinition.ChartDetails != null && detailsData.Any(data => data.Name == StateDefinition.ChartDetails.ValueTable))
+                    {
+                        if (!cachedDetailsForIdentities.ContainsKey(StateDefinition.ChartDetails.ValueTable))
+                            cachedDetailsForIdentities.Add(StateDefinition.ChartDetails.ValueTable, detailsData.First(data => data.Name == StateDefinition.ChartDetails.ValueTable));
+                        if (!CachedDetails.ContainsKey(DataProvider.Identities))
+                            CachedDetails.Add(DataProvider.Identities, cachedDetailsForIdentities);
+                    }
+                }
+                else
+                    return false;
+
+                return true;
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+
+            return false;
+        }
+
+        private void UpdateProcessorStateDefinition()
+        {
+            // correct an error in older definitions of table agnt-computer-event-details-processorUsage
+            try
+            {
+                var oldFromColumn = StateDefinition.Details.FirstOrDefault(column => column.Name == "From");
+                var oldToColumn = StateDefinition.Details.FirstOrDefault(column => column.Name == "To");
+
+                if (oldFromColumn is null || oldToColumn is null)
+                    return;
+
+                if (oldFromColumn.Column != "Duration" || oldToColumn.Column != "time")
+                    return;
+
+                oldFromColumn.Column = "time";
+                oldToColumn.Column = "Duration.add";
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+        }
+
+        private void ProcessDetailValue(string processintType, ref object rawValue, DateTime timeColumnValue)
+        {
+            try
+            {
+                if (rawValue is Int64 milliSec)
+                {
+                    switch (processintType)
+                    {
+                        case "add":
+                            rawValue = timeColumnValue.AddMilliseconds(milliSec);
+                            break;
+                        case "sub":
+                            rawValue = timeColumnValue.AddMilliseconds(-milliSec);
+                            break;
+                    }
+                }
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+        }
+
+        private cDetailedDataModel GetValuedDataModel()
+        {
+            if (!(StateDefinition.Details is cHealthCardDetailsValued _details) || ValuedDetailsData == null)
+                return null;
+
+            if (ValuedDetailsData.Columns.Count > 1)
+                return null;
+
+            var _rowHeadings = _details.Select(v => v.Names.GetValue() as object).ToList();
+            cDetailedDataModel output = new cDetailedDataModel()
+            {
+                Heading = StateDefinition.Names.GetValue(),
+                FullDetailedData = new List<object>(),
+                HasColumnHeaders = _rowHeadings.Count > 1
+            };
+
+            if (_rowHeadings.Count > 1)
+                output.FullDetailedData.Add(_rowHeadings);
+
+            var _data = ValuedDetailsData.Values[0];
+            foreach (var _row in _data)
+                output.FullDetailedData.Add(new List<object>() { _row[0] });
+
+            return output;
+        }
+
+        private cDetailedDataModel GetDetailedData()
+        {
+            try
+            {
+                const string timeColumnName = "time";
+                cDetailedDataModel output = new cDetailedDataModel() { FullDetailedData = new List<object>() };
+
+                string dateAddtionFormat = cMultiLanguageSupport.GetItem("DetailsPage.History.Details");
+                string dateAddition = string.Format(dateAddtionFormat, DateTime.Today.AddDays(-DayIndex).ToString("d", new CultureInfo(cFasdCockpitConfig.Instance.SelectedLanguage)));
+                string detailedDataHeading = "Details - " + DetailsTitle + dateAddition;
+                output.Heading = detailedDataHeading;
+
+                if (!(StateDefinition.Details is cHealthCardDetails _details) || _details.Table == null)
+                    return null;
+
+                // correct an error in older definitions of table agnt-computer-event-details-processorUsage
+                if (_details.Table == "agnt-computer-event-details-processorUsage")
+                    UpdateProcessorStateDefinition();
+
+                var headerValues = StateDefinition.Details.Select(value => value.Names.GetValue());
+                output.FullDetailedData.Add(headerValues.ToList<object>());
+
+                var detailsData = CachedDetails[DataProvider.Identities][_details.Table];
+
+                if (!detailsData.Values.TryGetValue(DayIndex, out var details))
+                    return output;
+
+                int columnCount = StateDefinition.Details.Count;
+                List<int> rawColumnIndexes = new List<int>(columnCount);
+                List<RawValueType> displayTypes = new List<RawValueType>(columnCount);
+                List<string> valueProcessings = new List<string>(columnCount);
+                int timeColumnIndex = detailsData.Columns.IndexOf(timeColumnName);
+                int filterColumnIndex = detailsData.Columns.IndexOf(StateDefinition.Details?.Filter?.FilterColumn);
+
+                foreach (var columnDefinition in StateDefinition.Details)
+                {
+                    var splitColumnName = columnDefinition.Column.Split('.');
+
+                    var rawColumnIndex = detailsData.Columns.IndexOf(splitColumnName[0]);
+                    var displayType = columnDefinition.DisplayType;
+                    var valueProcessing = splitColumnName.Length > 1 ? splitColumnName[1] : null;
+
+                    rawColumnIndexes.Add(rawColumnIndex);
+                    displayTypes.Add(cUtility.GetRawValueType(displayType));
+                    valueProcessings.Add(valueProcessing);
+                }
+
+                foreach (var detailsRow in details)
+                {
+                    var displayValuesOfRow = new List<object>(columnCount);
+
+                    var displayTypeEnumerator = displayTypes.GetEnumerator();
+                    var valueProcessingsEnumerator = valueProcessings.GetEnumerator();
+                    bool shouldHideRow = false;
+
+                    if (StateDefinition.Details.Filter != null && !rawColumnIndexes.Contains(filterColumnIndex))
+                    {
+                        bool columnValueMatchesFilterValue = StateDefinition.Details.Filter.FilterValues.Contains(detailsRow[filterColumnIndex]);
+                        if (!columnValueMatchesFilterValue)
+                            shouldHideRow = true;
+                    }
+
+                    IRawValueFormatter rawValueFormatter = new RawValueFormatter();
+                    rawValueFormatter.SetDefaultCulture(new System.Globalization.CultureInfo(cFasdCockpitConfig.Instance.SelectedLanguage));
+
+                    foreach (var index in rawColumnIndexes)
+                    {
+                        try
+                        {
+                            if (shouldHideRow)
+                                continue;
+
+                            if (detailsRow.Length < index || !displayTypeEnumerator.MoveNext() || !valueProcessingsEnumerator.MoveNext())
+                                continue;
+
+                            var rawDetailValue = detailsRow[index];
+
+                            if (index == filterColumnIndex
+                                && !StateDefinition.Details.Filter.FilterValues.Contains(rawDetailValue))
+                            {
+                                shouldHideRow = true;
+                                continue;
+                            }
+
+                            if (valueProcessingsEnumerator.Current != null)
+                                if (detailsRow[timeColumnIndex] is DateTime timeColumnValue)
+                                    ProcessDetailValue(valueProcessingsEnumerator.Current, ref rawDetailValue, timeColumnValue);
+
+                            var displayValue = rawValueFormatter.GetDisplayValue(rawDetailValue, displayTypeEnumerator.Current);
+                            displayValuesOfRow.Add(displayValue);
+                        }
+                        catch (Exception E)
+                        {
+                            LogException(E);
+                        }
+                    }
+
+                    if (shouldHideRow)
+                        continue;
+
+                    output.FullDetailedData.Add(displayValuesOfRow);
+                }
+
+                return output;
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+
+            return null;
+        }
+
+        private cDetailedChartModel GetDetailedChartData()
+        {
+            try
+            {
+                if (StateDefinition?.DetailedChartDetails is null)
+                    return null;
+
+                var detailsDataTable = CachedDetails[DataProvider.Identities][StateDefinition.DetailedChartDetails.ValueTable];
+
+                int valueIndex = detailsDataTable.Columns.IndexOf(StateDefinition.DetailedChartDetails.ValueColumn);
+                int timeIndex = detailsDataTable.Columns.IndexOf(StateDefinition.DetailedChartDetails.TimeColumn);
+                int durationIndex = detailsDataTable.Columns.IndexOf(StateDefinition.DetailedChartDetails.DurationColumn);
+                string title = StateDefinition.Names.GetValue();
+                bool isThresholdActive = StateDefinition is cHealthCardStateLevel;
+
+                var output = new cDetailedChartModel()
+                {
+                    Data = detailsDataTable.Values[DayIndex],
+                    ValueIndex = valueIndex,
+                    TimeIndex = timeIndex,
+                    DurationIndex = durationIndex,
+                    ChartTitle = title,
+                    IsThresholdActive = isThresholdActive,
+                };
+
+                if (StateDefinition is cHealthCardStateLevel stateLevelDefinition)
+                {
+                    output.WarningThreshold = stateLevelDefinition.Warning;
+                    output.ErrorThreshold = stateLevelDefinition.Error;
+                }
+                return output;
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+
+            return null;
+        }
+
+        private cChartModel GetChartData()
+        {
+            try
+            {
+                if (StateDefinition?.ChartDetails is null)
+                    return null;
+
+                var detailsDataTable = CachedDetails[DataProvider.Identities][StateDefinition.ChartDetails.ValueTable];
+
+                int valueIndex = detailsDataTable.Columns.IndexOf(StateDefinition.ChartDetails.ValueColumn);
+                int timeIndex = detailsDataTable.Columns.IndexOf(StateDefinition.ChartDetails.TimeColumn);
+                int durationIndex = detailsDataTable.Columns.IndexOf(StateDefinition.ChartDetails.DurationColumn);
+                string title = StateDefinition.Names.GetValue();
+                bool isThresholdActive = false;
+                double warningThreshold = 0;
+                double errorThreshold = 0;
+                bool isDirectionUp = true;
+                if (StateDefinition is cHealthCardStateLevel stateLevel)
+                {
+                    isThresholdActive = true;
+                    warningThreshold = stateLevel.Warning;
+                    errorThreshold = stateLevel.Error;
+                    isDirectionUp = stateLevel.IsDirectionUp;
+                }
+                int stepLengthScale = StateDefinition.ChartDetails.StepLengthScale;
+                int stepLengthLine = StateDefinition.ChartDetails.StepLengthLine;
+                int maxValue = StateDefinition.ChartDetails.MaxValue;
+                int minValue = StateDefinition.ChartDetails.MinValue;
+                string unitFormat = StateDefinition.UnitFormat;
+
+
+                var output = new cChartModel()
+                {
+                    Data = detailsDataTable.Values[DayIndex],
+                    ValueIndex = valueIndex,
+                    TimeIndex = timeIndex,
+                    DurationIndex = durationIndex,
+                    ChartTitle = title,
+                    WarningThreshold = warningThreshold,
+                    ErrorThreshold = errorThreshold,
+                    IsThresholdActive = isThresholdActive,
+                    IsDirectionUp = isDirectionUp,
+                    StepLengthScale = stepLengthScale,
+                    StepLengthLine = stepLengthLine,
+                    MaxValue = maxValue,
+                    MinValue = minValue,
+                    UnitFormat = unitFormat,
+
+                };
+
+                return output;
+
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+
+            return null;
+        }
+
+        private async Task<cDetailedDataModel> GetRefreshedDetailedDataAsync()
+        {
+            cDetailedDataModel output = null;
+            try
+            {
+                CachedDetails.Remove(DataProvider.Identities);
+
+                if (await LoadDetailsDataAsync())
+                    return GetDetailedData();
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+
+            return output;
+        }
+
+        private async Task<cDetailedChartModel> GetRefreshedDetailsChartDataAsync()
+        {
+            cDetailedChartModel output = null;
+
+            try
+            {
+                CachedDetails.Remove(DataProvider.Identities);
+
+                if (await LoadDetailsDataAsync())
+                    return GetDetailedChartData();
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+
+            return output;
+        }
+
+        private async Task<cChartModel> GetRefreshedChartDataAsync()
+        {
+            cChartModel output = null;
+
+            try
+            {
+                CachedDetails.Remove(DataProvider.Identities);
+
+                if (await LoadDetailsDataAsync())
+                    return GetChartData();
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+
+            return output;
+        }
+
+    }
+}
--- a/FasdDesktopUi/Basics/UiActions/ShowHeadingSelectionMenuAction.cs
+++ b/FasdDesktopUi/Basics/UiActions/ShowHeadingSelectionMenuAction.cs
@@ -0,0 +1,50 @@
+using C4IT.FASD.Base;
+using C4IT.Logging;
+using FasdDesktopUi.Basics.Models;
+using FasdDesktopUi.Basics.UserControls;
+using FasdDesktopUi.Pages.DetailsPage;
+using FasdDesktopUi.Pages.DetailsPage.UserControls;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.InteropServices.WindowsRuntime;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+
+using static C4IT.Logging.cLogManager;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    public class cShowHeadingSelectionMenuAction : cUiActionBase
+    {
+        public override async Task<bool> RunUiActionAsync(object sender, UIElement UiLocation, bool isDetailedLayout, cSupportCaseDataProvider dataProvider)
+        {
+            try
+            {
+                if (!(UiLocation is DetailsPageView detailsPage))
+                    return false;
+
+                detailsPage.IsBlurred = true;
+                Panel.SetZIndex(detailsPage.NavigationHeadingUc, 4);
+                detailsPage.NavigationHeadingUc.ClearValue(DetailsPageView.EffectProperty);
+
+                return true;
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+            finally
+            {
+            }
+
+            await Task.CompletedTask;
+
+            return false;
+        }
+    }
+}
--- a/FasdDesktopUi/Basics/UiActions/ShowRecommendationAction.cs
+++ b/FasdDesktopUi/Basics/UiActions/ShowRecommendationAction.cs
@@ -0,0 +1,66 @@
+using C4IT.Logging;
+
+using FasdDesktopUi.Basics.Models;
+using FasdDesktopUi.Basics.UserControls;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+
+using static C4IT.Logging.cLogManager;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    public class cShowRecommendationAction : cUiActionBase
+    {
+        public string Title { get; set; }
+        public string Recommendation { get; set; }
+
+        public cShowRecommendationAction(string Title, string Recommendation)
+        {
+            this.Title = Title;
+            this.Recommendation = Recommendation;
+        }
+
+        public async override Task<bool> RunUiActionAsync(object sender, UIElement UiLocation, bool isDetailedLayout, cSupportCaseDataProvider dataProvider)
+        {
+
+            try
+            {
+                if (!(UiLocation is Decorator decorator))
+                    return false;
+
+                cRecommendationDataModel recommendationDataModel = Recommendation != null ? new cRecommendationDataModel() { Category = Title, Recommendation = Recommendation } : null;
+
+                if (decorator.Child is DataCanvas existingDataCanvas)
+                {
+                    var tempDataCanvasData = new cDataCanvasDataModel() { QuickActionStatusMonitorData = null, DetailedData = null, RecommendationData = recommendationDataModel };
+                    existingDataCanvas.DataCanvasData = tempDataCanvasData;
+                    existingDataCanvas.IsDetailedLayout = isDetailedLayout;
+                    existingDataCanvas.Visibility = Visibility.Visible;
+                }
+                else
+                {
+                    DataCanvas dataCanvas = new DataCanvas() { DataCanvasData = new cDataCanvasDataModel() { DetailedData = null, RecommendationData = recommendationDataModel }, IsDetailedLayout = isDetailedLayout };
+                    decorator.Child = dataCanvas;
+                }
+
+                decorator.Visibility = Visibility.Visible;
+
+                return true;
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+
+            await Task.CompletedTask;
+
+            return false;
+        }
+    }
+}
--- a/FasdDesktopUi/Basics/UiActions/SubMenuAction.cs
+++ b/FasdDesktopUi/Basics/UiActions/SubMenuAction.cs
@@ -0,0 +1,54 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+
+using C4IT.Logging;
+
+using FasdDesktopUi.Basics.Models;
+using FasdDesktopUi.Basics.UserControls;
+
+using static C4IT.Logging.cLogManager;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    public class cSubMenuAction : cUiActionBase
+    {
+        public bool UseTempData { get; private set; }
+        public List<cMenuDataBase> SubMenuData { get; set; }
+
+        public cSubMenuAction(bool UseTempData)
+        {
+            this.UseTempData = UseTempData;
+        }
+
+        public override async Task<bool> RunUiActionAsync(object sender, UIElement UiLocation, bool isDetailedLayout, cSupportCaseDataProvider dataProvider)
+        {
+            try
+            {
+                if (!(UiLocation is QuickActionSelector quickActionSelector))
+                    return false;
+
+                quickActionSelector.Visibility = Visibility.Visible;
+                quickActionSelector.TempQuickActionSelectorHeading = UseTempData ? quickActionSelector.QuickActionSelectorHeading : null;
+                quickActionSelector.TempQuickActionList = UseTempData ? quickActionSelector.QuickActionList : null;
+
+                quickActionSelector.QuickActionSelectorHeading = Name;
+                quickActionSelector.QuickActionList = SubMenuData;
+
+                return true;
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+
+            await Task.CompletedTask;
+            return false;
+        }
+    }
+}
--- a/FasdDesktopUi/Basics/UiActions/UiActionBase.cs
+++ b/FasdDesktopUi/Basics/UiActions/UiActionBase.cs
@@ -0,0 +1,64 @@
+using C4IT.FASD.Base;
+using FasdDesktopUi.Basics.Enums;
+using System;
+using System.Threading.Tasks;
+using System.Windows;
+using static C4IT.Logging.cLogManager;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    public abstract class cUiActionBase
+    {
+        public string Name { get; set; }
+        public string Description { get; set; }
+        public string AlternativeDescription { get; set; }
+        public enumActionDisplayType DisplayType { get; set; }
+
+        public static cUiActionBase GetUiAction(cFasdQuickAction quickAction)
+        {
+            try
+            {
+                if (quickAction is cF4sdQuickActionLocalWebRequest webRequestQuickAction)
+                    return new cUiLocalWebRequestQuickAction(webRequestQuickAction);
+                else if (quickAction is cFasdQuickActionLocal localQuickAction)
+                    return new cUiLocalQuickAction(localQuickAction);
+                else if (quickAction is cF4sdQuickActionRemote remoteQuickAction)
+                    return new cUiRemoteQuickAction(remoteQuickAction);
+                else if (quickAction is cF4sdQuickActionChained chainQuickAction)
+                    return new cUiChainQuickAction(chainQuickAction);
+                else if (quickAction is cF4sdQuickActionDemo QuickActionDemo)
+                    return new cUiDemoQuickAction(QuickActionDemo);
+                else if (quickAction is cF4sdQuickActionServer serverQuickAction)
+                    return new cUiServerQuickAction(serverQuickAction);
+                else
+                    return new cUiDummyQuickAction(quickAction);
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+
+            return null;
+        }
+
+        public abstract Task<bool> RunUiActionAsync(object sender, UIElement UiLocation, bool isDetailedLayout, cSupportCaseDataProvider dataProvider);
+
+        public delegate void UiActionEventHandlerDelegate(object sender, UiActionEventArgs args);
+
+        public static readonly RoutedEvent UiActionClickedEvent = EventManager.RegisterRoutedEvent("UiActionClicked", RoutingStrategy.Bubble, typeof(UiActionEventHandlerDelegate), typeof(UIElement));
+
+        public static void RaiseEvent(cUiActionBase uiAction, UIElement uiElement, object sender)
+        {
+            uiElement.RaiseEvent(new UiActionEventArgs(UiActionClickedEvent, sender) { UiAction = uiAction });
+        }
+    }
+
+    public class UiActionEventArgs : RoutedEventArgs
+    {
+        public cUiActionBase UiAction { get; set; }
+
+        public UiActionEventArgs(RoutedEvent routedEvent, object source) : base(routedEvent, source)
+        {
+        }
+    }
+}
--- a/FasdDesktopUi/Basics/UiActions/UiChainQuickAction.cs
+++ b/FasdDesktopUi/Basics/UiActions/UiChainQuickAction.cs
@@ -0,0 +1,207 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+using FasdDesktopUi.Basics.Models;
+using C4IT.FASD.Base;
+using C4IT.MultiLanguage;
+using static C4IT.Logging.cLogManager;
+using C4IT.F4SD.DisplayFormatting;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    public class cUiChainQuickAction : cUiQuickAction
+    {
+        private readonly List<cFasdQuickAction> chainedQuickActionConfigs = new List<cFasdQuickAction>();
+
+        public int QuickActionCount { get => chainedQuickActionConfigs?.Count ?? 0; }
+
+        public cF4sdQuickActionChained ChainedQuickAction { get; set; }
+
+        public cUiChainQuickAction(cF4sdQuickActionChained quickAction) : base(quickAction)
+        {
+            ChainedQuickAction = quickAction;
+
+            foreach (var quickActionName in quickAction.QuickActionNames)
+            {
+                if ((cF4SDCockpitXmlConfig.Instance?.QuickActionConfig?.F4SDQuickActions.QuickActions.TryGetValue(quickActionName, out var chainedQuickAction) ?? false))
+                    chainedQuickActionConfigs.Add(chainedQuickAction);
+                else
+                    LogEntry($"Couldn't find Quick Action with name '{quickActionName}'", C4IT.Logging.LogLevels.Warning);
+            }
+        }
+
+        public async override Task<cQuickActionStatusMonitorModel> GetQuickActionStatusMonitorDataAsync()
+        {
+            try
+            {
+                var quickActionSteps = new List<cQuickActionStatusMonitorModel.cQuickActionStep>();
+
+                bool requiresUserPermission = false;
+
+                foreach (var quickActionConfig in chainedQuickActionConfigs)
+                {
+                    var tempStep = new cQuickActionStatusMonitorModel.cQuickActionStep(quickActionConfig.Names.GetValue(), quickActionConfig.Name, cQuickActionStatusMonitorModel.cQuickActionStep.enumActionStepType.main);
+
+                    var uiAction = cUiActionBase.GetUiAction(quickActionConfig);
+                    if (uiAction is cUiQuickAction uiQuickAction)
+                    {
+                        var statusMonitorData = await uiQuickAction.GetQuickActionStatusMonitorDataAsync();
+                        tempStep.SubSteps = statusMonitorData.ActionSteps;
+
+                        requiresUserPermission = requiresUserPermission || statusMonitorData.RequiresUserPermission;
+                    }
+
+                    quickActionSteps.Add(tempStep);
+
+                }
+
+                var output = new cQuickActionStatusMonitorModel()
+                {
+                    ActionName = ChainedQuickAction.Names.GetValue(),
+                    QuickActionDefinition = ChainedQuickAction,
+                    ActionSteps = quickActionSteps,
+                    RequiresUserPermission = requiresUserPermission,
+                    RunQuickAction = ProcessActionAsync
+                };
+
+                if (chainedQuickActionConfigs.Any(config => config.AdjustableParameters?.Count > 0))
+                    output.QuickActionParameters = new Dictionary<string, cAdjustableParameter>();
+
+                foreach (var quickActionConfig in chainedQuickActionConfigs)
+                {
+                    if (quickActionConfig.AdjustableParameters is null)
+                        continue;
+
+                    foreach (var quickActionParam in quickActionConfig.AdjustableParameters)
+                    {
+                        if (output.QuickActionParameters is null || output.QuickActionParameters.ContainsKey(quickActionParam.Key))
+                            continue;
+
+                        output.QuickActionParameters.Add(quickActionParam.Key, quickActionParam.Value);
+                    }
+                }
+
+                return output;
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+
+            return null;
+        }
+
+        public override async Task<cDataCanvasDataModel> GetQuickActionDataAsync(cSupportCaseDataProvider dataProvider, bool isDetailedLayout)
+        {
+            DataProvider = dataProvider;
+
+            var detailedData = new cDetailedDataModel() { Heading = cMultiLanguageSupport.GetItem("DetailsPage.History") };
+
+            //Get QuickAciton Data
+            detailedData.FullDetailedData = new List<object>() { new List<object>() { "Status", cMultiLanguageSupport.GetItem("QuickAction.Revision.ExecutionTime") } };
+            if (dataProvider != null)
+            {
+                var quickActionHistory = await dataProvider.QuickActionProtocollHelper.GetQuickActionHistoryAsync(ChainedQuickAction.Name);
+                foreach (var historyLine in quickActionHistory)
+                {
+                    detailedData.FullDetailedData.Add(historyLine);
+                }
+            }
+
+            //Get Process Steps of Action
+            var quickActionData = await GetQuickActionStatusMonitorDataAsync();
+
+            //Get Recommendation
+            cRecommendationDataModel recommendationData = QuickActionRecommendation?.Recommendation != null ? QuickActionRecommendation : null;
+
+            return new cDataCanvasDataModel() { DetailedData = detailedData, QuickActionStatusMonitorData = quickActionData, RecommendationData = recommendationData };
+        }
+
+        private void CancelRunningActionSteps()
+        {
+            try
+            {
+                foreach (var actionStep in StatusMonitor.QuickActionData.ActionSteps)
+                {
+                    if (actionStep.Status is enumQuickActionRevisionStatus.inProgress)
+                        actionStep.Status = enumQuickActionRevisionStatus.canceled;
+
+                    foreach (var subSteps in actionStep.SubSteps)
+                    {
+                        if (subSteps.Status is enumQuickActionRevisionStatus.inProgress)
+                            subSteps.Status = enumQuickActionRevisionStatus.canceled;
+                    }
+                }
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+        }
+
+        public override async Task<List<object>> ProcessActionAsync(CancellationToken token, Dictionary<cAdjustableParameter, object> ParameterDictionary = null)
+        {
+            try
+            {
+                if (chainedQuickActionConfigs?.Count <= 0)
+                    return null;
+
+                foreach (var quickActionConfig in chainedQuickActionConfigs)
+                {
+                    if (token.IsCancellationRequested)
+                        break;
+
+                    var uiAction = GetUiAction(quickActionConfig);
+
+                    if (uiAction is null)
+                        continue;
+
+                    if (!(uiAction is cUiQuickAction uiQuickAction))
+                        continue;
+
+                    uiQuickAction.DataProvider = DataProvider;
+                    uiQuickAction.StatusMonitor = StatusMonitor;
+
+                    foreach (var child in StatusMonitor.CompletionStatusPanel.Children)
+                    {
+                        if (child is System.Windows.Controls.StackPanel childStackPanel)
+                            childStackPanel.Visibility = System.Windows.Visibility.Collapsed;
+
+                        if (child is System.Windows.FrameworkElement childFrameworkElement)
+                            if (childFrameworkElement.Tag?.Equals(quickActionConfig.Name) ?? false)
+                                childFrameworkElement.Visibility = System.Windows.Visibility.Visible;
+                    }
+
+                    var result = await uiQuickAction.ProcessActionAsync(token, ParameterDictionary);
+
+                    if (result != null && result[0].Equals(cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.FinishedWithError")))
+                    {
+                        CancelRunningActionSteps();
+                        return new List<object>() { cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.FinishedWithError"), _rawValueFormatter.GetDisplayValue(DateTime.UtcNow, RawValueType.DATETIME) };
+                    }
+                }
+
+                if (token.IsCancellationRequested)
+                {
+                    CancelRunningActionSteps();
+                    return new List<object>() { cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.Canceled"), _rawValueFormatter.GetDisplayValue(DateTime.UtcNow, RawValueType.DATETIME) };
+                }
+
+                return new List<object>() { cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.FinishedSuccessfull"), _rawValueFormatter.GetDisplayValue(DateTime.UtcNow, RawValueType.DATETIME) };
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+
+            return null;
+        }
+    }
+}
--- a/FasdDesktopUi/Basics/UiActions/UiCopyAction.cs
+++ b/FasdDesktopUi/Basics/UiActions/UiCopyAction.cs
@@ -0,0 +1,70 @@
+using System;
+using System.Reflection;
+using System.Threading.Tasks;
+using System.Windows;
+
+using FasdDesktopUi.Basics.UserControls;
+using C4IT.FASD.Base;
+using static C4IT.Logging.cLogManager;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    public class cUiCopyAction : cUiActionBase
+    {
+        public cCopyTemplate CopyTemplate { get; set; }
+
+        public cUiCopyAction(cCopyTemplate copyTemplate)
+        {
+            CopyTemplate = copyTemplate;
+        }
+
+        public override async Task<bool> RunUiActionAsync(object sender, UIElement UiLocation, bool isDetailedLayout, cSupportCaseDataProvider dataProvider)
+        {
+            var CM = MethodBase.GetCurrentMethod();
+            LogMethodBegin(CM);
+            try
+            {
+                if (dataProvider == null || dataProvider.NamedParameterEntries.Count == 0 || CopyTemplate == null)
+                    return false;
+
+                var ClData = new DataObject();
+                foreach (var Entry in CopyTemplate.CopyContentList.Values)
+                    SetCopyContent(ClData, Entry, dataProvider);
+
+                System.Windows.Forms.Clipboard.SetDataObject(ClData, true);
+
+                if (sender is CustomMenuItem senderElement)
+                    await cUtility.ChangeIconToCheckAsync(senderElement.MenuItemIcon);
+
+                return true;
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+            finally
+            {
+                LogMethodEnd(CM);
+            }
+
+            return false;
+        }
+
+        private void SetCopyContent(DataObject ClData, cCopyContent Content, cSupportCaseDataProvider dataProvider)
+        {
+            var clipboardText = Content.Content;
+
+            clipboardText = dataProvider.HealthCardDataHelper.ReplaceNamedParameters(clipboardText, Content.Format == enumCopyContentFormat.HTML);
+
+            var textFormat = TextDataFormat.UnicodeText;
+            if (Content.Format == enumCopyContentFormat.HTML)
+            {
+                clipboardText = cUtility.GetHtmlFrame(clipboardText);
+                textFormat = TextDataFormat.Html;
+            }
+
+            ClData.SetText(clipboardText, textFormat);
+        }
+
+    }
+}
--- a/FasdDesktopUi/Basics/UiActions/UiCopyDetailsTableContent.cs
+++ b/FasdDesktopUi/Basics/UiActions/UiCopyDetailsTableContent.cs
@@ -0,0 +1,179 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using System.IO;
+using System.Text;
+
+using Microsoft.Win32;
+
+using C4IT.Logging;
+
+using FasdDesktopUi.Basics.Models;
+
+using static C4IT.Logging.cLogManager;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using C4IT.MultiLanguage;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    abstract public class cUiCopyDetailsTableContentBase : cUiActionBase
+    {
+        private cDetailedDataModel Data;
+
+        public cUiCopyDetailsTableContentBase(cDetailedDataModel Data)
+        {
+            this.Data = Data;
+        }
+
+        internal String getContentString(bool csv)
+        {
+            try
+            {
+                string retVal = String.Empty;
+                char separator = csv ? ';' : '\t';
+
+                if (!Data.HasColumnHeaders)
+                    retVal = Data.Heading;
+
+                foreach (var row in Data.FullDetailedData)
+                {
+                    if (!(row is List<object> _lst))
+                        continue;
+
+                    var line = String.Empty;
+                    foreach (var cell in _lst)
+                    {
+                        if (!string.IsNullOrEmpty(line))
+                            line += separator;
+
+                        var item = cell.ToString();
+                        if (csv && item.Contains(separator.ToString()))
+                        {
+                            item = item.Replace("\"", "\"\"");
+                            item = "\"" + item + "\"";
+                        }
+
+                        line += item;
+                    }
+                    if (!string.IsNullOrEmpty(line))
+                    {
+                        if (!string.IsNullOrEmpty(retVal))
+                            retVal += "\n";
+                        retVal += line;
+                    }
+                }
+
+                return retVal;
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+
+            return null;
+        }
+    }
+
+    public class cUiCopyDetailsTableContent : cUiCopyDetailsTableContentBase
+    {
+        public cUiCopyDetailsTableContent (cDetailedDataModel Data) : base(Data)
+        {
+        }
+
+        public override async Task<bool> RunUiActionAsync(object sender, System.Windows.UIElement UiLocation, bool isDetailedLayout, cSupportCaseDataProvider dataProvider)
+        {
+            await Task.CompletedTask;
+
+            var strCipboard = getContentString(false);
+            if (string.IsNullOrEmpty(strCipboard))
+                return true;
+
+            strCipboard += "\n";
+            System.Windows.Forms.Clipboard.SetText(strCipboard);
+
+            return false;
+        }
+    }
+
+
+    public class cUiSaveDetailsTableContent : cUiCopyDetailsTableContentBase
+    {
+        public cUiSaveDetailsTableContent(cDetailedDataModel Data) : base(Data)
+        {
+        }
+
+
+        [DllImport("shell32.dll", CharSet = CharSet.Unicode)]
+        static extern int SHGetKnownFolderPath([MarshalAs(UnmanagedType.LPStruct)] Guid rfid, uint dwFlags, IntPtr hToken, out string pszPath);
+
+        public static readonly Guid DownloadsFolderID = new Guid("374DE290-123F-4565-9164-39C4925E467B");
+
+        public static string GetSpecialWindowsFolder(Guid FolderID)
+        {
+            try
+            {
+                string _folder;
+                if (SHGetKnownFolderPath(FolderID, 0, IntPtr.Zero, out _folder) == 0)
+                    return _folder;
+
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+            return String.Empty;
+        }
+
+        public override async Task<bool> RunUiActionAsync(object sender, System.Windows.UIElement UiLocation, bool isDetailedLayout, cSupportCaseDataProvider dataProvider)
+        {
+
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+
+            try
+            {
+                await Task.CompletedTask;
+
+                var strContent = getContentString(false);
+
+                if (string.IsNullOrEmpty(strContent))
+                    return true;
+
+                var LastDirectory = cFasdCockpitConfig.Instance.LastDownloadPath;
+                if (string.IsNullOrEmpty(LastDirectory))
+                    LastDirectory = GetSpecialWindowsFolder(DownloadsFolderID);
+
+                SaveFileDialog saveFileDialog = new SaveFileDialog()
+                {
+                    Filter = "Tab-separated file (*.txt)|*.txt|Comma-serarated file (*.csv)|*.csv",
+                    Title = cMultiLanguageSupport.GetItem("DetailsPage.DetailTable.ContentDownload"),
+                    InitialDirectory = LastDirectory
+                };
+
+                if (saveFileDialog.ShowDialog() != true)
+                    return true;
+
+                if (Path.GetExtension(saveFileDialog.FileName).ToLower() == ".csv")
+                    strContent = getContentString(true);
+
+                File.WriteAllText(saveFileDialog.FileName, strContent, Encoding.UTF8);
+
+                cFasdCockpitConfig.Instance.LastDownloadPath = Path.GetDirectoryName(saveFileDialog.FileName);
+                cFasdCockpitConfig.Instance.Save("LastDownloadPath");
+
+                return true;
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+            finally
+            {
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return false;
+        }
+    }
+
+}
--- a/FasdDesktopUi/Basics/UiActions/UiDemoQuickAction.cs
+++ b/FasdDesktopUi/Basics/UiActions/UiDemoQuickAction.cs
@@ -0,0 +1,147 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using C4IT.F4SD.DisplayFormatting;
+using C4IT.FASD.Base;
+using C4IT.Logging;
+using C4IT.MultiLanguage;
+
+using FasdCockpitBase.Models;
+
+using FasdDesktopUi.Basics.Models;
+using FasdDesktopUi.Basics.Services.ProtocollService;
+using FasdDesktopUi.Basics.UserControls;
+
+using static FasdDesktopUi.Basics.UserControls.QuickActionStatusMonitor;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    public class cUiDemoQuickAction : cUiQuickAction
+    {
+        public cF4sdQuickActionDemo quickActionDemo { get; private set; }
+
+        public cUiDemoQuickAction(cF4sdQuickActionDemo QuickActionConfig) : base(QuickActionConfig)
+        {
+            quickActionDemo = QuickActionConfig;
+            Name = QuickActionConfig.Name;
+        }
+
+        public override async Task<cDataCanvasDataModel> GetQuickActionDataAsync(cSupportCaseDataProvider dataProvider, bool isDetailedLayout)
+        {
+            await Task.CompletedTask;
+
+            DataProvider = dataProvider;
+
+            var detailedData = new cDetailedDataModel() { Heading = "Demo QuickAction" };
+
+            //Get QuickAciton Data
+            detailedData.FullDetailedData = new List<object>()
+            {
+                new List<object>() { "Status", cMultiLanguageSupport.GetItem("QuickAction.Revision.ExecutionTime")},
+                new List<object>() { cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.FinishedSuccessfull"), _rawValueFormatter.GetDisplayValue(DateTime.UtcNow.AddMinutes(-5), RawValueType.DATETIME)},
+                new List<object>() { cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.FinishedSuccessfull"), _rawValueFormatter.GetDisplayValue(DateTime.UtcNow.AddMinutes(-38), RawValueType.DATETIME) },
+                new List<object>() { cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.FinishedWithError"), _rawValueFormatter.GetDisplayValue(DateTime.UtcNow.AddHours(-2).AddMinutes(12), RawValueType.DATETIME) },
+                new List<object>() { cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.FinishedSuccessfull"), _rawValueFormatter.GetDisplayValue(DateTime.UtcNow.AddDays(-1).AddHours(4).AddMinutes(-32), RawValueType.DATETIME) },
+                new List<object>() { cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.FinishedWithError"), _rawValueFormatter.GetDisplayValue(DateTime.UtcNow.AddDays(-1).AddHours(4).AddMinutes(-34), RawValueType.DATETIME) }
+            };
+
+            //Get Process Steps of Action
+            var quickActionData = new cQuickActionStatusMonitorModel()
+            {
+                ActionName = Name,
+                QuickActionDefinition = quickActionDemo,
+                ActionSteps = new List<cQuickActionStatusMonitorModel.cQuickActionStep>(),
+                QuickActionParameters = quickActionDemo.AdjustableParameters,
+                RunQuickAction = ProcessActionAsync
+            };
+
+            if (quickActionDemo.QuickActionType == enumQuickActionExecutionType.LocalScript)
+            {
+                quickActionData.ActionSteps.Add(new cQuickActionStatusMonitorModel.cQuickActionStep(cMultiLanguageSupport.GetItem("QuickAction.Local.Load"), quickActionDemo.Name, cQuickActionStatusMonitorModel.cQuickActionStep.enumActionStepType.running));
+            }
+            else
+            {
+                if (quickActionDemo.SimulatedClientConnect > 0)
+                    quickActionData.ActionSteps.Add(new cQuickActionStatusMonitorModel.cQuickActionStep(cMultiLanguageSupport.GetItem("QuickAction.Remote.Connect"), quickActionDemo.Name, cQuickActionStatusMonitorModel.cQuickActionStep.enumActionStepType.connectingToClient));
+                if (quickActionDemo.SimulatedRuntime > 0)
+                    quickActionData.ActionSteps.Add(new cQuickActionStatusMonitorModel.cQuickActionStep(cMultiLanguageSupport.GetItem("QuickAction.Remote.Running"), quickActionDemo.Name, cQuickActionStatusMonitorModel.cQuickActionStep.enumActionStepType.running));
+            }
+
+            cRecommendationDataModel recommendationData = QuickActionRecommendation?.Recommendation != null ? QuickActionRecommendation : null;
+
+            return new cDataCanvasDataModel() { DetailedData = detailedData, QuickActionStatusMonitorData = quickActionData, RecommendationData = recommendationData };
+        }
+
+        public override async Task<List<object>> ProcessActionAsync(CancellationToken token, Dictionary<cAdjustableParameter, object> ParameterDictionary = null)
+        {
+            var _finshedStatus = enumQuickActionRevisionStatus.finishedSuccessfull;
+            if (quickActionDemo.SimulatedClientConnect > 0)
+            {
+                try { await Task.Delay(quickActionDemo.SimulatedClientConnect * 1000, token); }
+                catch (TaskCanceledException) { }
+
+                if (token.IsCancellationRequested)
+                    _finshedStatus = enumQuickActionRevisionStatus.canceled;
+                cQuickActionStatusMonitorModel.cQuickActionStep.SetQuickActionStepStatuses(StatusMonitor.QuickActionData.ActionSteps, quickActionDemo.Name, cQuickActionStatusMonitorModel.cQuickActionStep.enumActionStepType.connectingToClient, _finshedStatus);
+            }
+
+            if (quickActionDemo.SimulatedRuntime > 0)
+            {
+                if (!token.IsCancellationRequested)
+                    try { await Task.Delay(quickActionDemo.SimulatedRuntime * 1000, token); }
+                    catch (TaskCanceledException) { }
+
+                if (token.IsCancellationRequested)
+                    _finshedStatus = enumQuickActionRevisionStatus.canceled;
+
+                cQuickActionStatusMonitorModel.cQuickActionStep.SetQuickActionStepStatuses(StatusMonitor.QuickActionData.ActionSteps, quickActionDemo.Name, cQuickActionStatusMonitorModel.cQuickActionStep.enumActionStepType.running, _finshedStatus);
+            }
+
+            string _msg;
+            if (_finshedStatus == enumQuickActionRevisionStatus.canceled)
+            {
+                _msg = cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.Canceled");
+                cQuickActionStatusMonitorModel.cQuickActionStep.CancelRemainingQuickActionSteps(StatusMonitor.QuickActionData.ActionSteps);
+            }
+            else
+            {
+                if (quickActionDemo?.QuickActionMeasureResults?.Count > 0 && quickActionDemo.QuickActionMeasures?.Count > 0)
+                {
+                    var measureValues = cUiRemoteQuickAction.GetStatusMonitorMeasureValues(quickActionDemo.QuickActionMeasureResults.Values.ToList(), quickActionDemo.QuickActionMeasures);
+                    if (measureValues?.Count > 0)
+                        StatusMonitor.MeasureValues = measureValues;
+                }
+
+                cQuickActionOutput quickActionOutput = null;
+                var _ref = new cF4sdQuickActionRevision();
+
+                if (!string.IsNullOrEmpty(quickActionDemo?.DemoResult))
+                    try
+                    {
+                        dynamic retValue = Newtonsoft.Json.JsonConvert.DeserializeObject(quickActionDemo?.DemoResult);
+                        var _output = new cF4sdQuickActionRevision.cOutput()
+                        {
+                            ResultCode = quickActionDemo.QuickActionSuccess,
+                            Values = retValue
+                        };
+
+                        _ref.OutputText = Newtonsoft.Json.JsonConvert.SerializeObject(_output);
+                    }
+                    catch { }
+
+                StatusMonitor.QuickActionOutputs.Add(_ref.Output);
+                quickActionOutput = QuickActionStatusMonitor.cQuickActionOutput.GetQuickActionOutput(_ref.Output, DataProvider);
+
+                cQuickActionCopyData copyData = QuickActionProtocollEntry.GetCopyData(quickActionDemo, DataProvider, true, quickActionOutput, StatusMonitor.MeasureValues);
+                F4SDProtocoll.Instance.Add(new QuickActionProtocollEntry(quickActionDemo, copyData));
+
+                _msg = cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.FinishedSuccessfull");
+            }
+
+            return new List<object>() { _msg, _rawValueFormatter.GetDisplayValue(DateTime.UtcNow, RawValueType.DATETIME) };
+        }
+    }
+}
--- a/FasdDesktopUi/Basics/UiActions/UiDummyQuickAction.cs
+++ b/FasdDesktopUi/Basics/UiActions/UiDummyQuickAction.cs
@@ -0,0 +1,47 @@
+using C4IT.F4SD.DisplayFormatting;
+using C4IT.FASD.Base;
+using C4IT.Logging;
+using C4IT.MultiLanguage;
+using FasdCockpitBase.Models;
+using FasdDesktopUi.Basics.Models;
+using FasdDesktopUi.Basics.UserControls;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.Tracing;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using static C4IT.Logging.cLogManager;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    public class cUiDummyQuickAction : cUiQuickAction
+    {
+        public cUiDummyQuickAction(cFasdQuickAction quickAction)
+            : base(null)
+        {
+            Name = quickAction.Name;
+            Description = quickAction.Descriptions.GetValue();
+        }
+
+        public override async Task<cDataCanvasDataModel> GetQuickActionDataAsync(cSupportCaseDataProvider dataProvider = null, bool isDetailedLayout = false)
+        {
+            await Task.CompletedTask;
+            return new cDataCanvasDataModel();
+        }
+
+        public override async Task<List<object>> ProcessActionAsync(CancellationToken token, Dictionary<cAdjustableParameter, object> ParameterDictionary = null)
+        {
+            await Task.CompletedTask;
+            List<object> result = new List<object> { cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.FinishedSuccessfull"), _rawValueFormatter.GetDisplayValue(DateTime.UtcNow, RawValueType.DATETIME) };
+            return result;
+        }
+
+        private List<QuickActionStatusMonitor.cQuickActionMeasureValue> GetStatusMonitorMeasureValues(List<cF4sdQuickActionRevision.cMeasure> measures)
+        {
+            return null;
+        }
+    }
+}
--- a/FasdDesktopUi/Basics/UiActions/UiLocalQuickAction.cs
+++ b/FasdDesktopUi/Basics/UiActions/UiLocalQuickAction.cs
@@ -0,0 +1,246 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using C4IT.F4SD.DisplayFormatting;
+using C4IT.FASD.Base;
+using C4IT.FASD.Cockpit.Communication;
+using C4IT.Logging;
+using C4IT.MultiLanguage;
+using FasdCockpitBase.Models;
+using FasdDesktopUi.Basics.Models;
+using FasdDesktopUi.Basics.Services.ProtocollService;
+using Newtonsoft.Json;
+using static C4IT.Logging.cLogManager;
+using static FasdDesktopUi.Basics.UserControls.QuickActionStatusMonitor;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    public class cUiLocalQuickAction : cUiQuickAction
+    {
+        public cFasdQuickActionLocal LocalQuickAction { get; set; }
+
+        public cUiLocalQuickAction(cFasdQuickActionLocal quickAction) : base(quickAction)
+        {
+            LocalQuickAction = quickAction;
+            Name = quickAction.Name;
+        }
+
+        public override async Task<cQuickActionStatusMonitorModel> GetQuickActionStatusMonitorDataAsync()
+        {
+            await Task.CompletedTask;
+
+            return new cQuickActionStatusMonitorModel()
+            {
+                ActionName = LocalQuickAction.Names.GetValue(),
+                QuickActionDefinition = LocalQuickAction,
+                ActionSteps = new List<cQuickActionStatusMonitorModel.cQuickActionStep>()
+                {
+                    new cQuickActionStatusMonitorModel.cQuickActionStep(cMultiLanguageSupport.GetItem("QuickAction.Local.Load"), LocalQuickAction.Name, cQuickActionStatusMonitorModel.cQuickActionStep.enumActionStepType.running)
+                },
+                QuickActionParameters = LocalQuickAction.AdjustableParameters,
+                RunQuickAction = ProcessActionAsync
+            };
+        }
+
+        public override async Task<cDataCanvasDataModel> GetQuickActionDataAsync(cSupportCaseDataProvider dataProvider, bool isDetailedLayout)
+        {
+            DataProvider = dataProvider;
+
+            var detailedDataQuickActionHistory = new cDetailedDataModel()
+            {
+                Heading = cMultiLanguageSupport.GetItem("DetailsPage.History"),
+                FullDetailedData = new List<object>() { new List<object>() { "Status", cMultiLanguageSupport.GetItem("QuickAction.Revision.ExecutionTime") } }
+            };
+
+            //Get QuickAciton Data
+            if (dataProvider != null)
+            {
+                var quickActionHistory = await dataProvider.QuickActionProtocollHelper.GetQuickActionHistoryAsync(LocalQuickAction.Name);
+
+                if (quickActionHistory != null)
+                    detailedDataQuickActionHistory.FullDetailedData.AddRange(quickActionHistory);
+            }
+
+
+            //Get Process Steps of Action
+            var quickActionData = await GetQuickActionStatusMonitorDataAsync();
+
+            //Get Recommendation
+            cRecommendationDataModel recommendationData = QuickActionRecommendation?.Recommendation != null ? QuickActionRecommendation : null;
+
+            return new cDataCanvasDataModel() { DetailedData = detailedDataQuickActionHistory, QuickActionStatusMonitorData = quickActionData, RecommendationData = recommendationData };
+        }
+
+        private cF4sdQuickActionRevision GetRevisionOutput(cExternalToolExecutorEnh.cProcessResult _result)
+        {
+            var retVal = new cF4sdQuickActionRevision() { Status = enumQuickActionRevisionStatus.unknown };
+            try
+            {
+                if (!string.IsNullOrEmpty(_result.StandardOutput))
+                {
+                    retVal.OutputText = _result.StandardOutput;
+                    if (retVal.Output != null)
+                    {
+                        if (retVal.Output.ErrorCode is null || retVal.Output.ErrorCode == 0)
+                            retVal.Status = enumQuickActionRevisionStatus.finishedSuccessfull;
+                        else
+                            retVal.Status = enumQuickActionRevisionStatus.finishedWithError;
+                    }
+                }
+
+                if (retVal.Status == enumQuickActionRevisionStatus.unknown)
+                {
+                    if (_result.ReturnCode != 0 || !string.IsNullOrEmpty(_result.StandardError))
+                    {
+                        retVal.Status = enumQuickActionRevisionStatus.finishedWithError;
+                        retVal.Output = new cF4sdQuickActionRevision.cOutput()
+                        {
+                            ErrorCode = _result.ReturnCode,
+                            ErrorDescription = _result.StandardError
+                        };
+                    }
+                    else
+                        retVal.Status = enumQuickActionRevisionStatus.finishedSuccessfull;
+                }
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+
+            return retVal;
+        }
+
+        public override async Task<List<object>> ProcessActionAsync(CancellationToken token, Dictionary<cAdjustableParameter, object> ParameterDictionary = null)
+        {
+            try
+            {
+                var startTime = DateTime.UtcNow;
+
+                var _actionResult = await cExternalToolExecutorEnh.StartLocalActionAsync(LocalQuickAction, DataProvider.NamedParameterEntries.ToInterfaceDictionary(), cMultiLanguageSupport.GetItem("RemoteTool.Credentials.PasswordRequest"), ParameterDictionary);
+
+                cQuickActionOutput quickActionOutput = new cQuickActionOutputSingle(new cF4sdQuickActionRevision.cOutput() { ResultCode = enumQuickActionSuccess.unknown });
+                cQuickActionOutput protocollOutput = new cQuickActionOutputSingle(new cF4sdQuickActionRevision.cOutput() { ResultCode = enumQuickActionSuccess.unknown });
+
+                List<object> output = new List<object>();
+
+                if (!token.IsCancellationRequested)
+                {
+                    var ResultRevision = GetRevisionOutput(_actionResult);
+
+                    cQuickActionStatusMonitorModel.cQuickActionStep.SetQuickActionStepStatuses(StatusMonitor.QuickActionData.ActionSteps, LocalQuickAction.Name, cQuickActionStatusMonitorModel.cQuickActionStep.enumActionStepType.running, enumQuickActionRevisionStatus.finishedSuccessfull);
+                    cQuickActionStatusMonitorModel.cQuickActionStep.SetQuickActionStepStatuses(StatusMonitor.QuickActionData.ActionSteps, LocalQuickAction.Name, cQuickActionStatusMonitorModel.cQuickActionStep.enumActionStepType.main, enumQuickActionRevisionStatus.finishedSuccessfull);
+
+                    if (ResultRevision.Output == null)
+                        quickActionOutput = new cQuickActionOutputSingle(new cF4sdQuickActionRevision.cOutput() { ResultCode = enumQuickActionSuccess.finished });
+                    else
+                    {
+                        StatusMonitor.QuickActionOutputs.Add(ResultRevision.Output);
+                        quickActionOutput = cQuickActionOutput.GetQuickActionOutput(ResultRevision.Output, DataProvider);
+                    }
+
+                    if (cF4SDCockpitXmlConfig.Instance.HealthCardConfig.ProtocollLanguage != null)
+                    {
+                        string tempLang = cMultiLanguageSupport.CurrentLanguage;
+                        cMultiLanguageSupport.CurrentLanguage = cF4SDCockpitXmlConfig.Instance.HealthCardConfig.ProtocollLanguage;
+                        if (ResultRevision.Output == null)
+                            protocollOutput = new cQuickActionOutputSingle(new cF4sdQuickActionRevision.cOutput() { ResultCode = enumQuickActionSuccess.finished });
+                        else
+                            protocollOutput = cQuickActionOutput.GetQuickActionOutput(ResultRevision.Output, DataProvider);
+                        cMultiLanguageSupport.CurrentLanguage = tempLang;
+                    }
+
+                    cQuickActionCopyData copyData = QuickActionProtocollEntry.GetCopyData(LocalQuickAction, DataProvider, false, protocollOutput, StatusMonitor.MeasureValues);
+                    F4SDProtocoll.Instance.Add(new QuickActionProtocollEntry(LocalQuickAction, copyData));
+
+
+                    string quickActionStatus;
+                    switch (ResultRevision.Status)
+                    {
+                        case enumQuickActionRevisionStatus.inProgress:
+                            quickActionStatus = cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.InProgress");
+                            break;
+                        case enumQuickActionRevisionStatus.finishedSuccessfull:
+                            quickActionStatus = cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.FinishedSuccessfull");
+                            break;
+                        case enumQuickActionRevisionStatus.finishedWithError:
+                            quickActionStatus = cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.FinishedWithError");
+                            break;
+                        case enumQuickActionRevisionStatus.unknown:
+                        default:
+                            quickActionStatus = cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.Unknown");
+                            break;
+                    }
+
+                    output = new List<object>() { quickActionStatus, _rawValueFormatter.GetDisplayValue(DateTime.UtcNow, RawValueType.DATETIME) };
+                }
+                else
+                {
+                    cQuickActionStatusMonitorModel.cQuickActionStep.SetQuickActionStepStatuses(StatusMonitor.QuickActionData.ActionSteps, LocalQuickAction.Name, cQuickActionStatusMonitorModel.cQuickActionStep.enumActionStepType.main, enumQuickActionRevisionStatus.canceled);
+                    cQuickActionStatusMonitorModel.cQuickActionStep.SetQuickActionStepStatuses(StatusMonitor.QuickActionData.ActionSteps, LocalQuickAction.Name, cQuickActionStatusMonitorModel.cQuickActionStep.enumActionStepType.running, enumQuickActionRevisionStatus.canceled);
+
+                    quickActionOutput = new cQuickActionOutputSingle(new cF4sdQuickActionRevision.cOutput() { ResultCode = enumQuickActionSuccess.error, ErrorDescription = cMultiLanguageSupport.GetItem("QuickAction.Copy.Output.Cancel") });
+
+                    if (cF4SDCockpitXmlConfig.Instance.HealthCardConfig.ProtocollLanguage != null)
+                    {
+                        string tempLang = cMultiLanguageSupport.CurrentLanguage;
+                        cMultiLanguageSupport.CurrentLanguage = cF4SDCockpitXmlConfig.Instance.HealthCardConfig.ProtocollLanguage;
+                        protocollOutput = new cQuickActionOutputSingle(new cF4sdQuickActionRevision.cOutput() { ResultCode = enumQuickActionSuccess.error, ErrorDescription = cMultiLanguageSupport.GetItem("QuickAction.Copy.Output.Cancel") });
+                        cMultiLanguageSupport.CurrentLanguage = tempLang;
+                    }
+
+                    cQuickActionCopyData copyData = QuickActionProtocollEntry.GetCopyData(LocalQuickAction, DataProvider, false, protocollOutput, StatusMonitor.MeasureValues);
+                    F4SDProtocoll.Instance.Add(new QuickActionProtocollEntry(LocalQuickAction, copyData));
+
+                    output = new List<object>() { cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.Canceled"), _rawValueFormatter.GetDisplayValue(DateTime.UtcNow, RawValueType.DATETIME) };
+                }
+
+                _ = Task.Run(async () =>
+                {
+                    try
+                    {
+                        Guid? userId = DataProvider?.Identities?.FirstOrDefault(identity => identity.Class == enumFasdInformationClass.User)?.Id;
+                        Guid? computerId = DataProvider?.Identities?.FirstOrDefault(identity => identity.Class == enumFasdInformationClass.Computer)?.Id;
+
+                        var reportQuickActionParameter = new cF4SDQuickActionParameters()
+                        {
+                            CaseId = DataProvider.CaseId,
+                            QuickActionId = LocalQuickAction.Id,
+                            QuickActionName = LocalQuickAction.Name,
+                            Paramaters = ParameterDictionary is null ? null : JsonConvert.SerializeObject(ParameterDictionary, Formatting.None),
+                            Result = JsonConvert.SerializeObject(quickActionOutput.ResultCode.GetValueOrDefault().ToString(), Formatting.None),
+                            ErrorCode = quickActionOutput.ErrorCode,
+                            ErrorDescription = quickActionOutput.ErrorDescription,
+                            Start = startTime,
+                            Finish = DateTime.UtcNow,
+                            UserId = userId,
+                            DeviceId = computerId,
+                            ExecutionType = LocalQuickAction.ExecutionType,
+                            ResultType = LocalQuickAction.ResultType
+                        };
+
+                        var reportedQuickActionSuccessfully = await cFasdCockpitCommunicationBase.Instance.ReportQuickAction(reportQuickActionParameter);
+
+                        if (reportedQuickActionSuccessfully is false)
+                            LogEntry($"Failed to report QuickAction '{LocalQuickAction.Name}' for case '{reportQuickActionParameter.CaseId}' to Analytics.", LogLevels.Warning);
+                    }
+                    catch (Exception E)
+                    {
+                        LogException(E);
+                    }
+                });
+
+                return output;
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+                return new List<object>() { cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.FinishedWithError"), _rawValueFormatter.GetDisplayValue(DateTime.UtcNow, RawValueType.DATETIME) };
+            }
+        }
+    }
+}
--- a/FasdDesktopUi/Basics/UiActions/UiLocalWebRequestQuickAction.cs
+++ b/FasdDesktopUi/Basics/UiActions/UiLocalWebRequestQuickAction.cs
@@ -0,0 +1,161 @@
+using C4IT.F4SD.DisplayFormatting;
+using C4IT.FASD.Base;
+using C4IT.Logging;
+using C4IT.MultiLanguage;
+using FasdCockpitBase.Models;
+using FasdDesktopUi.Basics.Models;
+using FasdDesktopUi.Basics.Services.ProtocollService;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using static C4IT.Logging.cLogManager;
+using static FasdDesktopUi.Basics.UserControls.QuickActionStatusMonitor;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    public class cUiLocalWebRequestQuickAction : cUiLocalQuickAction
+    {
+        public cF4sdQuickActionLocalWebRequest WebRequestQuickAction { get; set; }
+
+        public cUiLocalWebRequestQuickAction(cF4sdQuickActionLocalWebRequest webRequestQuickAction) : base(webRequestQuickAction)
+        {
+            WebRequestQuickAction = webRequestQuickAction;
+        }
+
+
+        private string GetUrl()
+        {
+            string output = string.Empty;
+            try
+            {
+                if (WebRequestQuickAction?.QueryString is null)
+                    return output;
+
+                if (!string.IsNullOrEmpty(WebRequestQuickAction.QueryString.ConstValue))
+                {
+                    output = WebRequestQuickAction.QueryString.ConstValue;
+                }
+                else
+                {
+                    var queryStringParameterName = WebRequestQuickAction.QueryString.ParameterName;
+                    if (!string.IsNullOrEmpty(queryStringParameterName))
+                        if (DataProvider.NamedParameterEntries.TryGetValue(queryStringParameterName, out var namedParameterEntry))
+                            output = namedParameterEntry.GetValue();
+                }
+
+                if (string.IsNullOrEmpty(output))
+                    return output;
+
+                if (WebRequestQuickAction.QueryParameters?.Count <= 0)
+                    return output;
+
+                foreach (var queryParameter in WebRequestQuickAction.QueryParameters)
+                {
+                    if (string.IsNullOrEmpty(queryParameter.QueryParameterName))
+                        continue;
+
+                    var replacementString = string.Empty;
+
+                    if (!string.IsNullOrEmpty(queryParameter.ConstValue))
+                    {
+                        replacementString = queryParameter.ConstValue;
+                    }
+                    else
+                    {
+                        var queryStringParameterName = queryParameter.ParameterName;
+                        if (!string.IsNullOrEmpty(queryStringParameterName))
+                            if (DataProvider.NamedParameterEntries.TryGetValue(queryStringParameterName, out var namedParameterEntry))
+                                replacementString = queryParameter.UseHtmlValue ? namedParameterEntry.GetHtmlValue() : namedParameterEntry.GetHtmlValue();
+                    }
+
+                    output = output.Replace(queryParameter.QueryParameterName, replacementString);
+                }
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+
+            return output;
+        }
+
+        public override async Task<List<object>> ProcessActionAsync(CancellationToken token, Dictionary<cAdjustableParameter, object> ParameterDictionary = null)
+        {
+            try
+            {
+                //todo: use ParameterDictionary if request has Parameters                
+
+                await Task.CompletedTask;
+
+                cBrowsers browsers = new cBrowsers();
+                string webRequestUrl = GetUrl();
+
+                browsers.Start(WebRequestQuickAction.BrowserName, webRequestUrl);
+
+                if (string.IsNullOrEmpty(webRequestUrl))
+                {
+                    cQuickActionStatusMonitorModel.cQuickActionStep.SetQuickActionStepStatuses(StatusMonitor.QuickActionData.ActionSteps, LocalQuickAction.Name, cQuickActionStatusMonitorModel.cQuickActionStep.enumActionStepType.main, enumQuickActionRevisionStatus.canceled);
+                    cQuickActionStatusMonitorModel.cQuickActionStep.SetQuickActionStepStatuses(StatusMonitor.QuickActionData.ActionSteps, LocalQuickAction.Name, cQuickActionStatusMonitorModel.cQuickActionStep.enumActionStepType.running, enumQuickActionRevisionStatus.canceled);
+
+                    return new List<object>() { cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.FinishedWithError"), _rawValueFormatter.GetDisplayValue(DateTime.UtcNow, RawValueType.DATETIME) };
+                }
+
+                cQuickActionOutput quickActionOutput = new cQuickActionOutputSingle(new cF4sdQuickActionRevision.cOutput() { ResultCode = enumQuickActionSuccess.unknown }); ;
+                cQuickActionOutput protocollOutput = new cQuickActionOutputSingle(new cF4sdQuickActionRevision.cOutput() { ResultCode = enumQuickActionSuccess.unknown }); ;
+
+
+                if (!token.IsCancellationRequested)
+                {
+                    cQuickActionStatusMonitorModel.cQuickActionStep.SetQuickActionStepStatuses(StatusMonitor.QuickActionData.ActionSteps, LocalQuickAction.Name, cQuickActionStatusMonitorModel.cQuickActionStep.enumActionStepType.main, enumQuickActionRevisionStatus.finishedSuccessfull);
+                    cQuickActionStatusMonitorModel.cQuickActionStep.SetQuickActionStepStatuses(StatusMonitor.QuickActionData.ActionSteps, LocalQuickAction.Name, cQuickActionStatusMonitorModel.cQuickActionStep.enumActionStepType.running, enumQuickActionRevisionStatus.finishedSuccessfull);
+
+                    quickActionOutput = new cQuickActionOutputSingle(new cF4sdQuickActionRevision.cOutput() { ResultCode = enumQuickActionSuccess.finished });
+
+                    if (cF4SDCockpitXmlConfig.Instance.HealthCardConfig.ProtocollLanguage != null)
+                    {
+                        string tempLang = cMultiLanguageSupport.CurrentLanguage;
+                        cMultiLanguageSupport.CurrentLanguage = cF4SDCockpitXmlConfig.Instance.HealthCardConfig.ProtocollLanguage;
+                        protocollOutput = new cQuickActionOutputSingle(new cF4sdQuickActionRevision.cOutput() { ResultCode = enumQuickActionSuccess.finished });
+                        cMultiLanguageSupport.CurrentLanguage = tempLang;
+                    }
+
+                    cQuickActionCopyData copyData = QuickActionProtocollEntry.GetCopyData(LocalQuickAction, DataProvider, false, protocollOutput, StatusMonitor.MeasureValues);
+                    F4SDProtocoll.Instance.Add(new QuickActionProtocollEntry(LocalQuickAction, copyData));
+
+                    return new List<object>() { cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.FinishedSuccessfull"), _rawValueFormatter.GetDisplayValue(DateTime.UtcNow, RawValueType.DATETIME) };
+                }
+                else
+                {
+                    cQuickActionStatusMonitorModel.cQuickActionStep.SetQuickActionStepStatuses(StatusMonitor.QuickActionData.ActionSteps, LocalQuickAction.Name, cQuickActionStatusMonitorModel.cQuickActionStep.enumActionStepType.main, enumQuickActionRevisionStatus.canceled);
+                    cQuickActionStatusMonitorModel.cQuickActionStep.SetQuickActionStepStatuses(StatusMonitor.QuickActionData.ActionSteps, LocalQuickAction.Name, cQuickActionStatusMonitorModel.cQuickActionStep.enumActionStepType.running, enumQuickActionRevisionStatus.canceled);
+
+                    quickActionOutput = new cQuickActionOutputSingle(new cF4sdQuickActionRevision.cOutput() { ResultCode = enumQuickActionSuccess.error, ErrorDescription = cMultiLanguageSupport.GetItem("QuickAction.Copy.Output.Cancel") });
+
+                    string tempLang = cMultiLanguageSupport.CurrentLanguage;
+                    if (cF4SDCockpitXmlConfig.Instance.HealthCardConfig.ProtocollLanguage != null)
+                        cMultiLanguageSupport.CurrentLanguage = cF4SDCockpitXmlConfig.Instance.HealthCardConfig.ProtocollLanguage;
+
+                    protocollOutput = new cQuickActionOutputSingle(new cF4sdQuickActionRevision.cOutput() { ResultCode = enumQuickActionSuccess.error, ErrorDescription = cMultiLanguageSupport.GetItem("QuickAction.Copy.Output.Cancel") });
+                    cQuickActionCopyData copyData = QuickActionProtocollEntry.GetCopyData(LocalQuickAction, DataProvider, false, protocollOutput, StatusMonitor.MeasureValues);
+                    F4SDProtocoll.Instance.Add(new QuickActionProtocollEntry(LocalQuickAction, copyData));
+                    cMultiLanguageSupport.CurrentLanguage = tempLang;
+
+                    return new List<object>() { cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.Canceled"), _rawValueFormatter.GetDisplayValue(DateTime.UtcNow, RawValueType.DATETIME) };
+                }
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+                return new List<object>() { cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.FinishedWithError"), _rawValueFormatter.GetDisplayValue(DateTime.UtcNow, RawValueType.DATETIME) };
+            }
+            finally
+            {
+            }
+        }
+    }
+}
--- a/FasdDesktopUi/Basics/UiActions/UiProcessSearchHistoryEntry.cs
+++ b/FasdDesktopUi/Basics/UiActions/UiProcessSearchHistoryEntry.cs
@@ -0,0 +1,82 @@
+using C4IT.Logging;
+using C4IT.MultiLanguage;
+using FasdDesktopUi.Basics.Services.RelationService;
+using System;
+using System.Diagnostics;
+using System.Reflection;
+using System.Threading.Tasks;
+using System.Windows;
+using static C4IT.Logging.cLogManager;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    internal class cUiProcessSearchHistoryEntry : cUiActionBase
+    {
+        public cSearchHistoryEntryBase HistoryEntry { get; private set; }
+
+        public cUiProcessSearchHistoryEntry(cSearchHistoryEntryBase historyEntry)
+        {
+            HistoryEntry = historyEntry;
+        }
+
+        public override async Task<bool> RunUiActionAsync(object sender, UIElement UiLocation, bool isDetailedLayout, cSupportCaseDataProvider dataProvider)
+        {
+            var CM = MethodBase.GetCurrentMethod();
+            LogMethodBegin(CM);
+            try
+            {
+                cSearchManager.Instance.ReplaceEntry(HistoryEntry, HistoryEntry);
+                HistoryEntry.SearchUiProvider.SetSearchHistoryVisibility(false);
+                if (HistoryEntry.ShouldRefresh())
+                {
+                    HistoryEntry.SearchUiProvider.ShowLoadingTextItem(cMultiLanguageSupport.GetItem("Searchbar.Refresh.Relations"));
+                    await HistoryEntry.RefreshAsync();
+                }
+
+                // todo set relationService
+                IRelationService relationService = new RelationService();
+
+                switch (HistoryEntry)
+                {
+                    case cSearchHistorySearchResultEntry SearchEntry:
+                        HistoryEntry.SearchUiProvider.SetSearchHistoryVisibility(true);
+                        HistoryEntry.SearchUiProvider.ShowSearchRelations(SearchEntry, relationService, HistoryEntry.SearchUiProvider);
+                        return true;
+                    case cSearchHistoryRelationEntry RelationEntry:
+                        string caseObjectName = RelationEntry.SelectedRelation.DisplayName;
+                        string loadingStatusText = string.Format(cMultiLanguageSupport.GetItem("Searchbar.Loading.CaseData"), caseObjectName);
+                        RelationEntry.SearchUiProvider.ShowLoadingTextItem(loadingStatusText);
+
+                        // check, if  have an active support case
+                        var supportCaseActive = dataProvider?.IsActive ?? false;
+                        if (supportCaseActive)
+                        {
+                            if (!await cSupportCaseDataProvider.SupportTicketActiveNoticeAsync())
+                            {
+                                HistoryEntry.isSeen = false;
+                                return false;
+                            }
+                        }
+                        HistoryEntry.isSeen = true;
+                        dataProvider = await cSupportCaseDataProvider.GetDataProviderForAsync(RelationEntry.Relations, RelationEntry.SelectedRelation, relationService);
+                        if (dataProvider is null)
+                        {
+                            Debug.Assert(true, "Could not start a data provider for the selected criterias.");
+                            LogEntry("Could not start a data provider for the selected criterias.", LogLevels.Error);
+                        }
+                        return false;
+                }
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+            finally
+            {
+                LogMethodEnd(CM);
+            }
+
+            return false;
+        }
+    }
+}
--- a/FasdDesktopUi/Basics/UiActions/UiProcessSearchRelationAction.cs
+++ b/FasdDesktopUi/Basics/UiActions/UiProcessSearchRelationAction.cs
@@ -0,0 +1,110 @@
+using C4IT.FASD.Base;
+using C4IT.Logging;
+using C4IT.MultiLanguage;
+using FasdDesktopUi.Basics.Services.RelationService;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Reflection;
+using System.Threading.Tasks;
+using System.Windows;
+using static C4IT.Logging.cLogManager;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    public class cUiProcessSearchRelationAction : cUiActionBase
+    {
+        private readonly List<cFasdApiSearchResultEntry> _selectedSearchResult;
+        private readonly List<cF4sdApiSearchResultRelation> _relations;
+        private readonly cF4sdApiSearchResultRelation _selectedRelation;
+        private readonly IRelationService _relationService;
+        private readonly ISearchUiProvider _searchUiProvider;
+        private readonly cSearchHistoryEntryBase _searchHistoryEntry;
+
+        public cUiProcessSearchRelationAction(cSearchHistorySearchResultEntry searchHistoryEntry, cF4sdApiSearchResultRelation selectedRelation, IRelationService relationService, ISearchUiProvider searchUiProvider)
+        {
+            Name = $"{searchHistoryEntry.HeaderText} → {selectedRelation.DisplayName}";
+            _selectedSearchResult = searchHistoryEntry.SelectedSearchResult;
+            _relations = searchHistoryEntry.Relations;
+            _selectedRelation = selectedRelation;
+            _relationService = relationService;
+            _searchUiProvider = searchUiProvider;
+            _searchHistoryEntry = searchHistoryEntry;
+        }
+
+        public cUiProcessSearchRelationAction(string name, List<cFasdApiSearchResultEntry> selectedSearchResult, List<cF4sdApiSearchResultRelation> relations, cF4sdApiSearchResultRelation selectedRelation, ISearchUiProvider searchUiProvider, cSearchHistoryEntryBase searchHistoryEntry)
+        {
+            Name = name;
+            _selectedSearchResult = selectedSearchResult;
+            _relations = relations;
+            _selectedRelation = selectedRelation;
+            _searchUiProvider = searchUiProvider;
+            _searchHistoryEntry = searchHistoryEntry;
+        }
+
+        public override async Task<bool> RunUiActionAsync(object sender, UIElement UiLocation, bool isDetailedLayout, cSupportCaseDataProvider dataProvider)
+        {
+            // return false: The search action has finished, the search could be canceled
+            // return true: The search action is ongoing
+
+            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;
+                }
+
+                if (_selectedRelation == null)
+                {
+                    Debug.Assert(true, "A new support case can't be opend, if we have no selected relation or seach result");
+                    LogEntry("A new support case can't be opend, if we have no sselected relation or seach result", LogLevels.Error);
+                    return false;
+                }
+
+                // check, if  have an active support case
+                var supportCaseActive = dataProvider?.IsActive ?? false;
+
+                // create the search histroy entry
+                var _seachHistoryEntry = new cSearchHistoryRelationEntry(Name, _selectedSearchResult, _relations, _selectedRelation, _searchUiProvider);
+                cSearchManager.Instance.ReplaceEntry(_seachHistoryEntry, _searchHistoryEntry);
+
+                // show the loading information
+                string caseObjectName = _selectedRelation.DisplayName;
+                string loadingStatusText = string.Format(cMultiLanguageSupport.GetItem("Searchbar.Loading.CaseData"), caseObjectName);
+                _searchUiProvider.ShowLoadingTextItem(loadingStatusText);
+
+                // if we have an opened support case, close it immediately
+                if (supportCaseActive)
+                {
+                    if (!await cSupportCaseDataProvider.SupportTicketActiveNoticeAsync())
+                        return false;
+                }
+
+                // set the new result menu properies for loading ....
+                _seachHistoryEntry.isSeen = true;
+                // get the new data provider for the support call informations (get it from the cache or create a new one)
+                dataProvider = await cSupportCaseDataProvider.GetDataProviderForAsync(_relations, _selectedRelation, _relationService);
+
+                if (dataProvider is null)
+                {
+                    Debug.Assert(true, "Could not start a data provider for the selected criterias.");
+                    LogEntry("Could not start a data provider for the selected criterias.", LogLevels.Error);
+                }
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+            finally
+            {
+                LogMethodEnd(CM);
+            }
+
+            return false;
+        }
+    }
+}
--- a/FasdDesktopUi/Basics/UiActions/UiProcessSearchResultAction.cs
+++ b/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);
+            }
+        }
+    }
+
+}
--- a/FasdDesktopUi/Basics/UiActions/UiQuickAction.cs
+++ b/FasdDesktopUi/Basics/UiActions/UiQuickAction.cs
@@ -0,0 +1,117 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Markup;
+using System.Windows.Media;
+using System.Windows.Threading;
+
+using FasdCockpitBase.Models;
+using FasdDesktopUi.Basics.Models;
+using FasdDesktopUi.Basics.UserControls;
+using FasdDesktopUi.Basics.UserControls.AdaptableIcon;
+
+using C4IT.FASD.Base;
+using static C4IT.Logging.cLogManager;
+using C4IT.Logging;
+using C4IT.F4SD.DisplayFormatting;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    public abstract class cUiQuickAction : cUiActionBase
+    {
+        private readonly bool shouldRunImmidiate = false;
+
+        protected readonly IRawValueFormatter _rawValueFormatter = new RawValueFormatter();
+
+        public cFasdQuickAction QuickActionConfig { get; private set; }
+
+        public cSupportCaseDataProvider DataProvider { get; set; }
+
+        public QuickActionStatusMonitor StatusMonitor { get; set; }
+
+        public cRecommendationDataModel QuickActionRecommendation { get; set; }
+
+
+        public cUiQuickAction(cFasdQuickAction QuickActionConfig)
+        {
+            try
+            {
+                if (QuickActionConfig is null)
+                    return;
+
+                _rawValueFormatter.SetDefaultCulture(new System.Globalization.CultureInfo(cFasdCockpitConfig.Instance.SelectedLanguage));
+
+                shouldRunImmidiate = QuickActionConfig.RunImmediate;
+                Description = QuickActionConfig.Descriptions?.GetValue(Default: null);
+                AlternativeDescription = QuickActionConfig.AlternativeDescriptions?.GetValue(Default: null);
+                this.QuickActionConfig = QuickActionConfig;
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+        }
+
+        public virtual async Task<cQuickActionStatusMonitorModel> GetQuickActionStatusMonitorDataAsync()
+        {
+            await Task.CompletedTask;
+            return new cQuickActionStatusMonitorModel();
+        }
+
+        public abstract Task<cDataCanvasDataModel> GetQuickActionDataAsync(cSupportCaseDataProvider dataProvider, bool isDetailedLayout);
+
+        public abstract Task<List<object>> ProcessActionAsync(CancellationToken token, Dictionary<cAdjustableParameter, object> ParameterDictionary = null);
+
+        private void DrawUiActionControls(cDataCanvasDataModel quickActionData, UIElement UiLocation, bool isDetailedLayout)
+        {
+            if (!(UiLocation is Decorator decorator))
+                return;
+
+            if (decorator.Child is DataCanvas existinDataCanvas)
+            {
+                existinDataCanvas.DataCanvasData = quickActionData;
+                existinDataCanvas.DataProvider = DataProvider;
+                existinDataCanvas.IsDetailedLayout = isDetailedLayout;
+                StatusMonitor = existinDataCanvas.QuickActionStatusUc;
+                existinDataCanvas.Visibility = Visibility.Visible;
+            }
+            else
+            {
+                DataCanvas dataCanvas = new DataCanvas(isDetailedLayout) { DataCanvasData = quickActionData, IsDetailedLayout = isDetailedLayout, DataProvider = DataProvider };
+                decorator.Child = dataCanvas;
+                StatusMonitor = dataCanvas.QuickActionStatusUc;
+            }
+
+            StatusMonitor.ExecuteButton.IsHitTestVisible = true;
+            decorator.Visibility = Visibility.Visible;
+        }
+
+        public override async Task<bool> RunUiActionAsync(object sender, UIElement UiLocation, bool isDetailedLayout, cSupportCaseDataProvider dataProvider)
+        {
+            try
+            {
+                var quickActionData = await GetQuickActionDataAsync(dataProvider, isDetailedLayout);
+                DrawUiActionControls(quickActionData, UiLocation, isDetailedLayout);
+
+                if (shouldRunImmidiate)
+                    if (UiLocation is Decorator uiDecorator)
+                        if (uiDecorator.Child is DataCanvas dataCanvas)
+                            await dataCanvas.QuickActionStatusUc.RunQuickActionAsync();
+                return true;
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+
+            return false;
+        }
+    }
+}
--- a/FasdDesktopUi/Basics/UiActions/UiQuickTipAction.cs
+++ b/FasdDesktopUi/Basics/UiActions/UiQuickTipAction.cs
@@ -0,0 +1,147 @@
+using C4IT.FASD.Base;
+using F4SD_AdaptableIcon;
+using FasdDesktopUi.Basics.Converter;
+using FasdDesktopUi.Basics.Enums;
+using FasdDesktopUi.Basics.Helper;
+using FasdDesktopUi.Basics.Models;
+using FasdDesktopUi.Basics.UserControls.QuickTip;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows;
+using static C4IT.Logging.cLogManager;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    public class cUiQuickTipAction : cUiActionBase
+    {
+        public cSupportCaseDataProvider DataProvider { get; set; }
+
+        private readonly cFasdQuickTip _quickTip;
+
+        private readonly List<cUiQuickTipElement> _quickTipElements = new List<cUiQuickTipElement>();
+
+        public cUiQuickTipAction(cFasdQuickTip quickTip)
+        {
+            _quickTip = quickTip;
+        }
+
+        public override Task<bool> RunUiActionAsync(object sender, UIElement UiLocation, bool isDetailedLayout, cSupportCaseDataProvider dataProvider)
+        {
+            try
+            {
+                if (!(UiLocation is QuickTipStatusMonitor quickTipStatusMonitor))
+                    return Task.FromResult(false);
+
+                DataProvider = dataProvider;
+
+                CreateElementData();
+
+                quickTipStatusMonitor.QuickTipElementData = _quickTipElements;
+
+                quickTipStatusMonitor.QuickTipName = _quickTip.Names.GetValue();
+
+                if (_quickTip.Icon is null)
+                    quickTipStatusMonitor.QuickTipIcon = new IconData(MaterialIcons.MaterialIconType.ic_lightbulb_outline);
+                else
+                    quickTipStatusMonitor.QuickTipIcon = IconDataConverter.Convert(_quickTip.Icon);
+
+                quickTipStatusMonitor.Visibility = Visibility.Visible;
+
+                return Task.FromResult(true);
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+            return Task.FromResult(false);
+        }
+
+        private void CreateElementData()
+        {
+            _quickTipElements.Clear();
+
+            foreach (cQuickTipElement element in _quickTip.QuickTipElements)
+            {
+                switch (element)
+                {
+                    case cManualStep manualStep:
+                        _quickTipElements.Add(new cUiQuickTipElement(manualStep, enumQuickTipElementType.Manual, DataProvider));
+                        break;
+                    case cAutomatedStep automatedStep:
+                        _quickTipElements.Add(new cUiQuickTipElement(automatedStep, enumQuickTipElementType.Automated, DataProvider));
+                        break;
+                    case cTextElement textElement:
+                        _quickTipElements.Add(new cUiQuickTipElement(textElement, enumQuickTipElementType.Text, DataProvider));
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+
+        public class cUiQuickTipElement
+        {
+            public enumQuickTipElementType ElementType { get; set; }
+
+            public string ElementName { get; set; }
+
+            public string TextBlock { get; set; }
+
+            public bool IsRequired { get; set; }
+
+            public IconData Icon { get; set; }
+
+            public cQuickTipElement QuickTipElementDefinition { get; set; }
+
+            public cUiActionBase StepUiAction { get; set; }
+
+            public cSupportCaseDataProvider DataProvider { get; set; }
+
+            public cUiQuickTipElement(cSupportCaseDataProvider dataProvider)
+            {
+                DataProvider = dataProvider;
+            }
+
+            public cUiQuickTipElement(cQuickTipElement element, enumQuickTipElementType type, cSupportCaseDataProvider dataProvider)
+            {
+                DataProvider = dataProvider;
+                ElementType = type;
+                QuickTipElementDefinition = element;
+                ElementName = element.Names.GetValue();
+                TextBlock = element.TextBlocks.GetValue();
+                IsRequired = element.IsRequired;
+
+                if (element is cTextElement)
+                    return;
+
+                if (element is cAutomatedStep automatedStep)
+                    SetValues(automatedStep);
+
+                if (element is cManualStep manualStep)
+                    SetValues(manualStep);
+            }
+
+            private void SetValues(cAutomatedStep automatedStep)
+            {
+                cF4SDCockpitXmlConfig.Instance.MenuItems.TryGetValue(automatedStep.QuickAction, out cFasdBaseConfigMenuItem test);
+
+                MenuItemDataProvider _menuDataProvider = new MenuItemDataProvider(DataProvider);
+
+                cMenuDataBase uiAction = _menuDataProvider.GetMenuItemData()
+                    .Where(data => automatedStep.QuickAction == data.UiAction.Name && data.UiAction.DisplayType != enumActionDisplayType.hidden)
+                    .FirstOrDefault();
+
+                if (uiAction != null && uiAction.UiAction is cUiQuickAction elementQuickAction)
+                    StepUiAction = elementQuickAction;
+            }
+
+            private void SetValues(cManualStep manualStep)
+            {
+                StepUiAction = new cShowRecommendationAction(ElementName, manualStep.Summaries.GetValue());
+                Icon = IconDataConverter.Convert(manualStep.Icon);
+            }
+        }
+    }
+}
--- a/FasdDesktopUi/Basics/UiActions/UiRemoteQuickAction.cs
+++ b/FasdDesktopUi/Basics/UiActions/UiRemoteQuickAction.cs
@@ -0,0 +1,336 @@
+using C4IT.F4SD.DisplayFormatting;
+using C4IT.FASD.Base;
+using C4IT.FASD.Cockpit.Communication;
+using C4IT.Logging;
+using C4IT.MultiLanguage;
+using FasdCockpitBase.Models;
+using FasdDesktopUi.Basics.Models;
+using FasdDesktopUi.Basics.Services.ProtocollService;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using static C4IT.Logging.cLogManager;
+
+using static FasdDesktopUi.Basics.Models.cQuickActionStatusMonitorModel.cQuickActionStep;
+using static FasdDesktopUi.Basics.UserControls.QuickActionStatusMonitor;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    public class cUiRemoteQuickAction : cUiQuickAction
+    {
+        public cF4sdQuickActionRemote RemoteQuickAction { get; set; }
+
+        public cUiRemoteQuickAction(cF4sdQuickActionRemote quickAction) : base(quickAction)
+        {
+            RemoteQuickAction = quickAction;
+        }
+
+        public async override Task<cQuickActionStatusMonitorModel> GetQuickActionStatusMonitorDataAsync()
+        {
+            var scriptInfos = await cFasdCockpitCommunicationBase.Instance.GetQuickActionOfAgent(RemoteQuickAction.AgentScriptId);
+
+            var actionSteps = new List<cQuickActionStatusMonitorModel.cQuickActionStep>() { new cQuickActionStatusMonitorModel.cQuickActionStep(cMultiLanguageSupport.GetItem("QuickAction.Remote.Connect"), RemoteQuickAction.Name, enumActionStepType.connectingToClient) };
+            if (scriptInfos.UserPermissionRequired)
+                actionSteps.Add(new cQuickActionStatusMonitorModel.cQuickActionStep(cMultiLanguageSupport.GetItem("QuickAction.Remote.UserAcceptance"), RemoteQuickAction.Name, enumActionStepType.waitingForUserAcceptance));
+
+            actionSteps.Add(new cQuickActionStatusMonitorModel.cQuickActionStep(cMultiLanguageSupport.GetItem("QuickAction.Remote.Running"), RemoteQuickAction.Name, enumActionStepType.running));
+
+            return new cQuickActionStatusMonitorModel()
+            {
+                ActionName = RemoteQuickAction.Names.GetValue(),
+                QuickActionDefinition = RemoteQuickAction,
+                RequiresUserPermission = scriptInfos != null && scriptInfos.UserPermissionRequired,
+                ActionSteps = actionSteps,
+                QuickActionParameters = RemoteQuickAction.AdjustableParameters,
+                RunQuickAction = ProcessActionAsync
+            };
+        }
+
+        public override async Task<cDataCanvasDataModel> GetQuickActionDataAsync(cSupportCaseDataProvider dataProvider, bool isDetailedLayout)
+        {
+            DataProvider = dataProvider;
+
+            var detailedData = new cDetailedDataModel() { Heading = cMultiLanguageSupport.GetItem("DetailsPage.History") };
+
+            //Get QuickAciton Data
+            if (isDetailedLayout)
+            {
+                detailedData.FullDetailedData = new List<object>() { new List<object>() { "Status", cMultiLanguageSupport.GetItem("QuickAction.Revision.ExecutionTime") } };
+                var quickActionHistory = await dataProvider.QuickActionProtocollHelper.GetQuickActionHistoryAsync(RemoteQuickAction.Name);
+                foreach (var quickActionLine in quickActionHistory)
+                {
+                    quickActionLine[1] = _rawValueFormatter.GetDisplayValue(quickActionLine[1], RawValueType.DATETIME);
+                    detailedData.FullDetailedData.Add(quickActionLine);
+                }
+            }
+            else
+                detailedData.FullDetailedData = new List<object>();
+
+            //Get Process Steps of Action
+            var quickActionData = await GetQuickActionStatusMonitorDataAsync();
+
+            //Get Recommendation
+            cRecommendationDataModel recommendationData = QuickActionRecommendation?.Recommendation != null ? QuickActionRecommendation : null;
+
+            return new cDataCanvasDataModel() { DetailedData = detailedData, QuickActionStatusMonitorData = quickActionData, RecommendationData = recommendationData };
+        }
+
+        public override async Task<List<object>> ProcessActionAsync(CancellationToken token, Dictionary<cAdjustableParameter, object> ParameterDictionary = null)
+        {
+            try
+            {
+                int agentDeviceId = int.MinValue;
+                int? agentUserIdNullable = null;
+                var startTime = DateTime.UtcNow;
+
+                if (DataProvider.NamedParameterEntries.TryGetValue("AgentDeviceId", out var agentDeviceIdParameter))
+                    _ = int.TryParse(agentDeviceIdParameter.GetValue(), out agentDeviceId);
+
+                if (RemoteQuickAction.InformationClasses.Contains(enumFasdInformationClass.User))
+                    if (DataProvider.NamedParameterEntries.TryGetValue("AgentUserId", out var agentUserIdParameter))
+                        if (int.TryParse(agentUserIdParameter.GetValue(), out int agentUserId))
+                            agentUserIdNullable = agentUserId;
+
+                //todo: task of DataProviderBase?
+                var QuickActionResult = new cF4sdQuickActionRevision();
+                if (cCockpitConfiguration.Instance.agentApiConfiguration.OrganizationCode != null)
+                {
+                    var parameters = cExternalToolExecutorEnh.ReplaceParameters(RemoteQuickAction.Parameters, DataProvider.NamedParameterEntries.ToInterfaceDictionary(), false, ParameterDictionary);
+
+                    var scriptInformation = await cFasdCockpitCommunicationBase.Instance.RunAgentScript(RemoteQuickAction, cCockpitConfiguration.Instance.agentApiConfiguration.OrganizationCode.Value, agentDeviceId, agentUserIdNullable, parameters);
+                    await UpdateQuickActionStatusAsync(scriptInformation.TaskId, token);
+                    QuickActionResult = await GetRevisionForStatusMonitorAsync(scriptInformation.RevisionId, scriptInformation.TaskId, token);
+
+                    if (QuickActionResult != null && QuickActionResult.Status is enumQuickActionRevisionStatus.finishedWithError)
+                    {
+                        if (QuickActionResult.Output == null)
+                            QuickActionResult.Output = new cF4sdQuickActionRevision.cOutput() { ErrorCode = 1, ErrorDescription = QuickActionResult.OutputText };
+                        if (QuickActionResult.Output.ErrorCode == null && QuickActionResult.Output.ResultCode == 0 && QuickActionResult.Output.ErrorDescription == null && !string.IsNullOrEmpty(QuickActionResult.OutputText))
+                            QuickActionResult.Output.ErrorDescription = QuickActionResult.OutputText;
+                    }
+                }
+
+                if (QuickActionResult == null)
+                    QuickActionResult = new cF4sdQuickActionRevision() { Status = enumQuickActionRevisionStatus.finishedWithError, OutputText = cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.Canceled") };
+
+                if (QuickActionResult.Measures?.Count > 0)
+                {
+                    var StatusMonitorMeasureValues = GetStatusMonitorMeasureValues(QuickActionResult.Measures, RemoteQuickAction.QuickActionMeasures);
+
+                    if (StatusMonitorMeasureValues?.Count > 0)
+                        StatusMonitor.MeasureValues = StatusMonitorMeasureValues;
+                }
+
+                var quickActionOutput = cQuickActionOutput.GetQuickActionOutput(QuickActionResult.Output, DataProvider);
+                var protocollOutput = cQuickActionOutput.GetQuickActionOutput(QuickActionResult.Output, DataProvider);
+
+                if (!token.IsCancellationRequested)
+                {
+                    StatusMonitor.QuickActionOutputs.Add(QuickActionResult.Output);
+                    var status = quickActionOutput?.IsError == true ? enumQuickActionRevisionStatus.finishedWithError : QuickActionResult.Status;
+
+                    cQuickActionStatusMonitorModel.cQuickActionStep.SetQuickActionStepStatuses(StatusMonitor.QuickActionData.ActionSteps, RemoteQuickAction.Name, enumActionStepType.running, status);
+                    cQuickActionStatusMonitorModel.cQuickActionStep.SetQuickActionStepStatuses(StatusMonitor.QuickActionData.ActionSteps, RemoteQuickAction.Name, enumActionStepType.main, status);
+
+                    cQuickActionCopyData copyData = QuickActionProtocollEntry.GetCopyData(RemoteQuickAction, DataProvider, true, protocollOutput, StatusMonitor.MeasureValues);
+                    F4SDProtocoll.Instance.Add(new QuickActionProtocollEntry(RemoteQuickAction, copyData));
+
+                }
+                else
+                {
+                    cQuickActionStatusMonitorModel.cQuickActionStep.CancelRemainingQuickActionSteps(StatusMonitor.QuickActionData.ActionSteps);
+
+                    quickActionOutput = new cQuickActionOutputSingle(new cF4sdQuickActionRevision.cOutput() { ResultCode = enumQuickActionSuccess.error, ErrorDescription = cMultiLanguageSupport.GetItem("QuickAction.Copy.Output.Cancel") });
+
+                    if (cF4SDCockpitXmlConfig.Instance.HealthCardConfig.ProtocollLanguage != null)
+                    {
+                        string tempLang = cMultiLanguageSupport.CurrentLanguage;
+                        cMultiLanguageSupport.CurrentLanguage = cF4SDCockpitXmlConfig.Instance.HealthCardConfig.ProtocollLanguage;
+                        protocollOutput = new cQuickActionOutputSingle(new cF4sdQuickActionRevision.cOutput() { ResultCode = enumQuickActionSuccess.error, ErrorDescription = cMultiLanguageSupport.GetItem("QuickAction.Copy.Output.Cancel") });
+                        cMultiLanguageSupport.CurrentLanguage = tempLang;
+                    }
+
+                    cQuickActionCopyData copyData = QuickActionProtocollEntry.GetCopyData(RemoteQuickAction, DataProvider, true, protocollOutput, StatusMonitor.MeasureValues);
+                    F4SDProtocoll.Instance.Add(new QuickActionProtocollEntry(RemoteQuickAction, copyData));
+                    return new List<object>() { cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.Canceled"), _rawValueFormatter.GetDisplayValue(DateTime.UtcNow, RawValueType.DATETIME) };
+                }
+
+                string quickActionStatus;
+                switch (QuickActionResult.Status)
+                {
+                    case enumQuickActionRevisionStatus.inProgress:
+                        quickActionStatus = cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.InProgress");
+                        break;
+                    case enumQuickActionRevisionStatus.finishedSuccessfull:
+                        quickActionStatus = cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.FinishedSuccessfull");
+                        break;
+                    case enumQuickActionRevisionStatus.finishedWithError:
+                        quickActionStatus = cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.FinishedWithError");
+                        break;
+                    case enumQuickActionRevisionStatus.unknown:
+                    default:
+                        quickActionStatus = cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.Unknown");
+                        break;
+                }
+
+                _ = Task.Run(async () =>
+                {
+                    try
+                    {
+                        Guid? userId = DataProvider?.Identities?.FirstOrDefault(identity => identity.Class == enumFasdInformationClass.User)?.Id;
+                        Guid? computerId = DataProvider?.Identities?.FirstOrDefault(identity => identity.Class == enumFasdInformationClass.Computer)?.Id;
+
+                        var reportQuickActionParameter = new cF4SDQuickActionParameters()
+                        {
+                            CaseId = DataProvider.CaseId,
+                            QuickActionId = RemoteQuickAction.Id,
+                            QuickActionName = RemoteQuickAction.Name,
+                            Paramaters = ParameterDictionary is null ? null : JsonConvert.SerializeObject(ParameterDictionary, Formatting.None),
+                            Result = QuickActionResult.Output.Values is null ? null : JsonConvert.SerializeObject(QuickActionResult.Output.Values, Formatting.None),
+                            ErrorCode = QuickActionResult.Output.ErrorCode,
+                            ErrorDescription = QuickActionResult.Output.ErrorDescription,
+                            Start = startTime,
+                            Finish = DateTime.UtcNow,
+                            UserId = userId,
+                            DeviceId = computerId,
+                            ExecutionType = RemoteQuickAction.ExecutionType,
+                            ResultType = RemoteQuickAction.ResultType
+                        };
+
+                        var reportedQuickActionSuccessfully = await cFasdCockpitCommunicationBase.Instance.ReportQuickAction(reportQuickActionParameter);
+
+                        if (reportedQuickActionSuccessfully is false)
+                            LogEntry($"Failed to report QuickAction '{RemoteQuickAction.Name}' for case '{reportQuickActionParameter.CaseId}' to Analytics.", LogLevels.Warning);
+                    }
+                    catch (Exception E)
+                    {
+                        LogException(E);
+                    }
+                });
+
+                return new List<object>() { quickActionStatus, _rawValueFormatter.GetDisplayValue(DateTime.UtcNow, RawValueType.DATETIME) };
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+                return new List<object>() { cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.FinishedWithError"), _rawValueFormatter.GetDisplayValue(DateTime.UtcNow, RawValueType.DATETIME) };
+            }
+
+        }
+
+        public static List<cQuickActionMeasureValue> GetStatusMonitorMeasureValues(List<cF4sdQuickActionRevision.cMeasure> measures, Dictionary<int, cF4sdQuickActionMeasure> QuickActionMeasures)
+        {
+            try
+            {
+                var output = new List<cQuickActionMeasureValue>();
+
+                if (QuickActionMeasures == null || measures == null)
+                    return null;
+
+                foreach (var measure in measures)
+                {
+                    if (!QuickActionMeasures.TryGetValue(measure.Id, out var measureDefinition))
+                        continue;
+
+                    output.Add(new cQuickActionMeasureValue()
+                    {
+                        Id = measure.Id,
+                        Names = measureDefinition.Names,
+                        Display = cUtility.GetRawValueType(measureDefinition.Display),
+                        Value = measure.Value,
+                        PostValue = measure.PostValue
+                    });
+                }
+
+                return output;
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+            finally
+            {
+            }
+
+            return null;
+        }
+
+        private async Task UpdateQuickActionStatusAsync(int taskId, CancellationToken token)
+        {
+            try
+            {
+                const int pollDelayInMilliseconds = 250;
+
+                while (!token.IsCancellationRequested)
+                {
+                    var quickActionStatus = await cFasdCockpitCommunicationBase.Instance.GetAgentQuickActionStatus(taskId);
+
+                    if (quickActionStatus == enumQuickActionStatus.Unknown)
+                        break;
+
+                    List<enumActionStepType> actionStepsToUpdate = new List<enumActionStepType>();
+
+                    switch (quickActionStatus)
+                    {
+                        case enumQuickActionStatus.ConnectingToClient:
+                            break;
+                        case enumQuickActionStatus.WaitingForUserAcceptance:
+                            actionStepsToUpdate = new List<enumActionStepType>() { enumActionStepType.connectingToClient };
+                            break;
+                        case enumQuickActionStatus.Running:
+                        case enumQuickActionStatus.Finished:
+                            actionStepsToUpdate = new List<enumActionStepType>() { enumActionStepType.connectingToClient, enumActionStepType.waitingForUserAcceptance };
+                            break;
+                        case enumQuickActionStatus.Cancelled:
+                            var remainingSteps = StatusMonitor.QuickActionData.ActionSteps.Where(step => step.Status != enumQuickActionRevisionStatus.finishedSuccessfull);
+
+                            foreach (var remainingStep in remainingSteps)
+                            {
+                                remainingStep.Status = enumQuickActionRevisionStatus.canceled;
+                            }
+                            break;
+                    }
+
+                    foreach (var actionStepToUpdate in actionStepsToUpdate)
+                    {
+                        cQuickActionStatusMonitorModel.cQuickActionStep.SetQuickActionStepStatuses(StatusMonitor.QuickActionData.ActionSteps, RemoteQuickAction.Name, actionStepToUpdate, enumQuickActionRevisionStatus.finishedSuccessfull);
+                    }
+
+                    if (quickActionStatus == enumQuickActionStatus.Finished || quickActionStatus == enumQuickActionStatus.Cancelled)
+                        break;
+
+                    await Task.Delay(pollDelayInMilliseconds);
+                }
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+        }
+
+        private async Task<cF4sdQuickActionRevision> GetRevisionForStatusMonitorAsync(int revisionId, int taskId, CancellationToken token)
+        {
+            try
+            {
+                if (!token.IsCancellationRequested)
+                {
+                    var revision = await cFasdCockpitCommunicationBase.Instance.GetAgentRevision(revisionId, cCockpitConfiguration.Instance.agentApiConfiguration.OrganizationCode.Value);
+                    return revision;
+                }
+                else
+                    await cFasdCockpitCommunicationBase.Instance.CancelAgentTask(taskId);
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+
+            return null;
+        }
+    }
+}
--- a/FasdDesktopUi/Basics/UiActions/UiServerQuickAction.cs
+++ b/FasdDesktopUi/Basics/UiActions/UiServerQuickAction.cs
@@ -0,0 +1,261 @@
+using C4IT.F4SD.DisplayFormatting;
+using C4IT.FASD.Base;
+using C4IT.FASD.Cockpit.Communication;
+using C4IT.Logging;
+using C4IT.MultiLanguage;
+using FasdCockpitBase.Models;
+using FasdDesktopUi.Basics.Models;
+using FasdDesktopUi.Basics.Services.ProtocollService;
+using FasdDesktopUi.Basics.UserControls;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using static C4IT.Logging.cLogManager;
+using static FasdDesktopUi.Basics.UserControls.QuickActionStatusMonitor;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    public class cUiServerQuickAction : cUiQuickAction
+    {
+        public cF4sdQuickActionServer ServerQuickAction { get; set; }
+
+        public cUiServerQuickAction(cF4sdQuickActionServer quickAction) : base(quickAction)
+        {
+            ServerQuickAction = quickAction;
+            Name = quickAction.Names.GetValue();
+        }
+
+        public override async Task<cQuickActionStatusMonitorModel> GetQuickActionStatusMonitorDataAsync()
+        {
+            await Task.CompletedTask;
+
+            return new cQuickActionStatusMonitorModel()
+            {
+                ActionName = ServerQuickAction.Names.GetValue(),
+                QuickActionDefinition = ServerQuickAction,
+                ActionSteps = new List<cQuickActionStatusMonitorModel.cQuickActionStep>()
+                {
+                    new cQuickActionStatusMonitorModel.cQuickActionStep(cMultiLanguageSupport.GetItem("QuickAction.Remote.Running"), ServerQuickAction.Name, cQuickActionStatusMonitorModel.cQuickActionStep.enumActionStepType.running)
+                },
+                QuickActionParameters = ServerQuickAction.AdjustableParameters,
+                RunQuickAction = ProcessActionAsync
+            };
+        }
+
+        public override async Task<cDataCanvasDataModel> GetQuickActionDataAsync(cSupportCaseDataProvider dataProvider, bool isDetailedLayout)
+        {
+            DataProvider = dataProvider;
+
+            var detailedDataQuickActionHistory = new cDetailedDataModel()
+            {
+                Heading = cMultiLanguageSupport.GetItem("DetailsPage.History"),
+                FullDetailedData = new List<object>() { new List<object>() { "Status", cMultiLanguageSupport.GetItem("QuickAction.Revision.ExecutionTime") } }
+            };
+
+            //Get QuickAciton Data
+            if (dataProvider != null)
+            {
+                var quickActionHistory = await dataProvider.QuickActionProtocollHelper.GetQuickActionHistoryAsync(ServerQuickAction.Name);
+
+                if (quickActionHistory != null)
+                    detailedDataQuickActionHistory.FullDetailedData.AddRange(quickActionHistory);
+            }
+
+
+            //Get Process Steps of Action
+            var quickActionData = await GetQuickActionStatusMonitorDataAsync();
+
+            //Get Recommendation
+            cRecommendationDataModel recommendationData = QuickActionRecommendation?.Recommendation != null ? QuickActionRecommendation : null;
+
+            return new cDataCanvasDataModel() { DetailedData = detailedDataQuickActionHistory, QuickActionStatusMonitorData = quickActionData, RecommendationData = recommendationData };
+        }
+
+        private cF4sdQuickActionRevision GetRevisionOutput(cExternalToolExecutorEnh.cProcessResult _result)
+        {
+            var retVal = new cF4sdQuickActionRevision() { Status = enumQuickActionRevisionStatus.unknown };
+            try
+            {
+                if (!string.IsNullOrEmpty(_result.StandardOutput))
+                {
+                    retVal.OutputText = _result.StandardOutput;
+                    if (retVal.Output != null)
+                    {
+                        if (retVal.Output.ErrorCode is null || retVal.Output.ErrorCode == 0)
+                            retVal.Status = enumQuickActionRevisionStatus.finishedSuccessfull;
+                        else
+                            retVal.Status = enumQuickActionRevisionStatus.finishedWithError;
+                    }
+                }
+
+                if (retVal.Status == enumQuickActionRevisionStatus.unknown)
+                {
+                    if (_result.ReturnCode != 0 || !string.IsNullOrEmpty(_result.StandardError))
+                    {
+                        retVal.Status = enumQuickActionRevisionStatus.finishedWithError;
+                        retVal.Output = new cF4sdQuickActionRevision.cOutput()
+                        {
+                            ErrorCode = _result.ReturnCode,
+                            ErrorDescription = _result.StandardError
+                        };
+                    }
+                    else
+                        retVal.Status = enumQuickActionRevisionStatus.finishedSuccessfull;
+                }
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+
+            return retVal;
+        }
+
+        public override async Task<List<object>> ProcessActionAsync(CancellationToken token, Dictionary<cAdjustableParameter, object> ParameterDictionary = null)
+        {
+            try
+            {
+                var startTime = DateTime.UtcNow;
+
+                var _actionResult = await Task.Run(async () => { return await cExternalToolExecutorEnh.StartServerActionAsync(ServerQuickAction, DataProvider, cMultiLanguageSupport.GetItem("RemoteTool.Credentials.PasswordRequest"), ParameterDictionary); });
+
+                cQuickActionOutput quickActionOutput = new cQuickActionOutputSingle(new cF4sdQuickActionRevision.cOutput() { ResultCode = enumQuickActionSuccess.unknown }); ;
+                cQuickActionOutput protocollOutput = new cQuickActionOutputSingle(new cF4sdQuickActionRevision.cOutput() { ResultCode = enumQuickActionSuccess.unknown }); ;
+
+                List<object> output = new List<object>();
+
+                if (!token.IsCancellationRequested)
+                {
+                    var ResultRevision = GetRevisionOutput(_actionResult);
+
+                    cQuickActionStatusMonitorModel.cQuickActionStep.SetQuickActionStepStatuses(StatusMonitor.QuickActionData.ActionSteps, ServerQuickAction.Name, cQuickActionStatusMonitorModel.cQuickActionStep.enumActionStepType.running, enumQuickActionRevisionStatus.finishedSuccessfull);
+                    cQuickActionStatusMonitorModel.cQuickActionStep.SetQuickActionStepStatuses(StatusMonitor.QuickActionData.ActionSteps, ServerQuickAction.Name, cQuickActionStatusMonitorModel.cQuickActionStep.enumActionStepType.main, enumQuickActionRevisionStatus.finishedSuccessfull);
+
+                    if (!string.IsNullOrEmpty(_actionResult.StandardOutput))
+                        try
+                        {
+                            dynamic retValue = Newtonsoft.Json.JsonConvert.DeserializeObject(_actionResult.StandardOutput);
+                            var _output = new cF4sdQuickActionRevision.cOutput()
+                            {
+                                ResultCode = enumQuickActionSuccess.finished,
+                                Values = retValue
+                            };
+
+                            ResultRevision.OutputText = JsonConvert.SerializeObject(_output);
+                        }
+                        catch { }
+
+                    if (ResultRevision.Output == null)
+                        quickActionOutput = new cQuickActionOutputSingle(new cF4sdQuickActionRevision.cOutput() { ResultCode = enumQuickActionSuccess.finished });
+                    else
+                    {
+                        StatusMonitor.QuickActionOutputs.Add(ResultRevision.Output);
+
+                        quickActionOutput = cQuickActionOutput.GetQuickActionOutput(ResultRevision.Output, DataProvider);
+                    }
+
+                    if (cF4SDCockpitXmlConfig.Instance.HealthCardConfig.ProtocollLanguage != null)
+                    {
+                        string tempLang = cMultiLanguageSupport.CurrentLanguage;
+                        cMultiLanguageSupport.CurrentLanguage = cF4SDCockpitXmlConfig.Instance.HealthCardConfig.ProtocollLanguage;
+                        if (ResultRevision.Output == null)
+                            protocollOutput = new cQuickActionOutputSingle(new cF4sdQuickActionRevision.cOutput() { ResultCode = enumQuickActionSuccess.finished });
+                        else
+                            protocollOutput = cQuickActionOutput.GetQuickActionOutput(ResultRevision.Output, DataProvider);
+                        cMultiLanguageSupport.CurrentLanguage = tempLang;
+                    }
+
+                    cQuickActionCopyData copyData = QuickActionProtocollEntry.GetCopyData(ServerQuickAction, DataProvider, false, protocollOutput, StatusMonitor.MeasureValues);
+                    F4SDProtocoll.Instance.Add(new QuickActionProtocollEntry(ServerQuickAction, copyData));
+
+                    string quickActionStatus;
+                    switch (ResultRevision.Status)
+                    {
+                        case enumQuickActionRevisionStatus.inProgress:
+                            quickActionStatus = cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.InProgress");
+                            break;
+                        case enumQuickActionRevisionStatus.finishedSuccessfull:
+                            quickActionStatus = cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.FinishedSuccessfull");
+                            break;
+                        case enumQuickActionRevisionStatus.finishedWithError:
+                            quickActionStatus = cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.FinishedWithError");
+                            break;
+                        case enumQuickActionRevisionStatus.unknown:
+                        default:
+                            quickActionStatus = cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.Unknown");
+                            break;
+                    }
+
+                    output = new List<object>() { quickActionStatus, _rawValueFormatter.GetDisplayValue(DateTime.UtcNow, RawValueType.DATETIME) };
+                }
+                else
+                {
+                    cQuickActionStatusMonitorModel.cQuickActionStep.SetQuickActionStepStatuses(StatusMonitor.QuickActionData.ActionSteps, ServerQuickAction.Name, cQuickActionStatusMonitorModel.cQuickActionStep.enumActionStepType.main, enumQuickActionRevisionStatus.canceled);
+                    cQuickActionStatusMonitorModel.cQuickActionStep.SetQuickActionStepStatuses(StatusMonitor.QuickActionData.ActionSteps, ServerQuickAction.Name, cQuickActionStatusMonitorModel.cQuickActionStep.enumActionStepType.running, enumQuickActionRevisionStatus.canceled);
+
+                    quickActionOutput = new cQuickActionOutputSingle(new cF4sdQuickActionRevision.cOutput() { ResultCode = enumQuickActionSuccess.error, ErrorDescription = cMultiLanguageSupport.GetItem("QuickAction.Copy.Output.Cancel") });
+
+                    if (cF4SDCockpitXmlConfig.Instance.HealthCardConfig.ProtocollLanguage != null)
+                    {
+                        string tempLang = cMultiLanguageSupport.CurrentLanguage;
+                        cMultiLanguageSupport.CurrentLanguage = cF4SDCockpitXmlConfig.Instance.HealthCardConfig.ProtocollLanguage;
+                        protocollOutput = new cQuickActionOutputSingle(new cF4sdQuickActionRevision.cOutput() { ResultCode = enumQuickActionSuccess.error, ErrorDescription = cMultiLanguageSupport.GetItem("QuickAction.Copy.Output.Cancel") });
+                        cMultiLanguageSupport.CurrentLanguage = tempLang;
+                    }
+
+                    cQuickActionCopyData copyData = QuickActionProtocollEntry.GetCopyData(ServerQuickAction, DataProvider, false, protocollOutput, StatusMonitor.MeasureValues);
+                    F4SDProtocoll.Instance.Add(new QuickActionProtocollEntry(ServerQuickAction, copyData));
+
+                    output = new List<object>() { cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.Canceled"), _rawValueFormatter.GetDisplayValue(DateTime.UtcNow, RawValueType.DATETIME) };
+                }
+
+                _ = Task.Run(async () =>
+                {
+                    try
+                    {
+                        Guid? userId = DataProvider?.Identities?.FirstOrDefault(identity => identity.Class == enumFasdInformationClass.User)?.Id;
+                        Guid? computerId = DataProvider?.Identities?.FirstOrDefault(identity => identity.Class == enumFasdInformationClass.Computer)?.Id;
+
+                        var reportQuickActionParameter = new cF4SDQuickActionParameters()
+                        {
+                            CaseId = DataProvider.CaseId,
+                            QuickActionId = ServerQuickAction.Id,
+                            QuickActionName = ServerQuickAction.Name,
+                            Paramaters = ParameterDictionary is null ? null : JsonConvert.SerializeObject(ParameterDictionary, Formatting.None),
+                            Result = JsonConvert.SerializeObject(quickActionOutput.ResultCode.GetValueOrDefault().ToString(), Formatting.None),
+                            ErrorCode = quickActionOutput.ErrorCode,
+                            ErrorDescription = quickActionOutput.ErrorDescription,
+                            Start = startTime,
+                            Finish = DateTime.UtcNow,
+                            UserId = userId,
+                            DeviceId = computerId,
+                            ExecutionType = ServerQuickAction.ExecutionType,
+                            ResultType = ServerQuickAction.ResultType
+                        };
+
+                        var reportedQuickActionSuccessfully = await cFasdCockpitCommunicationBase.Instance.ReportQuickAction(reportQuickActionParameter);
+
+                        if (reportedQuickActionSuccessfully is false)
+                            LogEntry($"Failed to report QuickAction '{ServerQuickAction.Name}' for case '{reportQuickActionParameter.CaseId}' to Analytics.", LogLevels.Warning);
+                    }
+                    catch (Exception E)
+                    {
+                        LogException(E);
+                    }
+                });
+
+                return output;
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+                return new List<object>() { cMultiLanguageSupport.GetItem("QuickAction.Revision.Status.FinishedWithError"), _rawValueFormatter.GetDisplayValue(DateTime.UtcNow, RawValueType.DATETIME) };
+            }
+        }
+    }
+}
--- a/FasdDesktopUi/Basics/UiActions/UiSystemDefaultQuickAction.cs
+++ b/FasdDesktopUi/Basics/UiActions/UiSystemDefaultQuickAction.cs
@@ -0,0 +1,51 @@
+using C4IT.FASD.Base;
+using C4IT.Logging;
+
+using FasdDesktopUi.Basics.Models;
+using FasdDesktopUi.Basics.UserControls;
+using FasdDesktopUi.Pages.CustomMessageBox;
+using FasdDesktopUi.Pages.DetailsPage;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using static C4IT.Logging.cLogManager;
+
+namespace FasdDesktopUi.Basics.UiActions
+{
+    public class cUiShowNotepadQuickAction : cUiActionBase
+    {       
+
+        public cUiShowNotepadQuickAction()
+        {
+            
+        }
+
+        public override async Task<bool> RunUiActionAsync(object sender, UIElement UiLocation, bool isDetailedLayout, cSupportCaseDataProvider dataProvider)
+        {
+            try
+            {
+                if (!(UiLocation is DetailsPageView detailsPage))
+                    return false;
+
+                detailsPage.NotepadChangeVisibilityAction(this, true);
+                return true;
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+
+            await Task.CompletedTask;
+            return false;   
+        }
+    }
+
+}
+