SignalR and Orchard Core 1.8.2, how to use the ChatHub with a JWT Bearer provided by the Orchard Core OpenIddict module

[MarGraz]

Hi everyone,

I'm trying to implement an Orchard Core microservice that uses SignalR for chat functionality. Essentially, the Angular client app will handle most of the front-end work, while Orchard Core 1.8.2 will be used to store the message history. To achieve this, I have installed Microsoft.AspNetCore.SignalR.Common 8.0.10 and created a ChatHub : Hub class to send messages.

However, I encounter a 401 Error whenever I add the [Authorize] attribute to the ChatHub (using the same approach that successfully authenticates my API endpoints). So I tried to remove the Authorize to check if SignalR is working, but I get a SignalR connection error that says: Error connecting to SignalR: Promise.catch.

My environment:

• Orchard Core 1.8.2 Headless, with OpenIddict client active;
• SignalR, Microsoft.AspNetCore.SignalR.Common, version 8.0.10;
• An SSO made using Orchard Core 1.8.2 that works as an OpenIddict server;
• A ChatHub class to manage sending messages (and later saving them in the Orchard Core database).

Questions:

How can I make this work? Is there another way to implement it or an official module? 🤔

Below is some of the code I wrote.

The Program.cs:

var builder = WebApplication.CreateBuilder(args);

builder.Services
    .AddOrchardCms()
    .ConfigureServices(services =>
    {
        ConfigurationModel config = builder.Configuration.Get<ConfigurationModel>();

        if (config == null)
        {
            throw new Exception("Was impossible to retrieve the appsettings.json configuration. Please check the appsettings file.");
        }
        services.AddHttpClient();
    });

builder.Services.AddSignalR();

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseOrchardCore();

// Remove in the API response the header "X-Powered-By: OrchardCore"
app.UsePoweredByOrchardCore(enabled: false);

app.UseEndpoints(endpoints =>
{
    endpoints.MapHub<ChatHub>("/chathub"); // The endpoint for the SignalR hub
});

app.Run();

My ChatHub.cs:

//[Authorize]
 [Authorize(AuthenticationSchemes = "Api"), IgnoreAntiforgeryToken]
 //[Authorize(AuthenticationSchemes = JwtBearerDefaults.AuthenticationScheme)]
 public class ChatHub : Hub
 {
     private readonly IChatHandler _chatHandler;

     public ChatHub(IChatHandler chatHandler)
     {
         _chatHandler = chatHandler;
     }

     // Method to send messages to a specific room
     public async Task SendMessageToRoom(string roomName, string userAId, string userAName, string userBId, string userBName, string message)
     {            
         //TODO Save here the message in the history (OC database)

         // Send the message to all clients in the group (room)
        await Clients.Group(roomName).SendAsync("ReceiveMessage", userAName, message);  // Send username and message           
     }

     public override async Task OnConnectedAsync()
     {
         var userRole = Context.User?.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Role)?.Value;
         var roomName = Context.GetHttpContext().Request.Query["room"];

         // Add the user to a room
         await Groups.AddToGroupAsync(Context.ConnectionId, roomName);

         // TODO Add here the part to retrieve old messages

         await base.OnConnectedAsync();
     }
 }

My Controller.cs to serve the client page:

 [Route("chat")]
 //[Authorize(AuthenticationSchemes = "Api"), IgnoreAntiforgeryToken]
 [ApiController]
 public class TestIndexController : Controller
 {
     private readonly IWebHostEnvironment _env;

     public TestIndexController(IWebHostEnvironment env)
     {
         _env = env;
     }

     // Action that returns static HTML content as a string
     [HttpGet]
     [Route("testClient")]
     public IActionResult StaticPage()
     {
         // Path to the static HTML file in your project folder
         var filePath = Path.Combine(_env.ContentRootPath, "TestClient", "Index.html");

         // Check if file exists
         if (!System.IO.File.Exists(filePath))
         {
             return NotFound("HTML file not found.");
         }

         // Serve the static HTML file
         return PhysicalFile(filePath, "text/html");
     }
 }

My client html:

<!DOCTYPE html>
<html>
<body>

    <h2>SignalR Chat Client</h2>
    <div>
        <label for="token">JWT Token:</label>
        <input type="text" id="token" placeholder="Enter your JWT Token">
    </div>
    <div>
        <label for="userAId">Your User ID:</label>
        <input type="text" id="userAId" placeholder="Enter your user ID">
    </div>
    <div>
        <label for="userAName">Your Name:</label>
        <input type="text" id="userAName" placeholder="Enter your name">
    </div>
    <div>
        <label for="userBId">Recipient's User ID:</label>
        <input type="text" id="userBId" placeholder="Enter recipient's user ID">
    </div>
    <div>
        <label for="userBName">Recipient's Name:</label>
        <input type="text" id="userBName" placeholder="Enter recipient's name">
    </div>
    <div>
        <label for="roomName">Room Name:</label>
        <input type="text" id="roomName" placeholder="Enter the Room Name">
    </div>
    <div>
        <label for="message">Message:</label>
        <input type="text" id="message" placeholder="Enter your message">
    </div>
    <button id="sendMessage">Send Message</button>

    <h3>Messages:</h3>
    <ul id="messagesList"></ul>

    <script src="https://cdnjs.cloudflare.com/ajax/libs/microsoft-signalr/5.0.12/signalr.min.js"></script>

    <script>
    window.onload = function () {
        let connection;

        console.log("Page loaded and script running");

        document.getElementById("sendMessage").addEventListener("click", function () {
            console.log("Button clicked");

            const token = document.getElementById("token").value;
            const userAId = document.getElementById("userAId").value;
            const userAName = document.getElementById("userAName").value;
            const userBId = document.getElementById("userBId").value;
            const userBName = document.getElementById("userBName").value;
            const roomName = document.getElementById("roomName").value;
            const message = document.getElementById("message").value;

            if (!token || !userAId || !userAName || !userBId || !userBName || !roomName || !message) {
                alert("All fields are required: JWT Token, User ID, Your Name, Recipient's User ID, Recipient's Name, Room Name, and Message!");
                return;
            }

            const decodedToken = parseJwt(token);
            console.log("Decoded Token: ", decodedToken);

            const currentTimestamp = Math.floor(Date.now() / 1000);

            if (decodedToken.exp < currentTimestamp) {
                alert("The JWT token has expired. Please generate a new one.");
                return;
            }

            let userRole = decodedToken["http://schemas.microsoft.com/ws/2008/06/identity/claims/role"];

            if (!userRole || (userRole !== "Base User" && userRole !== "Admin" && userRole !== "Developer Admin")) {
                alert("The JWT token must include a valid role ('Base User', 'Admin', or 'Developer Admin').");
                return;
            }

            if (!connection) {
                console.log("Using token for SignalR connection: ", token);

                connection = new signalR.HubConnectionBuilder()
                    .withUrl("https://localhost:44300/chathub?room=" + encodeURIComponent(roomName), {
                        accessTokenFactory: () => {
                            console.log("Token being used: ", token);
                            return token }
                    })
                    .configureLogging(signalR.LogLevel.Trace)  // Detailed logging for troubleshooting
                    .build();

                connection.start()
                    .then(() => {
                        console.log("Connected to SignalR");
                        loadChatHistory();

                        connection.invoke("SendMessageToRoom", roomName, userAId, userAName, userBId, userBName, message)
                            .then(() => {
                                console.log("Message sent to room:", roomName);
                            })
                            .catch(err => {
                                console.error("Error sending message:", err);
                            });
                    })
                    .catch(err => {
                        console.error("Error connecting to SignalR:", err);
                        alert("Failed to connect to SignalR. Please check your authentication.");
                    });

                connection.on("ReceiveMessage", (user, message) => {
                    const msg = document.createElement("li");
                    msg.textContent = `${user}: ${message}`;
                    document.getElementById("messagesList").appendChild(msg);
                });
            } else {
                connection.invoke("SendMessageToRoom", roomName, userAId, userAName, userBId, userBName, message)
                    .then(() => {
                        console.log("Message sent to room:", roomName);
                    })
                    .catch(err => console.error("Error sending message:", err));
            }
        });
    };

    function loadChatHistory() {
        const roomName = document.getElementById("roomName").value;
        connection.invoke("LoadChatHistory", roomName)
            .then(messages => {
                messages.forEach((msg) => {
                    const messageElement = document.createElement("li");
                    messageElement.textContent = `${msg.userName}: ${msg.message}`;
                    document.getElementById("messagesList").appendChild(messageElement);
                });
            })
            .catch(err => console.error("Error loading chat history:", err));
    }

    function parseJwt(token) {
        try {
            const base64Url = token.split('.')[1];
            const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
            const jsonPayload = decodeURIComponent(atob(base64).split('').map(function (c) {
                return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
            }).join(''));

            return JSON.parse(jsonPayload);
        } catch (e) {
            console.error("Error decoding token:", e);
            return null;
        }
    }
    </script>
</body>
</html>

Thank you 😊

[MarGraz]

I made some changes in the index.html page, I removed the history function, and moved the connection variable outside the window.onload.
Now I get this new error:

This is the new Index code:

<!DOCTYPE html>
<html>
<body>

    <h2>SignalR Chat Client</h2>
    <div>
        <label for="token">JWT Token:</label>
        <input type="text" id="token" placeholder="Enter your JWT Token">
    </div>
    <div>
        <label for="userAId">Your User ID:</label>
        <input type="text" id="userAId" placeholder="Enter your user ID">
    </div>
    <div>
        <label for="userAName">Your Name:</label>
        <input type="text" id="userAName" placeholder="Enter your name">
    </div>
    <div>
        <label for="userBId">Recipient's User ID:</label>
        <input type="text" id="userBId" placeholder="Enter recipient's user ID">
    </div>
    <div>
        <label for="userBName">Recipient's Name:</label>
        <input type="text" id="userBName" placeholder="Enter recipient's name">
    </div>
    <div>
        <label for="roomName">Room Name:</label>
        <input type="text" id="roomName" placeholder="Enter the Room Name">
    </div>
    <div>
        <label for="message">Message:</label>
        <input type="text" id="message" placeholder="Enter your message">
    </div>
    <button id="sendMessage">Send Message</button>

    <h3>Messages:</h3>
    <ul id="messagesList"></ul>

    <script src="https://cdnjs.cloudflare.com/ajax/libs/microsoft-signalr/5.0.12/signalr.min.js"></script>

    <script>

        let connection;

        window.onload = function () {

        console.log("Page loaded and script running");

        document.getElementById("sendMessage").addEventListener("click", function () {
            console.log("Button clicked");

            const token = document.getElementById("token").value;
            const userAId = document.getElementById("userAId").value;
            const userAName = document.getElementById("userAName").value;
            const userBId = document.getElementById("userBId").value;
            const userBName = document.getElementById("userBName").value;
            const roomName = document.getElementById("roomName").value;
            const message = document.getElementById("message").value;

            if (!token || !userAId || !userAName || !userBId || !userBName || !roomName || !message) {
                alert("All fields are required: JWT Token, User ID, Your Name, Recipient's User ID, Recipient's Name, Room Name, and Message!");
                return;
            }

            const decodedToken = parseJwt(token);
            console.log("Decoded Token: ", decodedToken);

            const currentTimestamp = Math.floor(Date.now() / 1000);

            if (decodedToken.exp < currentTimestamp) {
                alert("The JWT token has expired. Please generate a new one.");
                return;
            }

            let userRole = decodedToken["http://schemas.microsoft.com/ws/2008/06/identity/claims/role"];

            if (!userRole || (userRole !== "Base User" && userRole !== "Admin" && userRole !== "Developer Admin")) {
                alert("The JWT token must include a valid role ('Base User', 'Admin', or 'Developer Admin').");
                return;
            }

            if (!connection) {
                console.log("Using token for SignalR connection: ", token);

                connection = new signalR.HubConnectionBuilder()
                    .withUrl("https://localhost:44300/chathub?room=" + encodeURIComponent(roomName), {
                        accessTokenFactory: () => {
                            console.log("Token being used: ", token);
                            return token }
                    })
                    .configureLogging(signalR.LogLevel.Trace)  // Detailed logging for troubleshooting
                    .build();

                connection.start()
                    .then(() => {
                        console.log("Connected to SignalR");

                        connection.invoke("SendMessageToRoom", roomName, userAId, userAName, userBId, userBName, message)
                            .then(() => {
                                console.log("Message sent to room:", roomName);
                            })
                            .catch(err => {
                                console.error("Error sending message:", err.message);
                                alert("Failed to send the message: " + err.message);
                            });
                    })
                    .catch(err => {
                        console.error("Failed to connect to SignalR. Error message: ", err.message);
                        alert("Failed to connect to SignalR. Error message: " + err.message);
                    });

                connection.on("ReceiveMessage", (user, message) => {
                    const msg = document.createElement("li");
                    msg.textContent = `${user}: ${message}`;
                    document.getElementById("messagesList").appendChild(msg);
                });
            } else {
                connection.invoke("SendMessageToRoom", roomName, userAId, userAName, userBId, userBName, message)
                    .then(() => {
                        console.log("Message sent to room:", roomName);
                    })
                    .catch(err => console.error("Error sending message:", err));
            }
        });
    };

    function parseJwt(token) {
        try {
            const base64Url = token.split('.')[1];
            const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
            const jsonPayload = decodeURIComponent(atob(base64).split('').map(function (c) {
                return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
            }).join(''));

            return JSON.parse(jsonPayload);
        } catch (e) {
            console.error("Error decoding token:", e);
            return null;
        }
    }
    </script>
</body>
</html>

[Piedone]

While I don't know what happens in your app, I can give two pointers:

• You need to have a service provider scope wrapped around your operations, much like it happens with an HTTP request normally.
• You can debug into OC code even if it comes from NuGet. Just be sure to disable Just My Code in VS, then you can debug it as if it were source.

[MarGraz]

Thank you for your reply @Piedone.

1. What do you mean by needing a "service provider scope"? In my case, ChatHub.cs is part of an Orchard Core module, which is used by the OC Chat microservice (here you can see the Startup of the module). The module uses my ChatHandler.cs, that is inside the Chat microservice, passed in dependency injection, to save the room and messages in the Chat Microservice database.

---

2. I have disabled "Just My Code" in Visual Studio and observed what happens when I call contentManager.CreateAsync() and contentManager.PublishAsync().

During CreateAsync, the execution reaches the await _session.SaveAsync(contentItem); and then returns in my ChatHandler without executing all the code.
Here's the CreateAsync method in DefaultContentManager.cs:

public async Task CreateAsync(ContentItem contentItem, VersionOptions options)
{
	if (string.IsNullOrEmpty(contentItem.ContentItemVersionId))
	{
		contentItem.ContentItemVersionId = _idGenerator.GenerateUniqueId(contentItem);
		contentItem.Published = true;
		contentItem.Latest = true;
	}
	if (options.IsDraft)
	{
		contentItem.Published = false;
	}
	CreateContentContext context2 = new CreateContentContext(contentItem);
	await Handlers.InvokeAsync((IContentHandler handler, CreateContentContext context) => handler.CreatingAsync(context), context2, _logger);

	await _session.SaveAsync(contentItem);  // --- From here it returns in my ChatHandler, without executing the code below 
	                              // (the breakpoint on "_contentManagerSession.Store(contentItem)" is never hitted)

	_contentManagerSession.Store(contentItem);
	await ReversedHandlers.InvokeAsync((IContentHandler handler, CreateContentContext context) => handler.CreatedAsync(context), context2, _logger);
	if (options.IsPublished)
	{
		PublishContentContext publishContext = new PublishContentContext(contentItem, null);
		await Handlers.InvokeAsync((IContentHandler handler, PublishContentContext context) => handler.PublishingAsync(context), publishContext, _logger);
		await ReversedHandlers.InvokeAsync((IContentHandler handler, PublishContentContext context) => handler.PublishedAsync(context), publishContext, _logger);
	}
} 

Going deeper in the code, in the SaveAsync method in Session.cs, the execution continues as expected, assigning a new Id and returning. Here the code:

public async Task SaveAsync(object entity, bool checkConcurrency = false, string collection = null)
{
	SessionState state = GetState(collection);
	CheckDisposed();
	if (state.Saved.Contains(entity) || state.Updated.Contains(entity))
	{
		return;
	}
	state.Tracked.Remove(entity);
	if (state.IdentityMap.TryGetDocumentId(entity, out var id))
	{
		state.Updated.Add(entity);
		if (checkConcurrency || _store.Configuration.ConcurrentTypes.Contains(entity.GetType()))
		{
			state.Concurrent.Add(id);
		}
		return;
	}
	IAccessor<long> accessor = _store.GetIdAccessor(entity.GetType());
	if (accessor != null)
	{
		id = accessor.Get(entity);
		if (id > 0)
		{
			state.IdentityMap.AddEntity(id, entity);
			state.Updated.Add(entity);
			if (checkConcurrency || _store.Configuration.ConcurrentTypes.Contains(entity.GetType()))
			{
				state.Concurrent.Add(id);
			}
			return;
		}
	}
	id = await _store.GetNextIdAsync(collection);
	state.IdentityMap.AddEntity(id, entity);
	accessor?.Set(entity, id);
	state.Saved.Add(entity);
}

Instead in the PublishAsync() method in DefaultContentManager.cs, it returns at the first if (contentItem.Published), here the code:

	public async Task PublishAsync(ContentItem contentItem)
	{
		if (contentItem.Published) // --- returns here
		{
			return;
		}
		ContentItem previous = await _session.Query<ContentItem, ContentItemIndex>((ContentItemIndex x) => x.ContentItemId == contentItem.ContentItemId && x.Published).FirstOrDefaultAsync();
		PublishContentContext context2 = new PublishContentContext(contentItem, previous);
		await Handlers.InvokeAsync((IContentHandler handler, PublishContentContext context) => handler.PublishingAsync(context), context2, _logger);
		if (!context2.Cancel)
		{
			if (previous != null)
			{
				await _session.SaveAsync(previous, checkConcurrency: true);
				previous.Published = false;
			}
			contentItem.Published = true;
			await _session.SaveAsync(contentItem, checkConcurrency: true);
			await ReversedHandlers.InvokeAsync((IContentHandler handler, PublishContentContext context) => handler.PublishedAsync(context), context2, _logger);
		}
	}

Questions:

• I suspect the issue may be related to authentication, as our entry point is the ChatHub, called by the client via SignalR, inside the Orchard Core module. The user is authenticated here, but when execution continues in the ChatHandler, the Author and Owner fields seem to be missing, as I noted here. Is there another way to implement SignalR? 🤔

• Is there a different method to perform OpenIddict authentication with SignalR in an Orchard Core module? Perhaps @kevinchalet can provide some helpful insights 🤷‍♂️

Thank you

Below is the method I use to save my ChatRoom

This is where I call the Orchard Core's CreateAsync and PublishAsync:

   public async Task<ApiResult<ChatRoomApiModel>> CreateChatRoomAsync(ChatRoomApiModel model)
   {
       _logger.LogInformation($"{nameof(ChatHandler)}-{nameof(CreateChatRoomAsync)} started.");

       // Step 1: Validate the model
       if (string.IsNullOrEmpty(model.RoomName) || string.IsNullOrEmpty(model.UserAId) || string.IsNullOrEmpty(model.UserBId))
       {
           _logger.LogError($"{nameof(ChatHandler)}-{nameof(CreateChatRoomAsync)}: Invalid data. RoomName: {model.RoomName}, UserAId: {model.UserAId}, UserBId: {model.UserBId}");
           return new ApiResult<ChatRoomApiModel>(HttpStatusCode.BadRequest, "Invalid data.");
       }

       // Step 2: Check if the room already exists (it uses the "YesSql.ISession" in DI and an abstract class with the method you see here)
       var roomContentItemId = await GetContentItemIdByContentTypeNameAndMultipleContentFieldValuesAsync(
           nameof(ChatRoom),
           new Dictionary<string, string> {
               { nameof(ChatRoom.RoomName), model.RoomName },
               { nameof(ChatRoom.UserAId), model.UserAId },
               { nameof(ChatRoom.UserBId), model.UserBId }
           });

       if (!string.IsNullOrEmpty(roomContentItemId))
       {
           _logger.LogWarning($"{nameof(ChatHandler)}-{nameof(CreateChatRoomAsync)}: Room {model.RoomName} already exists.");
           return new ApiResult<ChatRoomApiModel>(HttpStatusCode.Conflict, "Room already exists.");
       }

       // Step 3: Create a new content item for ChatRoom
       var contentItem = await _contentManager.NewAsync(nameof(ChatRoom));

       if (contentItem == null)
       {
           _logger.LogError($"{nameof(ChatHandler)}-{nameof(CreateChatRoomAsync)}: Failed to create new content item for ChatRoom.");
           return new ApiResult<ChatRoomApiModel>(HttpStatusCode.InternalServerError, "Failed to create ChatRoom.");
       }

       // Step 4: Map the API model to the content part
       contentItem.Alter<ChatRoom>(part => part.FromApiModel(model));

       // Step 5: Handle the BagPart (empty for now)
       contentItem.Alter<BagPart>(x => x.ContentItems.Clear());

       // Step 6: Save and publish the content item
       _logger.LogInformation($"{nameof(ChatHandler)}-{nameof(CreateChatRoomAsync)}: Attempting to create and publish content item.");
       await _contentManager.CreateAsync(contentItem, VersionOptions.Published);
       await _contentManager.PublishAsync(contentItem);

       _logger.LogInformation($"{nameof(ChatHandler)}-{nameof(CreateChatRoomAsync)}: Successfully created ChatRoom with ID: {contentItem.ContentItemId}");

       // Step 7: Return the updated model
       model.ContentItemId = contentItem.ContentItemId;
       return new ApiResult<ChatRoomApiModel>(HttpStatusCode.OK, model);
   }

These are my models. For brevity, I only included the content type extension methods, which make it clear what is inside the ChatRoomApiModel and ChatMessageApiModel.

The ChatRoom model:

    public class ChatRoom : ContentPart
    {
        public TextField RoomName { get; set; } = new();
        public TextField UserAId { get; set; } = new();
        public TextField UserAName { get; set; } = new();
        public TextField UserBId { get; set; } = new();
        public TextField UserBName { get; set; } = new();
    }

    public static class ChatRoomExtensions
    {
        public static ChatRoom FromApiModel(this ChatRoom part, ChatRoomApiModel apiModel)
        {
            if (part == null || apiModel == null) return null;

            part.RoomName.Text = apiModel.RoomName;
            part.UserAId.Text = apiModel.UserAId;
            part.UserAName.Text = apiModel.UserAName;
            part.UserBId.Text = apiModel.UserBId;
            part.UserBName.Text = apiModel.UserBName;

            return part;
        }

        public static ChatRoomApiModel ToApiModel(this ChatRoom part, ContentItem contentItem)
        {
            if (part == null) return null;

            return new ChatRoomApiModel
            {
                ContentItemId = part.ContentItem.ContentItemId,
                RoomName = part.RoomName.Text,
                UserAId = part.UserAId.Text,
                UserAName = part.UserAName.Text,
                UserBId = part.UserBId.Text,
                UserBName = part.UserBName.Text
            };
        }
    }

The ChatMessage model:

    public class ChatMessage : ContentPart
    {
        public TextField UserName { get; set; } = new();
        public TextField Message { get; set; } = new();
    }

    public static class ChatMessageExtensions
    {
        public static ChatMessage FromApiModel(this ChatMessage part, ChatMessageApiModel apiModel)
        {
            if (part == null || apiModel == null) return null;

            part.UserName.Text = apiModel.UserName;
            part.Message.Text = apiModel.Message;

            return part;
        }

        public static ChatMessageApiModel ToApiModel(this ChatMessage part, ContentItem contentItem)
        {
            if (part == null) return null;

            return new ChatMessageApiModel
            {
                ContentItemId = part.ContentItem.ContentItemId,
                UserName = part.UserName.Text,
                Message = part.Message.Text
            };
        }
    }

[Piedone]

Note that I have no idea how SignalR works under the hood. So, just a general tip: where OC wraps the whole request into a shell's DI container scope is here:

OrchardCore/src/OrchardCore/OrchardCore/Modules/ModularTenantContainerMiddleware.cs

Line 58 in 1fb3287

await shellScope.UsingAsync(async scope =>

For SignalR, you'd need something similar. This is the bedrock: if you don't have something like this, nothing will behave as they should. Since I presume SignalR operations don't go through middlewares (right?), you need to manage the lifecycle somehow else.

Do you do this already?

[MarGraz]

@Piedone thank you for your reply and for explaining the DI container.

But how can I wrap SignalR in a scope, if it is already used in a dedicated module in my case? Could you guide me? I'll share the Startup.cs below and try to provide some context.

We have an OC 1.8.2 microservice with a handler class (ChatHandler) that saves messages and rooms to the OC microservice DB. SignalR is used through an OC module that we referenced and activated in the microservice Features. This SignalR module only receives JS calls from the frontend and then uses the ChatHandler class from the microservice, to save messages or rooms.

This is the Startup.cs for the SignalR module, where you can also see the UseEndpoints for the ChatHub : Hub class, with IChatHandler passed in DI (is this the problem? Do I need to instantiate IChatHandler in the module? 🤔 I think is not):

using Bookstore.Module.SignalR.OurHub;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.IdentityModel.Tokens;

namespace Bookstore.Module.SignalR
{
    public class Startup : StartupBase
    {
        public override void ConfigureServices(IServiceCollection services)
        {
            services.AddAuthentication()
                .AddJwtBearer("ChatHub", options =>
                {
                    // Configure validation Authority
                    options.Authority = "http://host.docker.internal:12103/";  // URL OpenIddict server
                    options.Audience = "oct:Default";  // Orchard Core Tenant Default audience (as shown in the JWT token)

                    options.RequireHttpsMetadata = false;  // TODO: Remove for production

                    // Configure token validation
                    options.TokenValidationParameters = new TokenValidationParameters
                    {
                        ValidateIssuer = true,
                        ValidateAudience = true,
                        ValidateLifetime = true
                    };
                });

            // Register SignalR services in Orchard Core
            services.AddSignalR();
        }

        public override void Configure(IApplicationBuilder app)
        {
            // Use endpoint routing to map the SignalR hubs
            app.UseEndpoints(endpoints =>
            {
                // Map the SignalR hub for chat
                endpoints.MapHub<ChatHub>("/chathub");
            });
        }
    }
}

After several trials, I’m confident the issue lies in the way we’re handling Authentication in Startup.cs. 🫠

For example, if an admin hasn’t logged into the chat microservice backoffice, the ChatHub : Hub class can access my ChatHandler, but when it tries to instantiate a new Content Item with await _contentManager.NewAsync(nameof(ChatRoom));, it returns this error: System.ArgumentNullException: 'Value cannot be null. Arg_ParamName_Name'. This happens at this line (this is OC code, not mine), because contentTypeDefinition is null, even though the content type exists.

HOWEVER, if I log in with my Admin user to the backoffice and send a chat message from the client to ChatHub, it successfully performs await _contentManager.NewAsync(nameof(ChatRoom)); in the microservice, but the created ContentItem has Author and Owner set to null 🤔, see the screenshot below (this is my ChatHandler.cs > CreateChatRoomAsync() code):

Following this, the Content Item is not created in the microservice backoffice and DB, as I already described here.

I suspect the issue is related to our Authentication process, but we might need help from @kevinchalet to identify exactly where the Auth flow in the OC module Startup.cs might be going wrong. What do you think @Piedone?

Thank you

[Piedone]

Sorry, but without learning SignalR, what I otherwise don't need now, I won't be able to help. I hope though that you can get to the bottom of this.

[MarGraz]

💡The problem seems to be if I pass my IChatHandler in DI, inside the ChatHub class. If I remove it, SignalR works.
The error I get:

Microsoft.AspNetCore.SignalR.HubConnectionHandler: Error: Error when dispatching 'OnConnectedAsync' on hub.

System.InvalidOperationException: Unable to resolve service for type 'Bookstore.Chat.Handlers.Interfaces.IChatHandler' while attempting to activate 'Bookstore.Chat.OurHub.ChatHub'.
   at Microsoft.Extensions.DependencyInjection.ActivatorUtilities.ThrowHelperUnableToResolveService(Type type, Type requiredBy)
   at lambda_method143(Closure, IServiceProvider, Object[])
   at Microsoft.AspNetCore.SignalR.Internal.DefaultHubActivator`1.Create()
   at Microsoft.AspNetCore.SignalR.Internal.DefaultHubDispatcher`1.OnConnectedAsync(HubConnectionContext connection)
   at Microsoft.AspNetCore.SignalR.Internal.DefaultHubDispatcher`1.OnConnectedAsync(HubConnectionContext connection)
   at Microsoft.AspNetCore.SignalR.HubConnectionHandler`1.RunHubAsync(HubConnectionContext connection)
OrchardCore.Modules.ModularTenantRouterMiddleware: Information: Begin Routing Request
The thread '[Thread Destroyed]' (15332) has exited with code 0 (0x0).

I initialize my ChatHandler in the Program.cs, as showed below, but it seems that is not passed automatically to the ChatHub class.

var builder = WebApplication.CreateBuilder(args);

builder.Services
    .AddOrchardCms()
    .ConfigureServices(services =>
    {
        ConfigurationModel config = builder.Configuration.Get<ConfigurationModel>();

        if (config == null)
        {
            throw new Exception("Was impossible to retrieve the appsettings.json configuration. Please check the appsettings file.");
        }

        services.AddHttpClient();

        // Add Parts
        
        services.AddContentPart<ChatMessage>();
        services.AddContentPart<ChatRoom>();
        
        // Add Handlers
        
        services.AddScoped<IChatHandler, ChatHandler>(x => new ChatHandler(x.GetRequiredService<IContentManager>(), x.GetRequiredService<YesSql.ISession>(), x.GetRequiredService<ILogger<ChatHandler>>()));        
    });

builder.Services.AddSignalR();

[...]

app.UseEndpoints(endpoints =>
{
    endpoints.MapHub<ChatHub>("/chathub"); // The endpoint for the SignalR hub
});

app.Run();

@Piedone @hishamco do you know how can I pass in dependency injection my ChatHandler, to the SignalR ChatHub class?

Thank you

[MarGraz]

I was able to fix the Dependency Injection problem

I created an Orcahrd Core Module with SignalR and my ChatHub class inside.

First of all

I removed all the SignalR parts from my Chat microservice Program.cs (here the first version):

var builder = WebApplication.CreateBuilder(args);

builder.Services
    .AddOrchardCms()
    .ConfigureServices(services =>
    {
        ConfigurationModel config = builder.Configuration.Get<ConfigurationModel>();

        if (config == null)
        {
            throw new Exception("Was impossible to retrieve the appsettings.json configuration. Please check the appsettings file.");
        }
        
        services.AddHttpClient();
        
          // Add Parts
        
        services.AddContentPart<ChatMessage>();
        services.AddContentPart<ChatRoom>();
        
        // Add Handlers
        
        services.AddScoped<IChatHandler, ChatHandler>(x => new ChatHandler(x.GetRequiredService<IContentManager>(), x.GetRequiredService<YesSql.ISession>(), x.GetRequiredService<ILogger<ChatHandler>>()));      
    });

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseOrchardCore();

// Remove in the API response the header "X-Powered-By: OrchardCore"
app.UsePoweredByOrchardCore(enabled: false);

app.Run();

Then

In the solution, I created a new Razor MVC Project called Bookstore.SignalR (basically an Orchard Core Module), with the packages Microsoft.AspNetCore.SignalR.Common 8.0.10 and OrchardCore.Module.Targets 1.8.3 installed. I deleted all the folders Controllers, Models and Views. Then I referenced a common project where I moved the IChatHandler interface so it could be available for both: the module, and the chat project.

Here is the Bookstore.SignalR csproj:

<Project Sdk="Microsoft.NET.Sdk.Razor">

	<PropertyGroup>
		<TargetFramework>net8.0</TargetFramework>
		<AddRazorSupportForMvc>true</AddRazorSupportForMvc>
		<Nullable>enable</Nullable>
		<ImplicitUsings>enable</ImplicitUsings>
	</PropertyGroup>

	<ItemGroup>
		<FrameworkReference Include="Microsoft.AspNetCore.App" />
	</ItemGroup>

	<ItemGroup>
		<PackageReference Include="Microsoft.AspNetCore.SignalR.Common" Version="8.0.10" />
		<PackageReference Include="OrchardCore.Module.Targets" Version="1.8.3" />
	</ItemGroup>

	<ItemGroup>
		<ProjectReference Include="..\Bookstore.Common\Bookstore.Common.csproj" />
	</ItemGroup>

</Project>

In Bookstore.SignalR project (Module)

I created ChatHub.cs, a Startup.cs and a Manifest.cs, below you can find the code.
The ChatHub.cs with the IChatHandler in injection (is the same as the previous version):

using Bookstore.Common;

namespace Bookstore.SignalR 
{
 public class ChatHub : Hub
 {
     private readonly IChatHandler _chatHandler;

     public ChatHub(IChatHandler chatHandler)
     {
         _chatHandler = chatHandler;
     }

     // Method to send messages to a specific room
     public async Task SendMessageToRoom(string roomName, string userAId, string userAName, string userBId, string userBName, string message)
     {            
         //TODO Save here the message in the history (OC database)

         // Send the message to all clients in the group (room)
        await Clients.Group(roomName).SendAsync("ReceiveMessage", userAName, message);  // Send username and message           
     }

     public override async Task OnConnectedAsync()
     {
         var userRole = Context.User?.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Role)?.Value;
         var roomName = Context.GetHttpContext().Request.Query["room"];

         // Add the user to a room
         await Groups.AddToGroupAsync(Context.ConnectionId, roomName);

         // TODO Add here the part to retrieve old messages

         await base.OnConnectedAsync();
     }
  }
 }

The Startup.cs into the Bookstore.SignalR module:

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;

namespace Bookstore.SignalR
{
    public class Startup : StartupBase
    {
        // This method is for registering services
        public override void ConfigureServices(IServiceCollection services)
        {
            // Register SignalR services in Orchard Core
            services.AddSignalR();
        }

        // This method configures the middleware pipeline
        public override void Configure(IApplicationBuilder app)
        {
            // Use endpoint routing to map the SignalR hubs
            app.UseEndpoints(endpoints =>
            {
                // Map the SignalR hub for chat
                endpoints.MapHub<ChatHub>("/chathub");
            });
        }
    }
}

Manifest.cs class:

using OrchardCore.Modules.Manifest;

[assembly: Module(
    Name = "Module SignalR",
    Author = "MarGraz",
    Website = "",
    Version = "0.0.1",
    Description = "Module that contains SignalR to use the OrchardCore services passed in DI.",
    Dependencies = new[] { "OrchardCore" },
    Category = "Real-time Communication"
)]

In my Chat microservice

I added a reference to the project Bookstore.SignalR and I started it. In the menu "Configurations" > "Features", I activated my SignalR module. Then using my html client, I sent a chat message, and the ChatHub was able to resolve the IChatHandler correctly in DI.

Next step

Now that SignalR is working inside Orchard Core and I was able to pass my handler in DI, the next step is to fix the Authorization problem.

Thank you

[Piedone]

Sorry, but I have zero experience with SignalR.

[MarGraz]

@Piedone don't worry, I solved the problem with the DI creating a Module, now I have problems with the Authorization. I will update the discussion in a while 😊