In this article, we show how you can separate your application's resources by workspaces—just like you see in platforms such as GitHub, Bitbucket, or Trello, where you can create different repositories or boards under different workspaces.

We implemented workspace management in a generic and reusable way, inspired by how ABP implements tenant management. Just as ABP automatically filters and separates data for each tenant, our approach does the same for workspaces—making it easy to keep data isolated and organized.

✅ Demo

In this sample, we created three offices as workspaces:

• Wafi Solutions BD
• Wafi Solutions UK
• Wafi Solutions KSA

We then created employees under each office. This implementation demonstrates how easily you can manage and separate resources (like employees) under different workspaces.

After completing these steps, your ABP application will have a fully functioning workspace management system that:

1. Isolates data between workspaces
2. Provides workspace management UI
3. Handles workspace-based routing
4. Works seamlessly with ABP's existing features

Users can:

• Create new workspaces
• Switch between workspaces
• Manage employees under workspace.

🏗️ Architecture Overview

The solution consists of two primary modules:

1. Wafi.Abp.Workspaces.Core Core module that provides the fundamental workspace management capabilities:

   • Workspace entity definitions and interfaces
   • Middleware for workspace resolution from HTTP headers
   • EF Core integration through custom DbContext
   • Data filtering based on current workspace

2. Wafi.Abp.Workspaces.Web UI components and controllers for workspace management in ABP web applications:

   • Workspace selector UI components
   • HTTP interceptors for automatic workspace header injection
   • Management interface for workspace configuration

🔧 How It Works

The workspace system implements data isolation within your company similar to ABP's multi-tenancy, but at a more granular level - enabling teams, departments, or projects to have their own isolated workspaces within the same tenant.

Core Components and Their Interactions

1. Entity Integration with IWorkspace.cs: This simple interface marks entities that should be segregated by workspace. Any entity implementing IWorkspace will automatically be filtered by the current workspace context.

// IWorkspace interface definition
public interface IWorkspace
{
    Guid? WorkspaceId { get; set; }
}

2. HTTP Request Processing with WorkspaceResolutionMiddleware.cs: This ASP.NET Core middleware intercepts all incoming requests to determine the current workspace context. It works in the request pipeline to:
   • Extract workspace information from HTTP headers
   • Set the current workspace for the duration of the request
   • Apply workspace context to all downstream operations

// Key part of the middleware
public async Task InvokeAsync(HttpContext context, RequestDelegate next)
{
    var workspaceResolveContext = new WorkspaceResolveContext(context);

    // Try resolving workspace from various sources
    foreach (var workspaceResolver in _options.WorkspaceResolvers)
    {
        await workspaceResolver.ResolveAsync(workspaceResolveContext);
        if (workspaceResolveContext.WorkspaceId.HasValue) break;
    }

    // Apply workspace context for the request duration
    if (workspaceResolveContext.WorkspaceId.HasValue)
    {
        using (_currentWorkspace.Change(workspaceResolveContext.WorkspaceId.Value))
        {
            await next(context);
        }
    }
    else
    {
        await next(context);
    }
}

3. Header-Based Resolution with WorkspaceIdHeaderResolveContributor.cs: This component extracts the workspace ID from the HTTP header (X-Workspace-Id), enabling seamless workspace resolution for API requests.

// Workspace ID Header Resolver
public class WorkspaceIdHeaderResolveContributor : IWorkspaceResolveContributor, ITransientDependency
{
    public const string HeaderName = "X-Workspace-Id";
    public const string ContributorName = "WorkspaceIdHeader";

    public Task ResolveAsync(IWorkspaceResolveContext context)
    {
        var httpContext = context.GetHttpContext();
        if (httpContext == null) return Task.CompletedTask;

        var workspaceIdHeader = httpContext.Request.Headers[HeaderName];
        if (workspaceIdHeader.Count == 0 || string.IsNullOrWhiteSpace(workspaceIdHeader[0]))
            return Task.CompletedTask;

        if (Guid.TryParse(workspaceIdHeader[0], out var workspaceId))
        {
            context.WorkspaceId = workspaceId;
        }
        
        return Task.CompletedTask;
    }
}

4. Data Filtering with WorkspaceDbContextBase.cs: This specialized DbContext provides automatic data filtering for all workspace-aware entities by:
   • Automatically applying the current workspace ID to new entities
   • Preventing accidental workspace ID modifications
   • Filtering query results to only show data from the current workspace

// Simplified version of WorkspaceDbContextBase filter expression
protected override Expression<Func<TEntity, bool>> CreateFilterExpression<TEntity>(ModelBuilder modelBuilder)
{
    // Get base filter from ABP
    var baseExpression = base.CreateFilterExpression<TEntity>(modelBuilder);
    
    // Skip if entity doesn't implement IWorkspace
    if (!typeof(IWorkspace).IsAssignableFrom(typeof(TEntity)))
    {
        return baseExpression;
    }

    // Find the workspace ID property
    var prop = modelBuilder.Entity<TEntity>()
        .Metadata.FindProperty(nameof(IWorkspace.WorkspaceId))!;
    
    var columnName = prop.GetColumnName() ?? prop.Name;

    // Create workspace filter: only show entities from current workspace
    Expression<Func<TEntity, bool>> workspaceFilter = e =>
        !IsMultiWorkspaceFilterEnabled
        || CurrentWorkspace.Id == null
        || EF.Property<Guid?>(e, columnName) == CurrentWorkspace.Id;

    // Combine with existing filters
    if (baseExpression == null) return workspaceFilter;
    return QueryFilterExpressionHelper.CombineExpressions(baseExpression, workspaceFilter);
}

5. Client-Side Integration with http-interceptor.js: This JavaScript component automatically includes the current workspace ID in all AJAX requests, ensuring seamless workspace context propagation from UI to API calls.

// Automatically included from http-interceptor.js
function getWorkspaceId() {
    return localStorage.getItem('selectedWorkspaceId');
}

jQuery(document).ajaxSend(function (event, xhr, settings) {
    const workspaceId = getWorkspaceId();
    if (workspaceId) {
        xhr.setRequestHeader('X-Workspace-Id', workspaceId);
    }
});

The system integrates seamlessly with ABP's existing multi-tenancy, allowing:

• Multi-tenant applications with workspace isolation within each tenant
• Single-tenant applications with departmental/team separation
• Combinations where some data is tenant-specific and some is workspace-specific

⚙️ Implementation Steps

Follow these steps to integrate Workspaces into your ABP application.

🔹 Step 1: Add the Workspace in your Entities

1. Add the Workspace packages in domain layer:

dotnet add package Wafi.Abp.Workspaces.Core

2. Add the module dependencies in your modules:

[DependsOn(
    typeof(WafiAbpWorkspaceModule)
)]
public class YourAppDomainModule : AbpModule
{
    // ...
}

3. Make Your Entities Workspace-Aware

Use the IWorkspace interface in your entities where you want to enable the workspace feature. This is very similar to IMultitenant, making integration straightforward:

// IWorkspace interface definition
public interface IWorkspace
{
    Guid? WorkspaceId { get; set; }
}

// Example implementation
public class YourEntity : FullAuditedAggregateRoot<Guid>, IMultiTenant, IWorkspace
{
    public Guid? TenantId { get; set; }
    public Guid? WorkspaceId { get; set; }
    
    // Your existing entity properties
}

🔹 Step 2: Configure Your Entity Framework Core Context

1. Change the base class of your DbContext from AbpDbContext to WorkspaceDbContextBase.
2. Add builder.ConfigureWorkspaces(); in the OnModelCreating method to register workspace-related entities and configurations.
3. Run a new migration and update the database to apply the necessary schema changes.

public class YourAppDbContext : WorkspaceDbContextBase<YourAppDbContext>
{
    public YourAppDbContext(DbContextOptions<YourAppDbContext> options) 
        : base(options)
    {
    }

    protected override void OnModelCreating(ModelBuilder builder)
    {
        base.OnModelCreating(builder);

        // Register workspace-related entity mappings and configurations
        builder.ConfigureWorkspaces();

        // Your existing model configuration
    }
}

The WorkspaceDbContextBase handles:

• Applying the current workspace ID to new entities
• Preventing workspace ID modifications in existing entities
• Filtering queries based on the current workspace context

// Example of SaveChanges method in WorkspaceDbContextBase
public override int SaveChanges(bool acceptAllChangesOnSuccess)
{
    ApplyCurrentWorkspaceId();
    return base.SaveChanges(acceptAllChangesOnSuccess);
}

private void ApplyCurrentWorkspaceId()
{
    if (CurrentWorkspace?.Id == null) return;

    var currentWorkspaceId = CurrentWorkspace.Id.Value;

    foreach (var entry in ChangeTracker.Entries()
        .Where(e =>
            e.Entity is IWorkspace &&
            (e.State == EntityState.Added || e.State == EntityState.Modified)))
    {
        // Stamp the FK column via EF Core API
        entry.Property(nameof(IWorkspace.WorkspaceId)).CurrentValue = currentWorkspaceId;

        if (entry.State == EntityState.Modified)
        {
            // Prevent accidental overwrites
            entry.Property(nameof(IWorkspace.WorkspaceId)).IsModified = false;
        }
    }
}

🔹 Step 3: Set Up Workspace Management UI

1. Add the Workspace packages in web layer:

dotnet add package Wafi.Abp.Workspaces.Web

2. Add the module dependencies in your modules:

[DependsOn(
    typeof(WorkspacesWebModule)
)]
public class YourWebModule : AbpModule
{
    // ...
}

3. Add the Workspace Selector in the leptonx topbar container:

public override void ConfigureServices(ServiceConfigurationContext context)
{
    public class YourToolbarContributor : IToolbarContributor
    {
        public async Task ConfigureToolbarAsync(IToolbarConfigurationContext context)
        {
            if (context.Toolbar.Name == LeptonXLiteToolbars.Main)
            {
                if (context.ServiceProvider.GetRequiredService<ICurrentUser>().IsAuthenticated)
                {
                    context.Toolbar.Items.AddFirst(new ToolbarItem(typeof(WorkspaceSelectorViewComponent)));
                }
            }
        }
    }
}

The workspace selector will now appear in your application's topbar, providing:

• A dropdown to switch between workspaces
• Visual indication of the current workspace
• Quick access to workspace management
• Seamless integration with ABP's LeptonXLite theme

📚 Additional Resources

For a deeper understanding of the module's implementation, architecture decisions, and advanced customization options, see:

• Full Module Source Code
• Sample Project

This guide demonstrates how to integrate Microsoft's Semantic Kernel SDK with the ABP.io framework. It includes a wrapper implementation to help you create AI-powered plugins for your ABP application services in a clean, modular way.

🏗️ Architecture Overview

The solution consists of two primary modules:

1. WafiOpenAISemanticKernelModule Core module that provides integration with Semantic Kernel.

2. WafiSmartHRAIPluginModule Sample implementation module demonstrating how to create AI plugins for business entities.

⚙️ Implementation Steps

Follow these steps to integrate Semantic Kernel into your ABP application.

🔹 Step 1: Add the Package to Your HttpApi Project

1. Add the Semantic Kernel wrapper package:

dotnet add YourApp.HttpApi.csproj package Wafi.Abp.OpenAISemanticKernel

2. Add the module dependency and configure Semantic Kernel options: This connects your ABP module with the Semantic Kernel framework and sets up OpenAI credentials.

[DependsOn(
    // your existing dependencies
    typeof(WafiOpenAISemanticKernelModule)
)]
public class YourAppHttpApiModule : AbpModule
{
    public override void ConfigureServices(ServiceConfigurationContext context)
    {
        var configuration = context.Services.GetConfiguration();

        Configure<WafiOpenAISemanticKernelOptions>(options =>
        {
            options.ModelId = configuration.GetValue<string>("SemanticKernel:OpenAI:ModelId");
            options.ApiKey = configuration.GetValue<string>("SemanticKernel:OpenAI:ApiKey");
        });
    }
}

3. Add the following configuration to your appsettings.json:

{
  "SemanticKernel": {
    "OpenAI": {
      "ApiKey": "your-openai-key",
      "ModelId": "gpt-4"
    }
  }
}

✅ This exposes the /api/OpenAISemanticKernel/ai/ask endpoint automatically, which the chat interface will use to interact with Semantic Kernel.

🔹 Step 2: Implement a Chat Interface

In your Web project, create a chat interface to interact with the /ai/ask API. You can refer to the host/Wafi.SmartHR.Web project for a sample implementation.

🔹 Step 3: Build Plugins to Connect ABP Services with Semantic Kernel

1. Add dependencies to the plugin project:

dotnet add package Wafi.Abp.OpenAISemanticKernel
dotnet add reference ../YourApp.Application/YourApp.Application.csproj

Add this to your plugin module class:

[DependsOn(typeof(YourAppApplicationModule))]
public class YourAppAIPluginModule : AbpModule
{
    // ...
}

2. Create AI Plugins for Your Entities

Each plugin class should clearly describe what the AI will get when calling its methods.

📄 Example: YourEntityPlugin.cs

public class YourEntityPlugin : ApplicationService, ITransientDependency
{
    private readonly IYourEntityAppService _entityService;
    private readonly IAuthorizationService _authorizationService;

    public YourEntityPlugin(
        IYourEntityAppService entityService,
        IAuthorizationService authorizationService)
    {
        _entityService = entityService;
        _authorizationService = authorizationService;
    }

    [KernelFunction]
    [Description("Search for entities by name or any relevant property using a keyword or phrase")]
    public async Task<string> SearchEntitiesAsync(string filter)
    {
        if (!await _authorizationService.IsGrantedAsync(YourPermissions.Default))
        {
            return "You are not authorized to access this data";
        }

        var entities = await _entityService.GetListAsync(filter);
        
        if (entities is null || entities.Items.Count == 0)
        {
            return $"No entities found for filter '{filter}'";
        }

        return JsonSerializer.Serialize(entities);
    }
}

🧠 Be sure to give a meaningful [Description] so that the AI knows exactly what this method does.

3. Create a Plugin Provider

Create a provider class to register your plugin with Semantic Kernel. This is a crucial step that makes your plugin discoverable by the AI system.

using Wafi.Abp.OpenAISemanticKernel.Plugins;
using YourApp.AI.Plugin.YourEntities;

namespace YourApp.AI.Plugin
{
    public class YourEntityPluginProvider : SemanticPluginProviderBase<YourEntityPlugin>, IWafiPluginProvider
    {
        public YourEntityPluginProvider(YourEntityPlugin plugin) : base(plugin) { }

        public override string Name => "Your Plugin Name";
    }
}

🔐 Authorization

All requests are protected by ABP's permission system. If a user doesn't have the required permissions, they will receive an appropriate message:

⚠️ You are not authorized to access this data.

The authorization check is performed in each plugin method:

if (!await _authorizationService.IsGrantedAsync(YourPermissions.Default))
{
    return "You are not authorized to access this data";
}

✅ Final Outcome

After completing these steps, your ABP application will have a fully functioning AI assistant powered by Semantic Kernel.

The AI interface can be accessed through the /askai endpoint in your web application. When users send questions to this endpoint, the system:

1. Processes the natural language query
2. Determines which registered plugins can fulfill the request
3. Calls the appropriate application services through the plugins
4. Returns formatted results to the user

Example 1: Employee List Query

Request:

POST /askai
Content-Type: application/json

{
    "question": "Give me the list of employees"
}

Response:

Here is the list of employees: John Doe - Email: john.doe@example.com - Phone: 1234567890 - Date of Birth: January 1, 1990 - Joining Date: January 1, 2020 - Total Leave Days: 20 - Remaining Leave Days: 20. Jane Smith - Email: jane.smith@example.com - Phone: 0987654321 - Date of Birth: February 1, 1991 - Joining Date: February 1, 2021 - Total Leave Days: 20 - Remaining Leave Days: 15

Example 2: Leave Records Query

Request:

POST /askai
Content-Type: application/json

{
    "question": "Give me the list of employee leave records"
}

Response:

Here is the list of employee leave records: John Doe - Annual leave from January 1 to January 5, 2025 (5 days) - Sick leave from March 15 to March 16, 2025 (2 days)\n - Personal leave from June 1 to June 3, 2025 (3 days) Jane Smith - Sick leave from February 1 to February 3, 2025 (3 days) - Annual leave from July 1 to July 10, 2025 (10 days)"

📚 Additional Resources

For a deeper understanding of the module's implementation, architecture decisions, and advanced customization options, see:

• Microsoft Semantic Kernel Documentation
• ABP Framework Documentation
• Full Module Source Code