feat: integrate Forgejo API for release synchronization and asset download

Services/ForgejoService.cs

@@ -1,6 +1,59 @@
+using System.Net.Http.Headers;
+using System.Net.Http.Json;
+using System.Text;
+using System.Text.Json;
+using ForgejoReleaseSync.DTOs.Forgejo;
+using Microsoft.Extensions.Logging;
+
 namespace ForgejoReleaseSync.Services;
 
-public class ForgejoService
+public class ForgejoService(HttpClient httpClient, AppConfig config, ILogger<ForgejoService> logger)
 {
-    
+    public async Task CreateReleaseAsync(string owner, string repo, string body, string name, string tagName, CancellationToken token = default)
+    {
+        try
+        {
+            var dto = new ForgejoCreateReleaseDto(body, false, false, name, false, tagName, "");
+        
+            var json = JsonSerializer.Serialize(dto, AppJsonSerializerContext.Default.ForgejoCreateReleaseDto);
+            using var content = new StringContent(json, Encoding.UTF8, "application/json");
+            
+            using var request = new HttpRequestMessage(HttpMethod.Post, new Uri($"{config.ForgejoInstacne}/api/v1/repos/{owner}/{repo}/releases"));
+            request.Content = content;
+
+            request.Headers.Authorization =
+                new AuthenticationHeaderValue("token", config.ForgejoToken);
+
+            using var response = await httpClient.SendAsync(request, token);
+            response.EnsureSuccessStatusCode();
+        }
+        catch (Exception e)
+        {
+            logger.LogError(e, "Failed to create forgejo release");
+            throw;
+        }
+        
+    }
+
+    public async Task<List<ForgejoReleaseResponseDto>> FetchRepoReleasesAsync(string owner, string repo)
+    {
+        try
+        {
+            var response = await httpClient.GetAsync(
+                new Uri($"{config.ForgejoInstacne}/api/v1/repos/{owner}/{repo}/releases?per_page=3&page=1"));
+
+            response.EnsureSuccessStatusCode();
+
+            var responseStream = await response.Content.ReadAsStreamAsync();
+            var releases = await JsonSerializer.DeserializeAsync(responseStream,
+                AppJsonSerializerContext.Default.ListForgejoReleaseResponseDto);
+
+            return releases ?? [];
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Failed to fetch forgejo releases");
+            throw;
+        }
+    }
 }

Services/GithubService.cs

@@ -1,39 +1,23 @@
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using ForgejoReleaseSync.DTOs;
+using ForgejoReleaseSync.DTOs.Forgejo;
 using Microsoft.Extensions.Logging;
 
 namespace ForgejoReleaseSync.Services;
 
-public class GithubService
+public class GithubService(
+    AppConfig config,
+    RepositoryConfig repoConfig,
+    HttpClient httpClient,
+    ILogger<GithubService> logger)
 {
-    
-    private readonly AppConfig _config;
-    private readonly RepositoryConfig _repoConfig;
-    private readonly HttpClient _httpClient;
-    private readonly ILogger<GithubService> _logger;
-    
-    public GithubService(AppConfig config, RepositoryConfig repoConfig, ILogger<GithubService> logger)
-    {
-        var client = new HttpClient();
-        client.BaseAddress = new Uri("https://api.github.com");
-        client.DefaultRequestHeaders.Add("User-Agent", "ForgejoReleaseSync");
-        client.DefaultRequestHeaders.Add("Accept", "application/json");
-        client.Timeout = TimeSpan.FromSeconds(90);
-
-        _config = config;
-        _repoConfig = repoConfig;
-        _httpClient = client;
-        _logger = logger;
-    }
-    
-    
     public async Task<List<GithubReleaseResponseDto>> FetchRepoReleasesAsync(string owner, string repo)
     {
         try
         {
-            var response = await _httpClient.GetAsync(
-                $"/repos/{owner}/{repo}/releases?per_page=3&page=1");
+            var response = await httpClient.GetAsync(
+                new Uri($"https://api.github.com/repos/{owner}/{repo}/releases?per_page=3&page=1"));
 
             response.EnsureSuccessStatusCode();
 
@@ -45,13 +29,16 @@ public class GithubService
         }
         catch (Exception ex)
         {
-            _logger.LogError(ex, "Failed to fetch posts from Mastodon");
-            return [];
+            logger.LogError(ex, "Failed to fetch posts from Mastodon");
+            throw;
         }
     }
 }
 
+// TODO: move this
 [JsonSerializable(typeof(List<GithubReleaseResponseDto>))]
+[JsonSerializable(typeof(ForgejoCreateReleaseDto))]
+[JsonSerializable(typeof(List<ForgejoReleaseResponseDto>))]
 internal partial class AppJsonSerializerContext : JsonSerializerContext
 {
 }

Services/ReleaseAssetDownloadService.cs

@@ -0,0 +1,14 @@
+namespace ForgejoReleaseSync.Services;
+
+public class ReleaseAssetDownloadService(HttpClient httpClient)
+{
+    public async Task<string> DownloadReleaseAssetAsync(Uri url)
+    {
+        var fileName = Path.GetFileName(url.AbsoluteUri);
+        var filePath = Path.Combine(Path.GetTempPath(), fileName);
+        await using Stream resource = await httpClient.GetStreamAsync(url);
+        await using FileStream fs = new FileStream(filePath, FileMode.OpenOrCreate);
+        await resource.CopyToAsync(fs, 8192);
+        return filePath;
+    }
+}

Services/SyncService.cs

@@ -8,10 +8,10 @@ public class SyncService(
     AppConfig config,
     RepositoryConfig repositoryConfig,
     GithubService githubService,
+    ForgejoService forgejoService,
+    ReleaseAssetDownloadService releaseAssetDownloadService,
     ILogger<SyncService> logger)
 {
-    private readonly AppConfig _appConfig = config;
-    private readonly GithubService _githubService = githubService;
 
     public async Task Sync()
     {
@@ -25,12 +25,24 @@ public class SyncService(
             var includeRegex = new Regex(repo.IncludeAssetsRegex);
             var excludeRegex = new Regex(repo.ExcludeAssetsRegex);
             
-            var releases = await _githubService.FetchRepoReleasesAsync(repoOwner, repoName);
+            var releases = await githubService.FetchRepoReleasesAsync(repoOwner, repoName);
             
             var lastRelease = releases.LastOrDefault(r => r.Prerelease == false);
             if (lastRelease is null)
                 continue;
             
+            var forgejoReleases = await forgejoService.FetchRepoReleasesAsync(repoOwner, repoName);
+            var lastForgejoRelease = forgejoReleases.LastOrDefault(r => r.Prerelease == false);
+
+            if (lastForgejoRelease is null || lastForgejoRelease.TagName != lastRelease.TagName)
+            {
+                logger.LogInformation("Creating release {ReleaseName} for repo {Owner}/{Name}",
+                    lastRelease.Name,
+                    repoOwner,
+                    repoName);
+                await forgejoService.CreateReleaseAsync(repoOwner, repoName, lastRelease.Body, lastRelease.Name, lastRelease.TagName);
+            }
+            
             var acceptableAssets = lastRelease.Assets
                 .Where(asset =>
                     includeRegex.IsMatch(asset.Name) &&
@@ -46,7 +58,11 @@ public class SyncService(
 
             foreach (var acceptableAsset in acceptableAssets)
             {
-                logger.LogInformation(acceptableAsset.Name);
+                logger.LogInformation($"Downloading {acceptableAsset.Name}");
+                
+                var downloadPath = await releaseAssetDownloadService.DownloadReleaseAssetAsync(acceptableAsset.BrowserDownloadUrl);
+                
+                logger.LogInformation($"Downloaded {acceptableAsset.Name} to {downloadPath}");
             }
         }
     }