Add webhook support and background sync service for release updates

- Introduced webhook endpoints to ClientPortal.Api for handling release notifications from Admin.Api.
- Added `ReleaseSyncService` for periodic syncing of releases from Admin.Api.
- Updated `appsettings` files to include sync and webhook configuration.
- Created `Client` model in Admin.Shared for webhook client metadata.
- Implemented webhook notification service in Admin.Api to notify clients of new releases.
- Enhanced Program.cs in Admin.Api and ClientPortal.Api to configure webhook and sync functionality.
- Updated Admin.Api to expose endpoints for syncing releases and update metadata through Cloudflare tunnels.

Author: MatejMa2ur

src/Admin.Api/Endpoints/Sync/SyncEndpoints.cs

@@ -0,0 +1,129 @@
+using Admin.Api.Domain.Interfaces;
+using Admin.Shared.Models;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Admin.Api.Endpoints.Sync;
+
+/// <summary>
+/// Sync endpoints for client to pull updates from server through Cloudflare tunnel
+/// </summary>
+public static class SyncEndpoints
+{
+    public static void MapSyncEndpoints(this IEndpointRouteBuilder app)
+    {
+        var group = app.MapGroup("/api/sync")
+            .WithTags("Sync")
+            .WithOpenApi();
+
+        // Endpoint for clients to pull active releases with their updates
+        group.MapGet("/releases/active", GetActiveReleasesForSync)
+            .WithName("SyncActiveReleases")
+            .WithSummary("Get all active releases with update metadata for client synchronization")
+            .Produces<List<ReleaseSyncDto>>(200);
+
+        // Endpoint for clients to pull update file metadata
+        group.MapGet("/updates/{id:guid}/metadata", GetUpdateMetadata)
+            .WithName("SyncUpdateMetadata")
+            .WithSummary("Get update file metadata including hash and signature for verification")
+            .Produces<UpdateMetadataDto>(200)
+            .Produces(404);
+    }
+
+    private static async Task<IResult> GetActiveReleasesForSync(
+        [FromServices] IReleaseRepository releaseRepository,
+        [FromServices] IUpdateRepository updateRepository)
+    {
+        var releases = await releaseRepository.GetActiveReleasesAsync();
+
+        var syncDtos = new List<ReleaseSyncDto>();
+
+        foreach (var release in releases)
+        {
+            var update = await updateRepository.GetByIdAsync(release.UpdateId);
+            if (update == null) continue;
+
+            var fileInfo = new FileInfo(update.FilePath);
+
+            syncDtos.Add(new ReleaseSyncDto
+            {
+                ReleaseId = release.Id,
+                UpdateId = update.Id,
+                Version = update.Version,
+                ReleaseDate = release.ReleaseDate,
+                IsMandatory = release.IsMandatory,
+                MaxPostponeDays = release.MaxPostponeDays,
+                Severity = update.Severity.ToString(),
+                Changelog = update.ChangeLog ?? string.Empty,
+                CVEList = string.Join(", ", update.SecurityFixes),
+                FileHash = update.FileHash,
+                Signature = update.DigitalSignature,
+                FileName = Path.GetFileName(update.FilePath),
+                FileSizeBytes = fileInfo.Exists ? fileInfo.Length : 0
+            });
+        }
+
+        return Results.Ok(syncDtos);
+    }
+
+    private static async Task<IResult> GetUpdateMetadata(
+        Guid id,
+        [FromServices] IUpdateRepository updateRepository)
+    {
+        var update = await updateRepository.GetByIdAsync(id);
+        if (update == null)
+        {
+            return Results.NotFound($"Update with ID {id} not found");
+        }
+
+        var fileInfo = new FileInfo(update.FilePath);
+
+        var metadata = new UpdateMetadataDto
+        {
+            Id = update.Id,
+            Version = update.Version,
+            FileName = Path.GetFileName(update.FilePath),
+            FileHash = update.FileHash,
+            Signature = update.DigitalSignature,
+            FileSizeBytes = fileInfo.Exists ? fileInfo.Length : 0,
+            Changelog = update.ChangeLog ?? string.Empty,
+            CVEList = string.Join(", ", update.SecurityFixes)
+        };
+
+        return Results.Ok(metadata);
+    }
+}
+
+/// <summary>
+/// DTO for syncing releases to client database
+/// </summary>
+public record ReleaseSyncDto
+{
+    public Guid ReleaseId { get; init; }
+    public Guid UpdateId { get; init; }
+    public string Version { get; init; } = string.Empty;
+    public DateTime ReleaseDate { get; init; }
+    public bool IsMandatory { get; init; }
+    public int MaxPostponeDays { get; init; }
+    public string Severity { get; init; } = string.Empty;
+    public string Changelog { get; init; } = string.Empty;
+    public string CVEList { get; init; } = string.Empty;
+    public string FileHash { get; init; } = string.Empty;
+    public string Signature { get; init; } = string.Empty;
+    public string FileName { get; init; } = string.Empty;
+    public long FileSizeBytes { get; init; }
+}
+
+/// <summary>
+/// DTO for update file metadata
+/// </summary>
+public record UpdateMetadataDto
+{
+    public Guid Id { get; init; }
+    public string Version { get; init; } = string.Empty;
+    public string FileName { get; init; } = string.Empty;
+    public string FileHash { get; init; } = string.Empty;
+    public string Signature { get; init; } = string.Empty;
+    public long FileSizeBytes { get; init; }
+    public string Changelog { get; init; } = string.Empty;
+    public string CVEList { get; init; } = string.Empty;
+}

src/Admin.Api/Program.cs

@@ -3,11 +3,13 @@
 using Admin.Api.Endpoints.Deployments;
 using Admin.Api.Endpoints.Devices;
 using Admin.Api.Endpoints.Releases;
+using Admin.Api.Endpoints.Sync;
 using Admin.Api.Endpoints.Updates;
 using Admin.Api.Infrastructure.Initialization;
 using Admin.Api.Infrastructure.Persistence;
 using Admin.Api.Infrastructure.Repositories;
 using Admin.Api.Infrastructure.Storage;
+using Admin.Api.Services;
 
 var builder = WebApplication.CreateBuilder(args);
 
@@ -29,6 +31,25 @@
 // Add storage service
 builder.Services.AddSingleton<IFileStorageService, LocalFileStorageService>();
 
+// Add webhook notification service
+builder.Services.AddScoped<IWebhookNotificationService, WebhookNotificationService>();
+
+// Add HttpClient for webhooks
+builder.Services.AddHttpClient("WebhookClient", client =>
+{
+    client.Timeout = TimeSpan.FromSeconds(10);
+})
+.ConfigurePrimaryHttpMessageHandler(() =>
+{
+    var handler = new HttpClientHandler();
+    if (builder.Environment.IsDevelopment())
+    {
+        handler.ServerCertificateCustomValidationCallback =
+            HttpClientHandler.DangerousAcceptAnyServerCertificateValidator;
+    }
+    return handler;
+});
+
 // Add CORS
 builder.Services.AddCors(options =>
 {
@@ -80,6 +101,7 @@
 api.MapGroup("/releases").MapReleaseEndpoints();
 api.MapGroup("/devices").MapDeviceEndpoints();
 api.MapGroup("/deployments").MapDeploymentEndpoints();
+api.MapSyncEndpoints(); // Sync endpoints for client to pull through Cloudflare tunnel
 
 // Health check
 app.MapGet("/health", () => Results.Ok(new { Status = "Healthy", Service = "Admin.Api" }))

src/Admin.Api/Services/WebhookNotificationService.cs

@@ -0,0 +1,201 @@
+using Admin.Shared.Models;
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.Json;
+
+namespace Admin.Api.Services;
+
+/// <summary>
+/// Service for sending webhook notifications to clients when new releases are created
+/// </summary>
+public interface IWebhookNotificationService
+{
+    Task NotifyClientsOfNewReleaseAsync(Release release, CancellationToken cancellationToken = default);
+    Task<bool> TestWebhookAsync(Client client, CancellationToken cancellationToken = default);
+}
+
+public class WebhookNotificationService : IWebhookNotificationService
+{
+    private readonly IHttpClientFactory _httpClientFactory;
+    private readonly ILogger<WebhookNotificationService> _logger;
+    private readonly IConfiguration _configuration;
+
+    public WebhookNotificationService(
+        IHttpClientFactory httpClientFactory,
+        ILogger<WebhookNotificationService> logger,
+        IConfiguration configuration)
+    {
+        _httpClientFactory = httpClientFactory;
+        _logger = logger;
+        _configuration = configuration;
+    }
+
+    public async Task NotifyClientsOfNewReleaseAsync(Release release, CancellationToken cancellationToken = default)
+    {
+        // In a real implementation, fetch clients from database
+        // For now, get from configuration or use sample data
+        var clients = GetRegisteredClients();
+
+        _logger.LogInformation("Notifying {Count} clients of new release {ReleaseId}", clients.Count, release.Id);
+
+        var tasks = clients
+            .Where(c => c.IsActive)
+            .Select(client => SendWebhookToClientAsync(client, release, cancellationToken));
+
+        await Task.WhenAll(tasks);
+    }
+
+    public async Task<bool> TestWebhookAsync(Client client, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var payload = new
+            {
+                EventType = "webhook.test",
+                Timestamp = DateTime.UtcNow,
+                ClientId = client.Id,
+                Message = "Webhook test from Admin.Api"
+            };
+
+            var result = await SendWebhookAsync(client, payload, cancellationToken);
+            return result;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Webhook test failed for client {ClientId}", client.Id);
+            return false;
+        }
+    }
+
+    private async Task SendWebhookToClientAsync(Client client, Release release, CancellationToken cancellationToken)
+    {
+        try
+        {
+            var payload = new
+            {
+                EventType = "release.created",
+                Timestamp = DateTime.UtcNow,
+                ReleaseId = release.Id,
+                UpdateId = release.UpdateId,
+                ReleaseDate = release.ReleaseDate,
+                IsMandatory = release.IsMandatory,
+                MaxPostponeDays = release.MaxPostponeDays,
+                IsActive = release.IsActive,
+                Message = "New release available - please sync from /api/sync/releases/active"
+            };
+
+            var success = await SendWebhookAsync(client, payload, cancellationToken);
+
+            if (success)
+            {
+                _logger.LogInformation("Webhook delivered successfully to client {ClientId} ({ClientName})",
+                    client.Id, client.Name);
+            }
+            else
+            {
+                _logger.LogWarning("Webhook delivery failed to client {ClientId} ({ClientName})",
+                    client.Id, client.Name);
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error sending webhook to client {ClientId} ({ClientName})",
+                client.Id, client.Name);
+        }
+    }
+
+    private async Task<bool> SendWebhookAsync(Client client, object payload, CancellationToken cancellationToken)
+    {
+        try
+        {
+            var httpClient = _httpClientFactory.CreateClient("WebhookClient");
+
+            // Serialize payload
+            var jsonPayload = JsonSerializer.Serialize(payload);
+
+            // Generate HMAC signature for security
+            var signature = GenerateHmacSignature(jsonPayload, client.WebhookSecret);
+
+            // Create HTTP request
+            var request = new HttpRequestMessage(HttpMethod.Post, client.WebhookUrl)
+            {
+                Content = new StringContent(jsonPayload, Encoding.UTF8, "application/json")
+            };
+
+            // Add signature header
+            request.Headers.Add("X-Webhook-Signature", signature);
+            request.Headers.Add("X-Webhook-Client-Id", client.Id.ToString());
+
+            // Send request
+            var response = await httpClient.SendAsync(request, cancellationToken);
+
+            if (response.IsSuccessStatusCode)
+            {
+                _logger.LogDebug("Webhook to {Url} returned {StatusCode}", client.WebhookUrl, response.StatusCode);
+                return true;
+            }
+            else
+            {
+                _logger.LogWarning("Webhook to {Url} failed with status {StatusCode}",
+                    client.WebhookUrl, response.StatusCode);
+                return false;
+            }
+        }
+        catch (HttpRequestException ex)
+        {
+            _logger.LogError(ex, "Network error sending webhook to {Url}", client.WebhookUrl);
+            return false;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Unexpected error sending webhook to {Url}", client.WebhookUrl);
+            return false;
+        }
+    }
+
+    private string GenerateHmacSignature(string payload, string secret)
+    {
+        using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(secret));
+        var hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(payload));
+        return Convert.ToBase64String(hash);
+    }
+
+    /// <summary>
+    /// Get registered clients from configuration
+    /// In production, this would query from database via IClientRepository
+    /// </summary>
+    private List<Client> GetRegisteredClients()
+    {
+        var webhookConfig = _configuration.GetSection("Webhooks:Clients").Get<List<WebhookClient>>();
+        if (webhookConfig == null || !webhookConfig.Any())
+        {
+            _logger.LogWarning("No webhook clients configured in appsettings");
+            return new List<Client>();
+        }
+
+        return webhookConfig.Select(wc => new Client
+        {
+            Id = Guid.NewGuid(),
+            Name = wc.Name,
+            WebhookUrl = wc.WebhookUrl,
+            WebhookSecret = wc.WebhookSecret,
+            IsActive = wc.IsActive
+        }).ToList();
+    }
+}
+
+/// <summary>
+/// Configuration for webhook clients
+/// </summary>
+public class WebhookConfiguration
+{
+    public List<WebhookClient> Clients { get; set; } = new();
+}
+
+public class WebhookClient
+{
+    public string Name { get; set; } = string.Empty;
+    public string WebhookUrl { get; set; } = string.Empty;
+    public string WebhookSecret { get; set; } = string.Empty;
+    public bool IsActive { get; set; } = true;
+}