first commit

F4SDwebService/Controllers/CheckConnectionController.cs

@@ -0,0 +1,27 @@
+using C4IT.FASD.Base;
+using F4SDwebService;
+using System;
+using System.Web.Http;
+
+namespace FasdWebService.Controllers
+{
+    public class CheckConnectionController : ApiController
+    {
+        public IHttpActionResult Get()
+        {
+            var SupportAuthorisation = WebApiApplication.Collector?.InfrastructureConfig?.Authorisation != null;
+
+            // the use of ticket completition policy in this request is deprecated, but kept for backwards compatibility
+            var completitionPolicy = enumShowDocumentCaseDialog.ifRequired;
+            if (WebApiApplication.Collector != null)
+            {
+                var globalConfig = WebApiApplication.Collector.GetGlobalConfig();
+                completitionPolicy = globalConfig.TicketConfiguration.CompletitionPolicy;
+            }
+
+            var output = new cFasdApiConnectionInfo() { ServerVersion = cInfo.ProductVersion(), MinCockpitVersion = cInfo.MinClientVersion(), ConfigRevision = 0, SupportAuthorisation = SupportAuthorisation, WebServerStatus = WebApiApplication.Collector?.ServerStatus ?? enumWebServerStatus.starting, showDocumentCaseDialog = completitionPolicy };
+
+            return Ok(output);
+        }
+    }
+}

F4SDwebService/Controllers/F4SDAnalyticsDataController.cs

@@ -0,0 +1,280 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
+using System.Threading;
+using System.Web.Http;
+
+using C4IT.FASD.Base;
+using C4IT.Logging;
+using static C4IT.Logging.cLogManager;
+using C4IT.DataHistoryProvider;
+
+namespace F4SDwebService.Controllers
+{
+
+    public class F4SDAnalyticsDataController : ApiController
+    {
+
+        [HttpGet]
+        [Route("api/F4SDAnalytics/GetF4SDAnalyticsState")]
+        public IHttpActionResult GetF4SDAnalyticsState()
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+
+            try
+            {
+                if (!WebApiApplication.Collector.F4SDAnalyticsValid)
+                    return Ok<bool>(false);
+
+                return Ok<bool>(true);
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+            finally
+            {
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+
+        [HttpPost]
+        [Route("api/F4SDAnalytics/CreateUserSession")]
+        public async Task<IHttpActionResult> CreateUserSession([FromBody] cF4SDUserSessionParameters jsonRequest)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+            var requestInfo = new cF4sdWebRequestInfo("CreateUserSession", jsonRequest?.SessionId?.ToString());
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+            var apiError = 0;
+
+            try
+            {
+                if (!WebApiApplication.Collector.F4SDAnalyticsValid)
+                    return NotFound();
+
+                if (await WebApiApplication.Collector.CreateUserSessionAsync(jsonRequest, requestInfo, 1, CancellationToken.None))
+                    return Ok();
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+
+        [HttpPost]
+        [Route("api/F4SDAnalytics/CloseUserSession")]
+        public async Task<IHttpActionResult> CloseUserSession([FromBody] cF4SDUserSessionParameters jsonRequest)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+            var requestInfo = new cF4sdWebRequestInfo("CloseUserSession", jsonRequest?.SessionId?.ToString());
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+            var apiError = 0;
+
+            try
+            {
+                if (!WebApiApplication.Collector.F4SDAnalyticsValid)
+                    return NotFound();
+                if (await WebApiApplication.Collector.CloseUserSessionAsync(jsonRequest, requestInfo, 1 , CancellationToken.None))
+                    return Ok();
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+
+
+        [HttpPost]
+        [Route("api/F4SDAnalytics/CreateCase")]
+        public async Task<IHttpActionResult> CreateCase([FromBody] cF4SDCaseParameters jsonRequest)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+            var requestInfo = new cF4sdWebRequestInfo("CreateCase", jsonRequest?.SessionId?.ToString());
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+            var apiError = 0;
+
+            try
+            {
+                if (!WebApiApplication.Collector.F4SDAnalyticsValid)
+                {
+                    return NotFound();
+                }
+                if (await WebApiApplication.Collector.CreateCaseAsync(jsonRequest, requestInfo, 1, CancellationToken.None))
+                {
+
+                    return Ok();
+                }
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+
+        [HttpPost]
+        [Route("api/F4SDAnalytics/UpdateCaseState")]
+        public async Task<IHttpActionResult> UpdateCaseState([FromBody] cF4SDCaseTimeParameters jsonRequest)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+            var requestInfo = new cF4sdWebRequestInfo("UpdateCaseState", jsonRequest?.CaseId?.ToString());
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+            var apiError = 0;
+
+            try
+            {
+                if (!WebApiApplication.Collector.F4SDAnalyticsValid)
+                    return NotFound();
+                if (await WebApiApplication.Collector.UpdateCaseStateAsync(jsonRequest, requestInfo, 1, CancellationToken.None))
+                    return Ok();
+
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+
+        [HttpPost]
+        [Route("api/F4SDAnalytics/ReportQuickActionExecution")]
+        public async Task<IHttpActionResult> ReportQuickActionExecution([FromBody] cF4SDQuickActionParameters jsonRequest)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+            var requestInfo = new cF4sdWebRequestInfo("ReportQuickActionExecution", jsonRequest?.DeviceId?.ToString());
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+            var apiError = 0;
+
+            try
+            {
+                if (!WebApiApplication.Collector.IsValid)
+                    return NotFound();
+
+                List<Task<bool>> taskList = new List<Task<bool>>();
+
+                if (WebApiApplication.Collector.F4SDAnalyticsValid)
+                    taskList.Add(WebApiApplication.Collector.ReportQuickActionExecutionAsync(jsonRequest, WebApiApplication.Collector.InfrastructureConfig.F4SDAnalyticsDB.Connection, requestInfo, 1, CancellationToken.None));
+
+                await Task.WhenAll(taskList).ConfigureAwait(false);
+
+                if (taskList.All(taskResult => taskResult.Result.Equals(true)))
+                    return Ok();
+
+                return BadRequest();
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+
+        [HttpPost]
+        [Route("api/F4SDAnalytics/KeepAliveSession")]
+        public IHttpActionResult KeepAliveSession([FromBody] Guid SessionId)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+
+            try
+            {
+                LogEntry($"API Call KeepAliveSession: " + SessionId.ToString());
+                if (!WebApiApplication.Collector.F4SDAnalyticsValid)
+                    return NotFound();
+
+                if (WebApiApplication.Collector.KeepAliveSession(SessionId, CancellationToken.None))
+                    return Ok();
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+            finally
+            {
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+
+        [HttpPost]
+        [Route("api/F4SDAnalytics/KeepAliveCase")]
+        public async Task<IHttpActionResult> KeepAliveCase([FromBody] Guid CaseId)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+            var requestInfo = new cF4sdWebRequestInfo("KeepAliveCase", CaseId.ToString());
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+            var apiError = 0;
+
+            try
+            {
+                LogEntry($"API Call KeepAliveSession: " + CaseId.ToString());
+                if (!WebApiApplication.Collector.F4SDAnalyticsValid)
+                {
+                    return NotFound();
+                }
+                if (await WebApiApplication.Collector.KeepAliveCase(CaseId, requestInfo, 1, CancellationToken.None))
+                    return Ok();
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+
+    }
+}

F4SDwebService/Controllers/GetAgentApiConfigurationController.cs

@@ -0,0 +1,21 @@
+using C4IT.FASD.Base;
+using F4SDwebService;
+using System;
+using System.Web.Http;
+
+namespace FasdWebService.Controllers
+{
+
+    public class GetAgentApiConfigurationController : ApiController
+    {
+        public IHttpActionResult Get()
+        {
+            var AgentConfig = WebApiApplication.Collector?.InfrastructureConfig?.ClientAgent;
+            if (AgentConfig == null)
+                return NotFound();
+
+            var output = WebApiApplication.Collector.F4sdAgent.GetAgentApiConfiguration(false);
+            return Ok(output);
+        }
+    }
+}

F4SDwebService/Controllers/GetConfigurationController.cs

@@ -0,0 +1,88 @@
+using C4IT.DataHistoryProvider;
+using C4IT.FASD.Base;
+using C4IT.Logging;
+using F4SDwebService;
+using System;
+using System.Net;
+using System.Reflection;
+using System.Web.Http;
+using static C4IT.Logging.cLogManager;
+
+namespace FasdWebService.Controllers
+{
+    public class GetConfigurationController : ApiController
+    {
+        public IHttpActionResult Get(string configType)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+
+            var requestInfo = new cF4sdWebRequestInfo("GetConfiguration", configType, cAuthentication.GetUserInfo(ActionContext));
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+            var apiError = 0;
+
+            try
+            {
+                if (!Enum.TryParse(configType, true, out enumFasdConfigurationType configurationType) || configurationType == enumFasdConfigurationType.unknown)
+                {
+                    LogEntry($"Couldn't find a configuration with name '{configType}'");
+                    apiError = (int)HttpStatusCode.NotFound;
+                    return NotFound();
+                }
+
+                var output = cConfigCache.Get(configurationType);
+
+                if (output != null)
+                    return Ok(output.Content);
+
+                apiError = (int)HttpStatusCode.NotFound;
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            LogEntry("Bad request happended when calling GetConfiguration Controller.");
+            return BadRequest();
+        }
+
+        [Route("api/GetCockpitConfiguration")]
+        public IHttpActionResult GetCockpitConfiguration()
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+
+            var requestInfo = new cF4sdWebRequestInfo("GetCockpitConfiguration", "configCockpit", cAuthentication.GetUserInfo(ActionContext));
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+            var apiError = 0;
+
+            try
+            {
+                var retVal = WebApiApplication.Collector.GetCockpitConfiguration(requestInfo);
+                if (retVal != null)
+                    return Ok(retVal);
+
+                apiError = (int)HttpStatusCode.BadRequest;
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+    }
+
+}

F4SDwebService/Controllers/GetDetailsDataController.cs

@@ -0,0 +1,64 @@
+using C4IT.DataHistoryProvider;
+using C4IT.FASD.Base;
+using C4IT.Logging;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Web.Http;
+using static C4IT.Logging.cLogManager;
+
+namespace F4SDwebService.Controllers
+{
+    public class GetDetailsDataController : ApiController
+    {
+        public async Task<IHttpActionResult> Get(string jsonRequest)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+
+            try
+            {
+                var Request = JsonConvert.DeserializeObject<cF4sdHealthCardRawDataRequest>(jsonRequest);
+                var requestId = Request.Identities?.First()?.Id.ToString();
+                var requestInfo = new cF4sdWebRequestInfo("GetDetailsData", requestId, cAuthentication.GetUserInfo(ActionContext));
+
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+
+                var apiError = 0;
+
+                try
+                {
+                    var RetVal = await WebApiApplication.Collector.GetDetailsTableResultsAsync(Request.Tables, Request.Identities, Request.RefTime, Request.MaxAge, CancellationToken.None, requestInfo, 1).ConfigureAwait(false);
+
+                    if (RetVal != null)
+                        return Ok(RetVal);
+
+                    return Ok(new List<cF4SDHealthCardRawData.cHealthCardDetailsTable>());
+                }
+                catch (Exception E)
+                {
+                    apiError = E.HResult;
+                    LogException(E);
+                }
+                finally
+                {
+                    if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                    if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                }
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+            finally
+            {
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+    }
+}

F4SDwebService/Controllers/GetRawDataController.cs

@@ -0,0 +1,144 @@
+using C4IT.DataHistoryProvider;
+using C4IT.FASD.Base;
+using C4IT.Logging;
+using Newtonsoft.Json;
+using System;
+using System.Linq;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Web.Http;
+using static C4IT.Logging.cLogManager;
+
+namespace F4SDwebService.Controllers
+{
+    public class GetRawDataController : ApiController
+    {
+        public async Task<IHttpActionResult> Get(string jsonRequest)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+            try
+            {
+                var Request = JsonConvert.DeserializeObject<cF4sdHealthCardRawDataRequest>(jsonRequest);
+                var requestInfo = new cF4sdWebRequestInfo("GetRawData", Request.Identities?.First()?.Id.ToString(), cAuthentication.GetUserInfo(ActionContext));
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+                var apiError = 0;
+
+                try
+                {
+                    var RetVal = await WebApiApplication.Collector.GetTableResults(Request.Tables, Request.Identities, Request.RefTime, Request.MaxAge, true, CancellationToken.None, requestInfo, 1).ConfigureAwait(false);
+
+                    if (RetVal != null)
+                        return Ok(RetVal);
+                    return Ok(new cF4SDHealthCardRawData());
+                }
+                catch (Exception E)
+                {
+                    apiError = E.HResult;
+                    LogException(E);
+                }
+                finally
+                {
+                    if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                    if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                }
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+            finally
+            {
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+
+        [Route("api/GetRawDataStart")]
+        public async Task<IHttpActionResult> GetWithSuccsession(string jsonRequest)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+            try
+            {
+                var Request = JsonConvert.DeserializeObject<cF4sdHealthCardRawDataRequest>(jsonRequest);
+
+                var requestInfo = new cF4sdWebRequestInfo("GetRawDataStart", Request.Identities?.First()?.Id.ToString(), cAuthentication.GetUserInfo(ActionContext));
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+
+                var apiError = 0;
+
+                try
+                {
+                    var RetVal = await WebApiApplication.Collector.GetTableResults(Request.Tables, Request.Identities, Request.RefTime, Request.MaxAge, false, CancellationToken.None, requestInfo, 1).ConfigureAwait(false);
+
+
+                    if (RetVal != null)
+                        return Ok(RetVal);
+
+                    return Ok(new cF4SDHealthCardRawData());
+                }
+                catch (Exception E)
+                {
+                    apiError = E.HResult;
+                    LogException(E);
+                }
+                finally
+                {
+                    if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                    if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                }
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+            finally
+            {
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+
+        [Route("api/GetRawDataNext")]
+        public async Task<IHttpActionResult> GetNext(Guid RequestId)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+            try
+            {
+                var requestInfo = new cF4sdWebRequestInfo("GetRawDataNext", RequestId.ToString(), cAuthentication.GetUserInfo(ActionContext));
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+
+                var apiError = 0;
+
+                try
+                {
+                    var res = await SuccessorCache.GetNextResult(WebApiApplication.Collector, RequestId, false, requestInfo, 1);
+                    return Ok(res);
+                }
+                catch (Exception E)
+                {
+                    apiError = E.HResult;
+                    LogException(E);
+                }
+                finally
+                {
+                    if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                    if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                }
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+            finally
+            {
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+
+    }
+}

F4SDwebService/Controllers/GetSelectionDataController.cs

@@ -0,0 +1,97 @@
+using C4IT.DataHistoryProvider;
+using C4IT.FASD.Base;
+using C4IT.Logging;
+using Newtonsoft.Json;
+using System;
+using System.Linq;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Web.Http;
+using static C4IT.Logging.cLogManager;
+
+namespace F4SDwebService.Controllers
+{
+    public class GetSelectionDataController : ApiController
+    {
+        [Route("api/GetSelectionCount")]
+        public async Task<IHttpActionResult> GetCount(string jsonRequest)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+
+            try
+            {
+                var Request = JsonConvert.DeserializeObject<cF4sdHealthSelectionDataRequest>(jsonRequest);
+                var requestInfo = new cF4sdWebRequestInfo("GetSelectionCount", Request.Identities?.First()?.Id.ToString(), cAuthentication.GetUserInfo(ActionContext));
+
+                var apiError = 0;
+
+                try
+                {
+                    var RetVal = await WebApiApplication.Collector.GetSelectionTableResultCountAsync(Request.Table, Request.Identities, Request.Search, requestInfo, CancellationToken.None, Request.ResetFilter, Request.FilterParams).ConfigureAwait(false);
+                    return Ok(RetVal);
+                }
+                catch (Exception E)
+                {
+                    apiError = E.HResult;
+                    LogException(E);
+                }
+                finally
+                {
+                    if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                    if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                }
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+            finally
+            {
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+
+        [Route("api/GetSelectionData")]
+        public async Task<IHttpActionResult> Get(string jsonRequest)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+            try
+            {
+                var Request = JsonConvert.DeserializeObject<cF4sdHealthSelectionDataRequest>(jsonRequest);
+                var requestInfo = new cF4sdWebRequestInfo("GetSelectionData", Request.Identities?.First()?.Id.ToString(), cAuthentication.GetUserInfo(ActionContext));
+
+                var apiError = 0;
+
+                try
+                {
+                    var RetVal = await WebApiApplication.Collector.GetSelectionTableResultAsync(Request.Table, Request.Identities, Request.Search, Request.PageSize, Request.Page, requestInfo, CancellationToken.None, Request.ResetFilter, Request.FilterParams).ConfigureAwait(false);
+                    if (RetVal != null)
+                        return Ok(RetVal);
+                    return Ok();
+                }
+                catch (Exception E)
+                {
+                    LogException(E);
+                }
+                finally
+                {
+                    if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                    if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                }
+            }
+            catch (Exception E)
+            {
+                LogException(E);
+            }
+            finally
+            {
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+    }
+}

F4SDwebService/Controllers/HomeController.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Web;
+using System.Web.Mvc;
+
+namespace F4SDwebService.Controllers
+{
+    public class HomeController : Controller
+    {
+        public ActionResult Index()
+        {
+            ViewBag.Title = "Home Page";
+
+            return View();
+        }
+    }
+}

F4SDwebService/Controllers/LogonController.cs

@@ -0,0 +1,214 @@
+using C4IT.DataHistoryProvider;
+using C4IT.FASD.Base;
+using C4IT.Logging;
+using C4IT.XML;
+using Microsoft.Win32;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Net;
+using System.Net.Http.Headers;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Web;
+using System.Web.Http;
+using static C4IT.Logging.cLogManager;
+
+namespace F4SDwebService.Controllers
+{
+    public class LogonController : ApiController
+    {
+        [Route("api/Logon/GetUserIdByAccount")]
+        public async Task<IHttpActionResult> GetUserIdByAccount(string Account, string Domain)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+
+            var requestInfo = new cF4sdWebRequestInfo("SearchDefault", (Domain ?? "") + ":" + (Account ?? ""));
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+
+            var apiError = 0;
+
+            try
+            {
+                var res = await WebApiApplication.Collector.GetUserIdFromAccountAsync(Account, Domain, requestInfo, 1, CancellationToken.None);
+                if (res != null)
+                    return Ok((Guid)res);
+                return Ok(Guid.Empty);
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return NotFound();
+        }
+
+        [Route("api/Logon/Logon")]
+        [HttpGet]
+        [Authorize]
+        public async Task<IHttpActionResult> WinLogon(string lang = null)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+
+            var _id = HttpContext.Current?.User?.Identity;
+            var requestInfo = new cF4sdWebRequestInfo("RegisterExternalToken", _id == null ? _id.Name : "unknown user");
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+
+            var apiError = 0;
+
+            try
+            {
+                LogEntry($"WinLogon with language: {lang}", LogLevels.Debug);
+                if (WebApiApplication.Collector == null)
+                    return NotFound();
+
+                try
+                {
+                    var _regBase = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32);
+                    var _regKey = _regBase.OpenSubKey("SOFTWARE\\Consulting4IT GmbH\\First Aid Service Desk\\Cockpit", false);
+                    if (_regKey != null && int.TryParse(_regKey.GetValue("DebugNoAuthentication", 0).ToString(), out var _regFlag))
+                    {
+                        if (_regFlag > 0)
+                            return Unauthorized();
+                    }
+                }
+                catch { }
+                if (_id == null)
+                    return new System.Web.Http.Results.UnauthorizedResult(new List<AuthenticationHeaderValue>() { new AuthenticationHeaderValue("NTLM"), new AuthenticationHeaderValue("Negotiate") }, this);
+
+                if (!string.IsNullOrEmpty(lang))
+                {
+                    try
+                    {
+                        lang = CultureInfo.GetCultureInfoByIetfLanguageTag(lang).IetfLanguageTag;
+                    }
+                    catch { }
+                }
+
+                var UserInfo = await WebApiApplication.Collector.GetWinUserInfoAsync(_id, lang, false, new CancellationTokenSource(18000).Token, requestInfo, 1);
+
+                if (UserInfo == null)
+                {
+                    return new System.Web.Http.Results.UnauthorizedResult(new List<AuthenticationHeaderValue>() { new AuthenticationHeaderValue("NTLM"), new AuthenticationHeaderValue("Negotiate") }, this);
+                }
+
+                LogEntry($"Successfull WinLogon with language: {lang}", LogLevels.Debug);
+
+                return Ok(UserInfo);
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return NotFound();
+        }
+
+        [Route("api/Logon/RegisterExternalToken")]
+        [HttpPost]
+        public async Task<IHttpActionResult> RegisterExternalToken(cF4SDTokenRegistration TokenRegistration)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+
+            var requestInfo = new cF4sdWebRequestInfo("RegisterExternalToken", TokenRegistration.UserId.ToString() + "_" + TokenRegistration.TokenType.ToString(), cAuthentication.GetUserInfo(ActionContext));
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+
+            var apiError = 0;
+
+            try
+            {
+                var _res = await WebApiApplication.Collector.ValidateTokenAsync(TokenRegistration, requestInfo, 1, new CancellationTokenSource().Token);
+
+                if (_res?.ValidLogonsUntil != null && _res.ValidLogonsUntil.Count > 0)
+                {
+                    _res.ChangeUserInfo(requestInfo.userInfo);
+                    var _token = WebApiApplication.Collector.GenerateJsonWebToken(requestInfo.userInfo);
+                    _res.Token = _token;
+
+                    if (cLogManager.DefaultLogger.IsDebug)
+                    {
+                        var _msg = Newtonsoft.Json.JsonConvert.SerializeObject(_res, Newtonsoft.Json.Formatting.Indented);
+                        var _lstMsg = new List<string>()
+                        {
+                            $"RegisterExternalToken result for user {TokenRegistration.Name} and token type {TokenRegistration.TokenType.ToString()}",
+                            _msg
+                        };
+                        cLogManager.DefaultLogger.LogList(LogLevels.Debug, _lstMsg);
+                    }
+
+                    return Ok(_res);
+                }
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return NotFound();
+        }
+
+        [Route("api/Logon/GetAdditionalUserInfo")]
+        [HttpGet]
+        public async Task<IHttpActionResult> GetAdditionalUserInfo(string AccountType)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+
+            var _ui = cAuthentication.GetUserInfo(ActionContext);
+            var requestInfo = new cF4sdWebRequestInfo("GetAdditionalUserInfo", AccountType + ((_ui?.Id is null) ? "" : "_" + _ui.Id.ToString()), _ui);
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+
+            var apiError = 0;
+
+            try
+            {
+
+
+                var _accountType = cXmlParser.GetEnumFromString(AccountType, enumAdditionalAuthentication.unknown);
+                if (_accountType == enumAdditionalAuthentication.unknown)
+                    return NotFound();
+
+                var _retVal = await WebApiApplication.Collector.GetAdditionalUserInfo(_accountType, requestInfo, 1, CancellationToken.None);
+
+                if (_retVal != null)
+                    return Ok(_retVal);
+
+                apiError = (int)HttpStatusCode.NotFound;
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return NotFound();
+        }
+    }
+}

F4SDwebService/Controllers/Matrix42/Matrix42TicketFinalization.cs

@@ -0,0 +1,63 @@
+using C4IT.DataHistoryProvider;
+using C4IT.FASD.Base;
+using C4IT.Logging;
+using System;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Web.Http;
+using static C4IT.Logging.cLogManager;
+
+
+namespace F4SDwebService.Controllers.Matrix42
+{
+    public class Matrix42TicketFinalizationController : ApiController
+    {
+        [HttpPost]
+        [Route("api/Matrix42/TicketFinalization")]
+        public async Task<IHttpActionResult> Matrix42TicketFinalization([FromBody] cApiM42Ticket jsonRequest)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+            var requestInfo = new cF4sdWebRequestInfo("Matrix42TicketFinalization", jsonRequest.Action?.ToString() + " + " + jsonRequest.Ticket?.ToString() ?? "", cAuthentication.GetUserInfo(ActionContext));
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+            var apiError = 0;
+
+            try
+            {
+
+                if (string.Equals(jsonRequest.StatusIdValue, "Closed", StringComparison.InvariantCultureIgnoreCase))
+                    await WebApiApplication.Collector.M42WpmCollector.ReopenM42TicketAsync(jsonRequest, requestInfo, 1, CancellationToken.None);
+                switch (jsonRequest.Action)
+                {
+                    case enumCloseCaseTicketStatus.Save:
+                        if (jsonRequest.Ticket == null || jsonRequest.Ticket.HasValue && jsonRequest.Ticket.Equals(Guid.Empty))
+                            return Ok(await WebApiApplication.Collector.M42WpmCollector.CreateM42TicketAsync(jsonRequest, requestInfo, 1, CancellationToken.None));
+                        else
+                            return Ok(await WebApiApplication.Collector.M42WpmCollector.UpdateM42TicketAsync(jsonRequest, requestInfo, 1, CancellationToken.None));
+                    case enumCloseCaseTicketStatus.Close:
+                        return Ok(await WebApiApplication.Collector.M42WpmCollector.CloseM42TicketAsync(jsonRequest, requestInfo, 1, CancellationToken.None));
+                    case enumCloseCaseTicketStatus.OnHold:
+                        return Ok(await WebApiApplication.Collector.M42WpmCollector.PauseM42TicketAsync(jsonRequest, requestInfo, 1, CancellationToken.None));
+                    case enumCloseCaseTicketStatus.Forward:
+                        return Ok(await WebApiApplication.Collector.M42WpmCollector.ForwardM42TicketAsync(jsonRequest, requestInfo, 1, CancellationToken.None));
+
+                    default: break;
+                }
+                return Ok(jsonRequest);
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+    }
+}

F4SDwebService/Controllers/QuickActionDataController.cs

@@ -0,0 +1,93 @@
+using C4IT.DataHistoryProvider;
+using C4IT.FASD.Base;
+using C4IT.Logging;
+using System;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Web.Http;
+using static C4IT.Logging.cLogManager;
+namespace F4SDwebService.Controllers
+{
+    public class QuickActionDataController : ApiController
+    {
+
+        [HttpPost]
+        [Route("api/QuickAction/Run")]
+        public async Task<IHttpActionResult> QuickActionRun([FromBody] cF4SDServerQuickActionParameters jsonRequest)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+            var requestInfo = new cF4sdWebRequestInfo(jsonRequest.Action, jsonRequest.ParamaterType);
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+            var apiError = 0;
+
+            try
+            {
+                if (jsonRequest.Category == "Intune")
+                {
+                    var result = await WebApiApplication.Collector.ActiveDirectory.QuickActionRun(jsonRequest, requestInfo, CancellationToken.None);
+
+                    if (result is null)
+                        return Ok();
+
+                    return Ok(result);
+                }
+                if (jsonRequest.Category == "Citrix")
+                {
+                    var result = await WebApiApplication.Collector.CitrixCollector.QuickActionRun(jsonRequest, requestInfo, CancellationToken.None);
+
+                    if (result is null)
+                        return Ok();
+
+                    return Ok(result);
+                }
+                else
+                    return Ok();
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+                return BadRequest();
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+        }
+
+
+        [HttpGet]
+        [Route("api/QuickAction/GetQuickActionList")]
+        public IHttpActionResult GetQuickActionList()
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+            var requestInfo = new cF4sdWebRequestInfo("GetQuickActionList", null);
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+            var apiError = 0;
+
+            try
+            {
+                var _quickActions = WebApiApplication.Collector.GetQuickActionAllList();
+
+                return Ok(_quickActions.Result);
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+                return BadRequest();
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+        }
+
+
+    }
+}

F4SDwebService/Controllers/SearchDefault.cs

@@ -0,0 +1,315 @@
+using C4IT.DataHistoryProvider;
+using C4IT.Logging;
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Web.Http;
+using static C4IT.Logging.cLogManager;
+
+namespace F4SDwebService.Controllers
+{
+    public class SearchDefaultController : ApiController
+    {
+        public async Task<IHttpActionResult> Get(string search)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+
+            var requestInfo = new cF4sdWebRequestInfo("SearchDefault", search);
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+            var apiError = 0;
+
+            try
+            {
+                if (WebApiApplication.Collector == null)
+                    return null;
+
+                var output = await WebApiApplication.Collector.DefaultSearchAsync(search, CancellationToken.None, requestInfo, 1);
+
+                if (output != null)
+                    return Ok(output);
+
+                apiError = (int)HttpStatusCode.BadRequest;
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+
+        [Route("api/SearchDetailed")]
+        public async Task<IHttpActionResult> GetDetailed(string search)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+
+            var requestInfo = new cF4sdWebRequestInfo("SearchDetailed", search);
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+
+            var apiError = 0;
+
+            try
+            {
+                if (WebApiApplication.Collector == null)
+                    return null;
+
+                var output = await WebApiApplication.Collector.DetailedSearchAsync(search, CancellationToken.None, requestInfo, 1);
+
+                if (output != null)
+                    return Ok(output);
+
+                apiError = (int)HttpStatusCode.BadRequest;
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+
+        [Route("api/SearchDetailedStart")]
+        public IHttpActionResult GetDetailedStart(string search)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+
+            var requestInfo = new cF4sdWebRequestInfo("SearchDetailedStart", search);
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+
+            var apiError = 0;
+
+            try
+            {
+                if (WebApiApplication.Collector == null)
+                    return null;
+
+                var output = WebApiApplication.Collector.DetailedSearchStart(search, requestInfo, 1);
+
+                if (output != null)
+                    return Ok(output);
+
+                apiError = (int)HttpStatusCode.BadRequest;
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+
+        [Route("api/SearchDetailedResult")]
+        public async Task<IHttpActionResult> GetDetailedResult(Guid taskID)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+
+            var requestInfo = new cF4sdWebRequestInfo("SearchDetailedResult", taskID.ToString());
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+
+            var apiError = 0;
+
+            try
+            {
+                if (WebApiApplication.Collector == null)
+                    return null;
+
+                var output = await cDataHistoryCollectorSearchTaskCache.GetResultAsync(taskID);
+
+                if (output != null)
+                    return Ok(output);
+
+                apiError = (int)HttpStatusCode.BadRequest;
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+
+        [Route("api/SearchDetailedStop")]
+        public IHttpActionResult GetDetailedStop(Guid taskID)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+
+            var requestInfo = new cF4sdWebRequestInfo("SearchDetailedStop", taskID.ToString());
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+
+            var apiError = 0;
+
+            try
+            {
+                if (WebApiApplication.Collector == null)
+                    return null;
+
+                cDataHistoryCollectorSearchTaskCache.StopTask(taskID);
+
+                return Ok();
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+
+        [Route("api/SearchPhone")]
+        public async Task<IHttpActionResult> GetPhone(string searchPhone, string searchName)
+        {
+            var requestInfo = new cF4sdWebRequestInfo("SearchPhone", searchPhone);
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+
+            var apiError = 0;
+
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+            try
+            {
+                if (WebApiApplication.Collector == null)
+                    return null;
+
+                var output = await WebApiApplication.Collector.PhoneSearchAsync(searchPhone, searchName, CancellationToken.None, requestInfo, 1);
+
+                if (output != null)
+                    return Ok(output);
+
+                apiError = (int)HttpStatusCode.BadRequest;
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+
+        [Route("api/SearchComputerByName")]
+        public async Task<IHttpActionResult> GetComputerByName(string Name, string Domain = null)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+
+            var requestInfo = new cF4sdWebRequestInfo("SearchComputerByName", Name);
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+
+            var apiError = 0;
+
+            try
+            {
+                if (WebApiApplication.Collector == null)
+                    return NotFound();
+
+                var output = await WebApiApplication.Collector.ComputerSearchByNameAsync(Name, Domain, CancellationToken.None, requestInfo, 1);
+
+                if (output != null)
+                    return Ok(output);
+
+                apiError = (int)HttpStatusCode.BadRequest;
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+
+        [Route("api/SearchUserByNameAndSids")]
+        public async Task<IHttpActionResult> GetUserByNameAndSids(string Name, string SIDs)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+
+            var requestInfo = new cF4sdWebRequestInfo("SearchUserByNameAndSids", Name);
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+
+            var apiError = 0;
+
+            try
+            {
+                if (WebApiApplication.Collector == null)
+                    return null;
+
+                var lstSids = new List<string>();
+                if (!string.IsNullOrWhiteSpace(SIDs))
+                {
+                    var arrSids = SIDs.Split(',');
+                    foreach (var Entry in arrSids)
+                        lstSids.Add(Entry.Trim());
+                }
+
+                var output = await WebApiApplication.Collector.UserSearchByNameAndSidsAsync(Name, lstSids, CancellationToken.None, requestInfo, 1);
+
+                if (output != null)
+                    return Ok(output);
+
+                apiError = (int)HttpStatusCode.BadRequest;
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+
+    }
+}

F4SDwebService/Controllers/StagedSearchRelationController.cs

@@ -0,0 +1,88 @@
+using C4IT.FASD.Base;
+using C4IT_DataHistoryProvider_Base.DataSources;
+using C4IT_DataHistoryProvider_Base.Services;
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Http;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Web.Http;
+using System.Web.Http.Results;
+using static C4IT.Logging.cLogManager;
+
+namespace F4SDwebService.Controllers
+{
+    public class StagedSearchRelationController : ApiController
+    {
+        private readonly IStagedRelationService _relationService;
+
+        public StagedSearchRelationController()
+        {
+            _relationService = WebApiApplication.Collector.GetStagedRelationService();
+        }
+
+        [HttpPost]
+        [Route("api/StagedSearchRelations")]
+        public IHttpActionResult StartGatheringRelatedInformationObjects([FromBody] IEnumerable<cFasdApiSearchResultEntry> relatedTo, [FromUri] int age)
+        {
+            MethodBase CM = null; if (DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+
+            try
+            {
+                cF4sdStagedSearchResultRelationTaskId taskId = _relationService.StartGatheringRelatedObjects(relatedTo, age);
+                if (taskId.Id == Guid.Empty)
+                    return BadRequest();
+
+                HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Accepted, taskId);
+                return new ResponseMessageResult(response);
+            }
+            catch (Exception ex)
+            {
+                LogException(ex);
+            }
+            finally { LogMethodEnd(CM); }
+
+            return InternalServerError();
+        }
+
+        [HttpGet]
+        [Route("api/StagedSearchRelations/{id}")]
+        public async Task<IHttpActionResult> GetRelatedInformationObjects([FromUri] Guid id, CancellationToken token)
+        {
+            MethodBase CM = null; if (DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+            try
+            {
+                return Ok(await _relationService.GetRelatedObjectsAsync(id, token));
+            }
+            catch (Exception ex)
+            {
+                LogException(ex);
+            }
+            finally { LogMethodEnd(CM); }
+
+            return InternalServerError();
+        }
+
+        [HttpPost]
+        [Route("api/StagedSearchRelations/{id}/stop")]
+        public IHttpActionResult StopGatheringRelatedInformationObjects([FromUri] Guid id)
+        {
+            MethodBase CM = null; if (DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+            try
+            {
+                _relationService.StopGatheringRelatedObjects(id);
+                HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Accepted);
+                return new ResponseMessageResult(response);
+            }
+            catch (Exception ex)
+            {
+                LogException(ex);
+            }
+            finally { LogMethodEnd(CM); }
+
+            return InternalServerError();
+        }
+    }
+}

F4SDwebService/Controllers/UsageController.cs

@@ -0,0 +1,104 @@
+using C4IT.DataHistoryProvider;
+using C4IT.FASD.Base;
+using C4IT.Logging;
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Web.Http;
+using static C4IT.Logging.cLogManager;
+
+namespace F4SDwebService.Controllers
+{
+    public class GetUsageController : ApiController
+    {
+        public async Task<IHttpActionResult> Get(enumF4sdSearchResultClass Class, Guid ClassId, int Age)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+
+            var requestInfo = new cF4sdWebRequestInfo("GetUsage", ClassId.ToString(), cAuthentication.GetUserInfo(ActionContext));
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+
+            var apiError = 0;
+
+            try
+            {
+
+                List<cF4sdApiSearchResultRelation> RetVal = null;
+
+
+                var infoClass = cF4sdIdentityEntry.GetFromSearchResult(Class);
+                if (infoClass != enumFasdInformationClass.Unknown)
+                {
+                    RetVal = await WebApiApplication.Collector.GetUsageFromAgentData(infoClass, new List<Guid>() { ClassId }, Age, CancellationToken.None, requestInfo, 1);
+                    return Ok(RetVal);
+                }
+
+                apiError = 404;
+                return NotFound();
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+
+        [Route("api/GetUsageDetailed")]
+        public async Task<IHttpActionResult> GetDetailed(enumF4sdSearchResultClass Class, string ClassIds, int Age)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+
+            var requestInfo = new cF4sdWebRequestInfo("GetUsageDetailed", ClassIds.Replace(",", "_"), cAuthentication.GetUserInfo(ActionContext));
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+
+            var apiError = 0;
+
+            try
+            {
+                var infoClass = cF4sdIdentityEntry.GetFromSearchResult(Class);
+                if (infoClass == enumFasdInformationClass.Unknown)
+                    return NotFound();
+
+                var arrIds = ClassIds.Split(',');
+                if (arrIds == null || arrIds.Length < 1)
+                    return NotFound();
+
+                var lstIds = new List<Guid>();
+                foreach (var Entry in arrIds)
+                {
+                    var strId = Entry.Trim();
+                    if (Guid.TryParse(strId, out var Id))
+                        lstIds.Add(Id);
+                }
+
+                var res = await WebApiApplication.Collector.GetUsageFromAgentData(infoClass, lstIds, Age, CancellationToken.None, requestInfo, 1);
+
+                return Ok(res);
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+
+    }
+}

F4SDwebService/Controllers/WritePropertyController.cs

@@ -0,0 +1,47 @@
+using C4IT.DataHistoryProvider;
+using C4IT.FASD.Base;
+using C4IT.Logging;
+using System;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Web.Http;
+using static C4IT.Logging.cLogManager;
+
+namespace F4SDwebService.Controllers
+{
+    public class WritePropertyController : ApiController
+    {
+        [HttpPost]
+        [Route("api/WriteProperty")]
+        public async Task<IHttpActionResult> Put([FromBody] cF4SDWriteParameters jsonRequest)
+        {
+            MethodBase CM = null; if (cLogManager.DefaultLogger.IsDebug) { CM = MethodBase.GetCurrentMethod(); LogMethodBegin(CM); }
+
+            var requestInfo = new cF4sdWebRequestInfo("WriteProperty", jsonRequest.id.ToString(), cAuthentication.GetUserInfo(ActionContext));
+            if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceStart(0, requestInfo.requestName, requestInfo.id, requestInfo.created); }
+
+            var apiError = 0;
+
+            try
+            {
+                if (await WebApiApplication.Collector.WritePropertyAsync(jsonRequest, requestInfo, CancellationToken.None))
+                    return Ok();
+                apiError = -1;
+            }
+            catch (Exception E)
+            {
+                apiError = E.HResult;
+                LogException(E);
+            }
+            finally
+            {
+                if (WebApiApplication.Debug_apiTiming) WebApiApplication.SaveApiTimingEntry(requestInfo.requestName, requestInfo.id, requestInfo.created, apiError);
+                if (cPerformanceLogger.IsActive && requestInfo != null) { cPerformanceLogger.LogPerformanceEnd(0, requestInfo.requestName, requestInfo.id, requestInfo.created, requestInfo.created, ErrorCode: apiError); }
+                if (CM != null) LogMethodEnd(CM);
+            }
+
+            return BadRequest();
+        }
+    }
+}