ForgejoReleaseSync/Services/SyncService.cs

using System.Security.Cryptography.X509Certificates;
using System.Text.RegularExpressions;
using Microsoft.Extensions.Logging;

namespace ForgejoReleaseSync.Services;

public class SyncService(
    AppConfig config,
    RepositoryConfig repositoryConfig,
    GithubService githubService,
    ForgejoService forgejoService,
    ReleaseAssetDownloadService releaseAssetDownloadService,
    ILogger<SyncService> logger)
{

    public async Task Sync()
    {
        logger.LogInformation("Starting Sync Service");
        logger.LogInformation($"loaded {repositoryConfig.Repositories.Count} repositories");
        foreach (var repo in repositoryConfig.Repositories)
        {
            var repoOwner = repo.GithubUrl.Split('/')[^2]; 
            var repoName = repo.GithubUrl.Split('/').Last();
            
            var includeRegex = new Regex(repo.IncludeAssetsRegex);
            var excludeRegex = new Regex(repo.ExcludeAssetsRegex);
            
            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);

            long releaseId; 
            if (lastForgejoRelease is null || lastForgejoRelease.TagName != lastRelease.TagName)
            {
                logger.LogInformation("Creating release {ReleaseName} for repo {Owner}/{Name}",
                    lastRelease.Name,
                    repoOwner,
                    repoName);
                var createReleaseRes = await forgejoService.CreateReleaseAsync(repoOwner, repoName, lastRelease.Body, lastRelease.Name, lastRelease.TagName);
                releaseId = createReleaseRes.LastOrDefault().Id;
            }
            releaseId = lastForgejoRelease.Id;
            
            var acceptableAssets = lastRelease.Assets
                .Where(asset =>
                    includeRegex.IsMatch(asset.Name) &&
                    !excludeRegex.IsMatch(asset.Name) && lastForgejoRelease.Assets.All(releaseAsset => releaseAsset.Name != asset.Name))
                .ToArray();

            logger.LogInformation(
                    "Repo {Owner}/{Name}: release: {ReleaseName} has {ReleaseCount} assets with matching assets",
                    repoOwner,
                    repoName, 
                lastRelease.Name,
                acceptableAssets.Length);

            foreach (var acceptableAsset in acceptableAssets)
            {
                logger.LogInformation($"Downloading {acceptableAsset.Name}");
                
                var downloadPath = await releaseAssetDownloadService.DownloadReleaseAssetAsync(acceptableAsset.BrowserDownloadUrl);
                
                logger.LogInformation($"Downloaded {acceptableAsset.Name} to {downloadPath}");
                
                await forgejoService.UploadReleaseAssetAsync(repoOwner, repoName, releaseId, downloadPath);
                
                logger.LogInformation($"Uploaded {acceptableAsset.Name}");
                
                await releaseAssetDownloadService.DeleteReleaseAssetAsync(downloadPath);
            }
        }
    }
}