{
  "backend": ".NET 8 Web API",
  "frontend": "DevExpress Blazor Components",
  "database": "MariaDB + Entity Framework Core",
  "realtime": "SignalR",
  "auth": "JWT (users) + API Keys (apps)",
  "deployment": "Docker + Traefik + GitHub Actions",
  "architecture": "Clean Architecture + DDD + CQRS"
}

/src
  Hub.Domain/              # Entities, Value Objects, Enums
    ├── Entities/
    │   ├── Application.cs
    │   ├── License.cs
    │   ├── Device.cs
    │   ├── User.cs
    │   ├── AuditLog.cs
    │   └── Telemetry.cs
    └── ValueObjects/

  Hub.Application/         # Business Logic, CQRS, DTOs
    ├── Commands/
    ├── Queries/
    ├── DTOs/
    └── Interfaces/

  Hub.Infrastructure/      # EF Core, SignalR, Repositories
    ├── Data/
    ├── Hubs/
    └── Services/

  Hub.Api/                 # REST Endpoints, Controllers
    ├── Controllers/
    ├── Middleware/
    └── SignalR/

  Hub.Web/                 # DevExpress Admin Panel
    ├── Components/
    ├── Pages/
    └── Services/

/client-libraries
  Ogur.Core/              # Client integration library
  Ogur.Abstractions/      # Shared contracts

// Core entities
Applications        // App registry (ApiKey, CurrentVersion)
Users              // Panel users (JWT auth)
Licenses           // 1 license = 1 user + 1 app + N devices
Devices            // HWID+GUID tracking, status management
DeviceSessions     // SignalR connection tracking
 
// Supporting entities
ApplicationVersions // Version history, download URLs
Telemetry          // Event logs from applications
AuditLogs          // Complete audit trail
HubCommands        // Command history (sent to devices)
ApplicationSettings // Per-app JSON configuration

POST   /api/licenses/validate      # Validate + register device
GET    /api/updates/check          # Check for updates
POST   /api/telemetry              # Send telemetry batch

GET    /api/applications           # List all apps
POST   /api/applications           # Register new app
GET    /api/licenses               # List licenses
POST   /api/licenses               # Create license
PATCH  /api/licenses/{id}          # Update license
GET    /api/devices                # List devices
POST   /api/devices/{id}/block     # Block device
POST   /api/devices/{id}/logout    # Force logout
GET    /api/audit                  # Query audit logs

// Server → Client
ReceiveCommand(HubCommand)          // Push command to app
RequestHeartbeat()                  // Request liveness check
 
// Client → Server
AcknowledgeCommand(commandId)       // Confirm execution
Heartbeat()                         // Periodic ping
ReportStatus(status)                // Status update

// JWT dla użytkowników panelu
services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options => { /* ... */ });
 
// API Key dla aplikacji
services.AddAuthentication("ApiKey")
    .AddScheme<ApiKeyAuthenticationOptions, ApiKeyAuthenticationHandler>();

public class Device
{
    public string Hwid { get; set; }        // Hardware ID
    public string DeviceGuid { get; set; }  // Persistent GUID
    public DeviceStatus Status { get; set; } // Active/LoggedOut/Blocked
}
 
// Validation logic
if (existingDevice.Hwid != newHwid || existingDevice.DeviceGuid != newGuid)
    return Error("Device mismatch");

// Admin panel sends command
await _hubContext.Clients
    .Group($"device_{deviceId}")
    .SendAsync("ReceiveCommand", new HubCommand
    {
        Type = CommandType.Logout,
        Payload = JsonSerializer.Serialize(data)
    });
 
// App acknowledges
public async Task AcknowledgeCommand(int commandId)
{
    await _commandRepository.MarkAsAcknowledged(commandId);
}

// Domain-based tenant detection
var host = httpContext.Request.Host.Host;
var tenant = host.Contains("ogur.dev") 
    ? TenantId.OgurDev 
    : TenantId.DKarczewski;
 
// CSS theming
:root[data-tenant="ogur"] {
    --primary-color: #7c3aed;
    --accent-color: #a78bfa;
}

// Command
public record ValidateLicenseCommand(
    string LicenseKey, 
    string Hwid, 
    string DeviceGuid
) : IRequest<Result<LicenseValidationDto>>;
 
// Handler
public class ValidateLicenseCommandHandler 
    : IRequestHandler<ValidateLicenseCommand, Result<LicenseValidationDto>>
{
    public async Task<Result<LicenseValidationDto>> Handle(
        ValidateLicenseCommand request, 
        CancellationToken ct)
    {
        // Business logic
    }
}

# docker-compose.yml
services:
  api:
    image: ghcr.io/ishkabar/ogur-hub-api:latest
    labels:
      - "traefik.http.routers.hub-api.rule=Host(`api.ogur.dev`)"
      - "traefik.http.routers.hub-api.tls.certresolver=letsencrypt"
 
  web:
    image: ghcr.io/ishkabar/ogur-hub-web:latest
    labels:
      - "traefik.http.routers.hub-web.rule=Host(`hub.ogur.dev`)"

// Client-side usage
var hubClient = serviceProvider.GetRequiredService<IHubClient>();
 
// License validation
var result = await hubClient.ValidateLicenseAsync(
    licenseKey, 
    hwid, 
    deviceGuid
);
 
// SignalR connection
await hubClient.ConnectAsync();
hubClient.OnCommandReceived += async (command) =>
{
    switch (command.Type)
    {
        case CommandType.Logout:
            await ForceLogoutAsync();
            break;
        case CommandType.Notify:
            ShowNotification(command.Payload);
            break;
    }
};
 
// Telemetry
await hubClient.ReportTelemetryAsync(new TelemetryEvent
{
    EventType = "FeatureUsed",
    Data = JsonSerializer.Serialize(eventData)
});