SignalR improvements, fixes, etc...

TIAM.Models/Dtos/Profiles/ProfileDto.cs

@@ -14,6 +14,8 @@ public class ProfileDto : IProfileDto //TODO: AcProfileDtoBase - J.
     public string? LastName { get; set; }
     //public string NickName { get; set; }
 
+    public string? EmailAddress { get; set; }
+
     public string? Description { get; set; }
 
     public string? ThumbnailUrl { get; set; }

TIAM.Services/AcSignalRTags.cs

@@ -0,0 +1,9 @@
+using AyCode.Services.SignalRs;
+
+namespace TIAM.Services;
+
+public class SignalRTags : AcSignalRTags
+{
+    public const int GetTransfersAsync = 5;
+    public const int GetPropertiesByOwnerIdAsync = 6;
+}

TIAM.Services/TIAM.Services.csproj

@@ -25,6 +25,9 @@
     <Reference Include="AyCode.Models">
       <HintPath>..\..\AyCode.Core\AyCode.Services.Server\bin\Debug\net8.0\AyCode.Models.dll</HintPath>
     </Reference>
+    <Reference Include="AyCode.Services">
+      <HintPath>..\..\AyCode.Core\AyCode.Services.Server\bin\Debug\net8.0\AyCode.Services.dll</HintPath>
+    </Reference>
   </ItemGroup>
 
 </Project>

TIAMSharedUI/Pages/User/MyServiceProviders.razor

@@ -8,11 +8,13 @@
 @using TIAMWebApp.Shared.Application.Utility
 @using AyCode.Core.Loggers
 @using AyCode.Services.Loggers
+@using TIAMWebApp.Shared.Application.Services
 @layout AdminLayout
 @inject IAcLogWriterClientBase BrowserConsoleLogWriter
 @inject IStringLocalizer<TIAMResources> localizer
 @inject ISessionService SessionService
 @inject IServiceProviderDataService ServiceProviderDataService
+
 <h3>Properties</h3>
 
 <div class="container">
@@ -186,9 +188,7 @@
     {
         base.OnInitialized();
         var myId = SessionService.User.UserId;
-        ServiceProviderDataService.GetPropertiesByOwnerIdAsync(myId);
-
 
+        var  companyPropertiesByOwner = ServiceProviderDataService.GetPropertiesByOwnerIdAsync(myId);
     }
-
 }

TIAMSharedUI/Pages/User/SysAdmins/ManageTransfers.razor

@@ -18,6 +18,7 @@
 @using AyCode.Core.Extensions;
 @using AyCode.Core
 @using AyCode.Core.Helpers
+@using TIAM.Services
 @layout AdminLayout
 @inject IEnumerable<IAcLogWriterClientBase> LogWriters
 @inject IStringLocalizer<TIAMResources> localizer
@@ -389,11 +390,12 @@
     {
         _logger = new LoggerClient<ManageTransfers>(LogWriters.ToArray());
 
-        devAdminSignalClient.SendRequestToServerAsync(SignalRTags.GetTransfersAsync, responseBytes =>
+        devAdminSignalClient.SendMessageToServerAsync<List<Transfer>>(SignalRTags.GetTransfersAsync, response =>
         {
-            var transfers = responseBytes.MessagePackTo<string>(ContractlessStandardResolver.Options).JsonTo<List<Transfer>>();
+            if (response.Status == SignalResponseStatus.Error)
+                return;
 
-            InitializeDataSources(transfers ?? []);
+            InitializeDataSources(response.ResponseData ?? []);
             StateHasChanged();
         }).Forget();
 

TIAMWebApp/Server/Controllers/TransferDataAPIController.cs

@@ -380,10 +380,10 @@ namespace TIAMWebApp.Server.Controllers
         [Route(APIUrls.GetTransfersRouteName)]
         public async Task<string> GetTransfers()
         {
-            var token = _authService.GetAuthTokenFromRequest(Request);
+            //var token = _authService.GetAuthTokenFromRequest(Request);
-            _logger.Detail(token);
+            //_logger.Detail(token);
-            var result = await _adminDal.GetTransfersJsonAsync();
 
+            var result = await _adminDal.GetTransfersJsonAsync();
             return result;
         }
 

TIAMWebApp/Server/Program.cs

@@ -41,6 +41,9 @@ builder.Services.AddScoped<AdminDal>();
 builder.Services.AddScoped<AuctionDal>();
 builder.Services.AddScoped<TransferDestinationDal>();
 builder.Services.AddSingleton<AuthService>();
+builder.Services.AddScoped<ServiceProviderAPIController>();
+builder.Services.AddScoped<TransferDataAPIController>();
+
 
 builder.Services.AddSignalR();//.AddMessagePackProtocol(options => options.SerializerOptions = MessagePackSerializerOptions.Standard.WithSecurity(MessagePackSecurity.UntrustedData));
 

TIAMWebApp/Server/Services/DevAdminSignalRhub.cs

@@ -8,10 +8,12 @@ using MessagePack;
 using MessagePack.Resolvers;
 using AyCode.Services.Server.SignalRs;
 using System.ServiceModel.Channels;
+using TIAM.Services;
+using TIAMWebApp.Server.Controllers;
 
 namespace TIAMWebApp.Server.Services;
 
-public class DevAdminSignalRHub(AdminDal adminDal, IEnumerable<IAcLogWriterBase> logWriters) : Hub<ISignalRHubItemServer>, IAcSignalRHubServer
+public class DevAdminSignalRHub(AdminDal adminDal, ServiceProviderAPIController serviceProviderAPIController, TransferDataAPIController transferDataAPIController, IEnumerable<IAcLogWriterBase> logWriters) : Hub<ISignalRHubItemServer>, IAcSignalRHubServer
 {
     private readonly TIAM.Core.Loggers.Logger<DevAdminSignalRHub> _logger = new(logWriters.ToArray());
 
@@ -35,41 +37,61 @@ public class DevAdminSignalRHub(AdminDal adminDal, IEnumerable<IAcLogWriterBase>
         await base.OnDisconnectedAsync(exception);
     }
 
-    public async Task OnRequestMessage(int messageTag, int requestId)
+    //public async Task OnRequestMessage(int messageTag, int requestId)
-    {
+    //{
-        _logger.Info($"Server OnRequestMessage; {nameof(messageTag)}: {messageTag}; {nameof(requestId)}: {requestId}; ConnectionId: {Context.ConnectionId}; UserIdentifier: {Context.UserIdentifier}");
+    //    _logger.Info($"Server OnRequestMessage; {nameof(messageTag)}: {messageTag}; {nameof(requestId)}: {requestId}; ConnectionId: {Context.ConnectionId}; UserIdentifier: {Context.UserIdentifier}");
 
-        if (messageTag == SignalRTags.GetTransfersAsync)
+    //    if (messageTag == SignalRTags.GetTransfersAsync)
-            await ResponseToCaller(SignalRTags.PostTransfersAsync, await adminDal.GetTransfersJsonAsync(), requestId);
+    //        await ResponseToCaller(SignalRTags.PostTransfersAsync, await adminDal.GetTransfersJsonAsync(), requestId);
-    }
+    //}
 
-    public async Task OnReceiveMessage(int messageTag, byte[] message, int? requestId)
+    public async Task OnReceiveMessage(int messageTag, byte[]? message, int? requestId)
     {
         var logText = $"Server OnReceiveMessage; {nameof(messageTag)}: {messageTag}; {nameof(requestId)}: {requestId}; ConnectionId: {Context.ConnectionId}; UserIdentifier: {Context.UserIdentifier}";
 
-        if (message.Length == 0) _logger.Warning($"message.Length == 0! {logText}");
+        if (message is { Length: 0 }) _logger.Warning($"message.Length == 0! {logText}");
         else _logger.Info(logText);
 
-        //if (messageTag == SignalRTags.GetTransfersAsync)
+        try
-        //    ResponseToClient(messageTag, await adminDal.GetTransfersJsonAsync(), requestId);
+        {
+            if (messageTag == SignalRTags.GetTransfersAsync)
+            {
+                await ResponseToCaller(messageTag, new SignalResponseMessage<string>(SignalResponseStatus.Success, await transferDataAPIController.GetTransfers()), requestId);
+            }
+            else if (messageTag == SignalRTags.GetPropertiesByOwnerIdAsync)
+            {
+                var ownerId = message.MessagePackTo<SignalRequestByIdMessage>().Id;
+                var json = (await serviceProviderAPIController.GetServiceProvidersByOwnerId(ownerId)).ToJson();
+
+                await ResponseToCaller(messageTag, new SignalResponseMessage<string>(SignalResponseStatus.Success, json), requestId);
+            }
+
+            return;
+        }
+        catch (Exception ex)
+        {
+            _logger.Error($"Server OnReceiveMessage; {ex.Message}", ex);
+        }
+
+        await ResponseToCaller(messageTag, new SignalResponseMessage<byte[]>(SignalResponseStatus.Error, null), requestId);
     }
 
-    protected async Task ResponseToCaller(int messageTag, object message, int requestId)
+    protected async Task ResponseToCaller(int messageTag, ISignalRMessage message, int? requestId)
         => await SendMessageToClient(Clients.Caller, messageTag, message, requestId);
 
-    protected async Task SendMessageToClient(ISignalRHubItemServer sendTo, int messageTag, object message, int? requestId = null)
+    protected async Task SendMessageToClient(ISignalRHubItemServer sendTo, int messageTag, ISignalRMessage message, int? requestId = null)
     {
         _logger.Info($"Server SendMessageToClient; {nameof(messageTag)}: {messageTag}; {nameof(requestId)}: {requestId}; ConnectionId: {Context.ConnectionId}; UserIdentifier: {Context.UserIdentifier}");
 
         await sendTo.OnReceiveMessage(messageTag, message.ToMessagePack(ContractlessStandardResolver.Options), requestId);
     }
 
-    protected void SendRequestToClient(ISignalRHubItemServer sendTo, int messageTag, int requestId)
+    //protected void SendRequestToClient(ISignalRHubItemServer sendTo, int messageTag, int requestId)
-    {
+    //{
-        _logger.Info($"Server SendRequestToClient; {nameof(messageTag)}: {messageTag}; {nameof(requestId)}: {requestId}; ConnectionId: {Context.ConnectionId}; UserIdentifier: {Context.UserIdentifier}");
+    //    _logger.Info($"Server SendRequestToClient; {nameof(messageTag)}: {messageTag}; {nameof(requestId)}: {requestId}; ConnectionId: {Context.ConnectionId}; UserIdentifier: {Context.UserIdentifier}");
 
-        sendTo.OnRequestMessage(messageTag, requestId).Forget();
+    //    sendTo.OnRequestMessage(messageTag, requestId).Forget();
-    }
+    //}
 
     public async Task SendMessageToGroup(string groupId, int messageTag, string message)
     {

TIAMWebApp/Shared/Services/AcSignalRClientBase.cs

@@ -1,4 +1,5 @@
 using System.Collections.Concurrent;
+using System.Security.Cryptography.X509Certificates;
 using AyCode.Core;
 using AyCode.Core.Enums;
 using AyCode.Core.Extensions;
@@ -12,6 +13,7 @@ using MessagePack;
 using MessagePack.Resolvers;
 using Microsoft.AspNetCore.SignalR.Client;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.IdentityModel.Tokens;
 using TIAM.Entities.Transfers;
 using TIAMWebApp.Shared.Application.Models.ClientSide;
 using TIAMWebApp.Shared.Application.Utility;
@@ -28,7 +30,9 @@ namespace TIAMWebApp.Shared.Application.Services
         protected readonly LoggerClient Logger;
 
         public event Action<int, byte[], int?> OnMessageReceived;
-        public event Action<int, int> OnMessageRequested;
+        //public event Action<int, int> OnMessageRequested;
+
+        public int Timeout = 10000;
 
         protected AcSignalRClientBase(string hubName, IEnumerable<IAcLogWriterClientBase> logWriters)
         {
@@ -41,8 +45,8 @@ namespace TIAMWebApp.Shared.Application.Services
 
             HubConnection.Closed += HubConnection_Closed;
 
-            _ = HubConnection.On<int, byte[], int?>("OnReceiveMessage", OnReceiveMessage);
+            _ = HubConnection.On<int, byte[], int?>(nameof(IAcSignalRHubClient.OnReceiveMessage), OnReceiveMessage);
-            _ = HubConnection.On<int, int>(nameof(IAcSignalRHubClient.OnRequestMessage), OnRequestMessage);
+            //_ = HubConnection.On<int, int>(nameof(IAcSignalRHubClient.OnRequestMessage), OnRequestMessage);
 
             HubConnection.StartAsync().Forget();
             
@@ -63,7 +67,7 @@ namespace TIAMWebApp.Shared.Application.Services
                 await HubConnection.StartAsync();
 
             if (HubConnection.State != HubConnectionState.Connected)
-                await TaskHelper.WaitToAsync(() => HubConnection.State == HubConnectionState.Connected, 10000, 25);
+                await TaskHelper.WaitToAsync(() => HubConnection.State == HubConnectionState.Connected, Timeout, 25);
         }
 
         public async Task StopConnection()
@@ -72,60 +76,78 @@ namespace TIAMWebApp.Shared.Application.Services
             await HubConnection.DisposeAsync();
         }
 
-        public virtual async Task SendMessageToServerAsync(int messageTag, object message, int? requestId = null)
+        public virtual Task SendMessageToServerAsync(int messageTag)
+            => SendMessageToServerAsync(messageTag, null, AcDomain.NextUniqueInt32);
+
+        public virtual Task SendMessageToServerAsync(int messageTag, int requestId)
+            => SendMessageToServerAsync(messageTag, null, requestId);
+
+        public virtual async Task SendMessageToServerAsync(int messageTag, ISignalRMessage? message, int? requestId)
         {
             Logger.DebugConditional($"Client SendMessageToServerAsync; {nameof(messageTag)}: {messageTag}; {nameof(requestId)}: {requestId};");
 
             await StartConnection();
             
-            HubConnection.SendAsync(nameof(IAcSignalRHubClient.OnReceiveMessage), messageTag, message, requestId).Forget();
+            HubConnection.SendAsync(nameof(IAcSignalRHubClient.OnReceiveMessage), messageTag, message?.ToMessagePack(ContractlessStandardResolver.Options), requestId).Forget();
         }
 
-        public virtual void SendRequestToServerAsync(int messageTag)
+        public virtual Task<TResponse?> SendMessageToServerAsync<TResponse>(int messageTag) where TResponse : class
-            => SendRequestToServerAsync(messageTag, AcDomain.NextUniqueInt32).Forget();
+            => SendMessageToServerAsync<TResponse>(messageTag, null, AcDomain.NextUniqueInt32);
 
-        public virtual async Task SendRequestToServerAsync(int messageTag, int requestId)
+        public virtual Task<TResponse?> SendMessageToServerAsync<TResponse>(int messageTag, ISignalRMessage? message) where TResponse : class
+            => SendMessageToServerAsync<TResponse>(messageTag, message, AcDomain.NextUniqueInt32);
+
+        public virtual async Task<TResponse?> SendMessageToServerAsync<TResponse>(int messageTag, ISignalRMessage? message, int requestId) where TResponse : class
         {
-            Logger.DebugConditional($"Client SendRequestToServerAsync; {nameof(messageTag)}: {messageTag}; {nameof(requestId)}: {requestId};");
+            Logger.DebugConditional($"Client SendMessageToServerAsync<TResult>; {nameof(messageTag)}: {messageTag}; {nameof(requestId)}: {requestId};");
-
-            await StartConnection();
-            
-            HubConnection.SendAsync(nameof(IAcSignalRHubClient.OnRequestMessage), messageTag, requestId).Forget();
-        }
-
-        public virtual async Task<TResult?> SendRequestToServerAsync<TResult>(int messageTag)
-        {
-            var requestId = AcDomain.NextUniqueInt32;
-
-            Logger.DebugConditional($"Client SendRequestToServerAsync<TResult>; {nameof(messageTag)}: {messageTag}; {nameof(requestId)}: {requestId};");
             
             _responseByRequestId[requestId] = null;
-            await SendRequestToServerAsync(messageTag, requestId);
+            await SendMessageToServerAsync(messageTag, message, requestId);
 
             try
             {
-                if (await TaskHelper.WaitToAsync(() => _responseByRequestId[requestId] != null, 10000, 25) &&
+                if (await TaskHelper.WaitToAsync(() => _responseByRequestId[requestId] != null, Timeout, 25) &&
-                    _responseByRequestId.TryRemove(requestId, out var obj) && obj is byte[] messagePackBytes)
+                    _responseByRequestId.TryRemove(requestId, out var obj) && obj is ISignalResponseMessage<string> responseMessage)
                 {
-                    var json = messagePackBytes.MessagePackTo<string>(ContractlessStandardResolver.Options);
+                    if (responseMessage.Status == SignalResponseStatus.Error || responseMessage.ResponseData == null)
-                    return json.JsonTo<TResult>() ?? default;
+                    {
+                        Logger.Error($"Client SendMessageToServerAsync<TResponseData>; tag: {messageTag}; Status: {responseMessage.Status}");
+                        return default;
+                    }
+
+                    return responseMessage.ResponseData.JsonTo<TResponse>();
                 }
             }
             catch (Exception ex)
             {
-                Logger.Error($"SendRequestToServerAsync; messageTag: {messageTag}; requestId: {requestId}; {ex.Message}", ex);
+                Logger.Error($"SendMessageToServerAsync; messageTag: {messageTag}; requestId: {requestId}; {ex.Message}", ex);
             }
 
             _responseByRequestId.TryRemove(requestId, out _);
             return default;
         }
 
-        public virtual Task SendRequestToServerAsync(int messageTag, Action<byte[]> responseCallback)
+        public virtual Task SendMessageToServerAsync<TResponseData>(int messageTag, Action<ISignalResponseMessage<TResponseData?>> responseCallback)
+            => SendMessageToServerAsync<TResponseData>(messageTag, null, responseCallback);
+
+        public virtual Task SendMessageToServerAsync<TResponseData>(int messageTag, ISignalRMessage? message, Action<ISignalResponseMessage<TResponseData?>> responseCallback)
         {
             var requestId = AcDomain.NextUniqueInt32;
-            _responseByRequestId[requestId] = responseCallback;
 
-            return SendRequestToServerAsync(messageTag, requestId);
+            _responseByRequestId[requestId] = new Action<ISignalResponseMessage<string>>(responseMessage  =>
+            {
+                TResponseData? responseData = default;
+
+                if (responseMessage.Status == SignalResponseStatus.Success)
+                {
+                    responseData = string.IsNullOrEmpty(responseMessage.ResponseData) ? default : responseMessage.ResponseData.JsonTo<TResponseData?>();
+                }
+                else Logger.Error($"Client SendMessageToServerAsync<TResponseData> callback; tag: {messageTag}; Status: {responseMessage.Status}");
+
+                responseCallback(new SignalResponseMessage<TResponseData?>(responseMessage.Status, responseData));
+            });
+                
+            return SendMessageToServerAsync(messageTag, message, requestId);
         }
 
         public virtual Task OnReceiveMessage(int messageTag, byte[] message, int? requestId)
@@ -144,16 +166,18 @@ namespace TIAMWebApp.Shared.Application.Services
                     switch (_responseByRequestId[reqId])
                     {
                         case null:
-                            _responseByRequestId[reqId] = message;
+                            _responseByRequestId[reqId] = message.MessagePackTo<SignalResponseMessage<string>>();
                             return Task.CompletedTask;
 
-                        case Action<byte[]> messagePackCallback:
+                        case Action<ISignalResponseMessage<string>> messagePackCallback:
                             _responseByRequestId.TryRemove(reqId, out _);
 
-                            messagePackCallback.Invoke(message);
+                            messagePackCallback.Invoke(message.MessagePackTo<SignalResponseMessage<string>>(ContractlessStandardResolver.Options));
                             return Task.CompletedTask;
 
                         //case Action<string> jsonCallback:
+                        //    _responseByRequestId.TryRemove(reqId, out _);
+
                         //    jsonCallback.Invoke(message.MessagePackTo<string>());
                         //    return Task.CompletedTask;
 
@@ -175,23 +199,22 @@ namespace TIAMWebApp.Shared.Application.Services
 
             return Task.CompletedTask;
         }
+        //public virtual Task OnRequestMessage(int messageTag, int requestId)
+        //{
+        //    Logger.DebugConditional($"Client OnRequestMessage; {nameof(messageTag)}: {messageTag}; {nameof(requestId)}: {requestId};");
 
-        public virtual Task OnRequestMessage(int messageTag, int requestId)
+        //    try
-        {
+        //    {
-            Logger.DebugConditional($"Client OnRequestMessage; {nameof(messageTag)}: {messageTag}; {nameof(requestId)}: {requestId};");
+        //        OnMessageRequested(messageTag, requestId);
+        //    }
+        //    catch(Exception ex)
+        //    {
+        //        Logger.Error($"Client OnReceiveMessage; {nameof(messageTag)}: {messageTag}; {nameof(requestId)}: {requestId}; {ex.Message}", ex);
+        //        throw;
+        //    }
 
-            try
+        //    return Task.CompletedTask;
-            {
-                OnMessageRequested(messageTag, requestId);
-            }
-            catch(Exception ex)
-            {
-                Logger.Error($"Client OnReceiveMessage; {nameof(messageTag)}: {messageTag}; {nameof(requestId)}: {requestId}; {ex.Message}", ex);
-                throw;
-            }
 
-            return Task.CompletedTask;
+        //}
-
-        }
     }
 }

TIAMWebApp/Shared/Services/ServiceProviderDataService.cs

@@ -4,7 +4,9 @@ using Microsoft.JSInterop;
 using Newtonsoft.Json;
 using SkiaSharp;
 using System.Net.Http.Json;
+using AyCode.Core.Helpers;
 using AyCode.Services.Loggers;
+using AyCode.Services.SignalRs;
 using TIAM.Core.Loggers;
 using TIAM.Database.DataLayers.Users;
 using TIAM.Entities.Products;
@@ -14,6 +16,8 @@ using TIAMWebApp.Shared.Application.Interfaces;
 using TIAMWebApp.Shared.Application.Models;
 using TIAMWebApp.Shared.Application.Models.ClientSide;
 using TIAMWebApp.Shared.Application.Utility;
+using TIAM.Services;
+using System.Linq;
 
 namespace TIAMWebApp.Shared.Application.Services
 {
@@ -21,13 +25,16 @@ namespace TIAMWebApp.Shared.Application.Services
     {
         private readonly HttpClient http;
         private readonly ISecureStorageHandler secureStorageHandler;
-        private readonly ILogger _logger;
+        private readonly LoggerClient<ServiceProviderDataService> _logger;
-        
 
-        public ServiceProviderDataService(HttpClient http, ISecureStorageHandler secureStorageHandler, IEnumerable<IAcLogWriterClientBase> logWriters)
+        private DevAdminSignalClient _devAdminSignalClient;
+
+        public ServiceProviderDataService(HttpClient http, ISecureStorageHandler secureStorageHandler, DevAdminSignalClient devAdminSignalClient, IEnumerable<IAcLogWriterClientBase> logWriters)
         {
             this.http = http;
             this.secureStorageHandler = secureStorageHandler;
+
+            _devAdminSignalClient = devAdminSignalClient;
             _logger = new LoggerClient<ServiceProviderDataService>(logWriters.ToArray());
         }
 
@@ -70,24 +77,41 @@ namespace TIAMWebApp.Shared.Application.Services
         //17.
         public async Task<Dictionary<Guid, string>?> GetPropertiesByOwnerIdAsync(Guid id)
         {
-            var url = $"{Setting.ApiBaseUrl}/{APIUrls.GetServiceProvidersByOwnerId}";
+            Dictionary<Guid, string>? companyPropertiesByOwner;
-            var response = await http.PostAsJsonAsync(url, id);
+
-            if (response.IsSuccessStatusCode)
+            //_devAdminSignalClient.SendMessageToServerAsync<Dictionary<Guid, string>>(SignalRTags.GetPropertiesByOwnerIdAsync, new SignalRequestByIdMessage(id), response =>
-            {
+            //{
-                var result = await response.Content.ReadFromJsonAsync<Dictionary<Guid, string>>();
+            //    if (response.Status == SignalResponseStatus.Error)
-                string resultString = "";
+            //        return;
-                foreach (var item in result)
+
-                {
+            //    companyPropertiesByOwner = response.ResponseData;
-                    resultString += item.Value + ", ";
+            //    if (companyPropertiesByOwner != null) _logger.DetailConditional($"companyPropertiesByOwner async: {string.Join("; ", companyPropertiesByOwner.Values)}");
-                }
+            //}).Forget();
-                _logger.Debug(resultString);
+
-                return result;
+
-            }
+            companyPropertiesByOwner = await _devAdminSignalClient.SendMessageToServerAsync<Dictionary<Guid, string>>(SignalRTags.GetPropertiesByOwnerIdAsync, new SignalRequestByIdMessage(id));
-            else
+            if (companyPropertiesByOwner != null) _logger.DetailConditional($"companyPropertiesByOwner: {string.Join("; ", companyPropertiesByOwner.Values)}");
-            {
+
-                return null;
+            return companyPropertiesByOwner;
-            }
+
-            
+            //var url = $"{Setting.ApiBaseUrl}/{APIUrls.GetServiceProvidersByOwnerId}";
+            //var response = await http.PostAsJsonAsync(url, id);
+            //if (response.IsSuccessStatusCode)
+            //{
+            //    var result = await response.Content.ReadFromJsonAsync<Dictionary<Guid, string>>();
+            //    string resultString = "";
+            //    foreach (var item in result)
+            //    {
+            //        resultString += item.Value + ", ";
+            //    }
+            //    _logger.DetailConditional(resultString);
+            //    return result;
+            //}
+            //else
+            //{
+            //    return null;
+            //}
+
         }
 
         //18.

TIAMWebApp/Shared/TIAMWebApp.Shared.Application.csproj

@@ -36,6 +36,7 @@
     <ProjectReference Include="..\..\TIAM.Database\TIAM.Database.csproj" />
     <ProjectReference Include="..\..\TIAM.Entities\TIAM.Entities.csproj" />
     <ProjectReference Include="..\..\TIAM.Models\TIAM.Models.csproj" />
+    <ProjectReference Include="..\..\TIAM.Services\TIAM.Services.csproj" />
     <ProjectReference Include="..\..\TIAMResources\TIAM.Resources.csproj" />
   </ItemGroup>