Merge pull request #72 from bartoszclapinski/sprint2/phase2.5-hangfire-setup-#71

feat(hangfire): add background job processing with PostgreSQL storage

Author: bartoszclapinski

src/DevMetricsPro.Application/DTOs/GitHub/GitHubRepositoryDto.cs

@@ -25,6 +25,11 @@ public class GitHubRepositoryDto
     /// </summary>
     public string HtmlUrl { get; set; } = string.Empty;
 
+    /// <summary>
+    /// Full repository name in owner/repo format (e.g., "octocat/Hello-World")
+    /// </summary>
+    public string? FullName { get; set; }
+
     /// <summary>
     /// Whether the repository is private
     /// </summary>

src/DevMetricsPro.Infrastructure/Services/GitHubRepositoryService.cs

@@ -45,6 +45,7 @@ public async Task<IEnumerable<GitHubRepositoryDto>> GetUserRepositoriesAsync(
                 Name = repo.Name,
                 Description = repo.Description,
                 HtmlUrl = repo.HtmlUrl,
+                FullName = repo.FullName,
                 IsPrivate = repo.Private,
                 IsFork = repo.Fork,
                 StargazersCount = repo.StargazersCount,

src/DevMetricsPro.Web/Controllers/GitHubController.cs

@@ -609,4 +609,61 @@ public async Task<IActionResult> GetRecentCommits(
 
             return (addedCount, updatedCount);
     }
+
+    /// <summary>
+    /// Triggers a background job to sync all GitHub data (repositories and commits) for the current user
+    /// </summary>
+    /// <returns>Job ID</returns>
+    [HttpPost("sync-all")]
+    [Authorize(AuthenticationSchemes = "Bearer")]
+    [ProducesResponseType(typeof(object), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    public async Task<IActionResult> TriggerFullSync(
+        CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            // Get authenticated user
+            var userId = User.FindFirst(System.Security.Claims.ClaimTypes.NameIdentifier)?.Value;
+            if (string.IsNullOrEmpty(userId))
+            {
+                _logger.LogWarning("User ID not found in JWT claims");
+                return Unauthorized(new { message = "User not authenticated" });
+            }
+
+            var user = await _userManager.FindByIdAsync(userId);
+            if (user == null)
+            {
+                _logger.LogWarning("User {UserId} not found", userId);
+                return BadRequest(new { message = "User not found" });
+            }
+
+            if (string.IsNullOrEmpty(user.GitHubAccessToken))
+            {
+                _logger.LogWarning("User {UserId} does not have GitHub connected", userId);
+                return BadRequest(new { message = "GitHub account not connected" });
+            }
+
+            // Enqueue background job
+            var jobId = Hangfire.BackgroundJob.Enqueue<Web.Jobs.SyncGitHubDataJob>(
+                job => job.ExecuteAsync(user.Id));
+
+            _logger.LogInformation(
+                "Enqueued full GitHub sync job {JobId} for user {UserId}",
+                jobId, userId);
+
+            return Ok(new
+            {
+                success = true,
+                message = "GitHub sync job started",
+                jobId = jobId
+            });
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error triggering full GitHub sync");
+            return StatusCode(500, new { message = "Failed to start sync job" });
+        }
+    }
 }

src/DevMetricsPro.Web/DevMetricsPro.Web.csproj

@@ -7,6 +7,9 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="Hangfire.AspNetCore" Version="1.8.21" />
+    <PackageReference Include="Hangfire.Core" Version="1.8.21" />
+    <PackageReference Include="Hangfire.PostgreSql" Version="1.20.12" />
     <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="9.0.10" />
     <PackageReference Include="Microsoft.AspNetCore.Identity.UI" Version="9.0.10" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.10">

src/DevMetricsPro.Web/Jobs/SyncGitHubDataJob.cs

@@ -0,0 +1,277 @@
+using DevMetricsPro.Application.Interfaces;
+using DevMetricsPro.Core.Entities;
+using DevMetricsPro.Core.Enums;
+using DevMetricsPro.Core.Interfaces;
+using Microsoft.AspNetCore.Identity;
+
+namespace DevMetricsPro.Web.Jobs;
+
+/// <summary>
+/// Background job for syncing GitHub data (repositories and commits) for a user.
+/// This job is executed by Hangfire on a schedule or manually triggered.
+/// </summary>
+public class SyncGitHubDataJob
+{
+    private readonly IGitHubRepositoryService _repositoryService;
+    private readonly IGitHubCommitsService _commitsService;
+    private readonly IUnitOfWork _unitOfWork;
+    private readonly UserManager<ApplicationUser> _userManager;
+    private readonly ILogger<SyncGitHubDataJob> _logger;
+
+    public SyncGitHubDataJob(
+        IGitHubRepositoryService repositoryService,
+        IGitHubCommitsService commitsService,
+        IUnitOfWork unitOfWork,
+        UserManager<ApplicationUser> userManager,
+        ILogger<SyncGitHubDataJob> logger)
+    {
+        _repositoryService = repositoryService;
+        _commitsService = commitsService;
+        _unitOfWork = unitOfWork;
+        _userManager = userManager;
+        _logger = logger;
+    }
+
+    /// <summary>
+    /// Executes the GitHub data sync for a specific user.
+    /// This method syncs repositories first, then commits for each repository.
+    /// </summary>
+    /// <param name="userId">The ID of the user to sync data for</param>
+    public async Task ExecuteAsync(Guid userId)
+    {
+        try
+        {
+            _logger.LogInformation("Starting GitHub data sync for user {UserId}", userId);
+
+            // Get user with GitHub connection
+            var user = await _userManager.FindByIdAsync(userId.ToString());
+            if (user == null)
+            {
+                _logger.LogWarning("User {UserId} not found", userId);
+                return;
+            }
+
+            if (string.IsNullOrEmpty(user.GitHubAccessToken))
+            {
+                _logger.LogWarning("User {UserId} does not have GitHub connected", userId);
+                return;
+            }
+
+            // Step 1: Sync repositories
+            _logger.LogInformation("Syncing repositories for user {UserId}", userId);
+            var repositories = await _repositoryService.GetUserRepositoriesAsync(
+                user.GitHubAccessToken, 
+                CancellationToken.None);
+
+            var repositoryList = repositories.ToList();
+            _logger.LogInformation("Found {Count} repositories for user {UserId}", 
+                repositoryList.Count, userId);
+
+            // Save repositories to database
+            var syncedRepos = await SaveRepositoriesToDatabaseAsync(repositoryList);
+            _logger.LogInformation("Saved {Count} repositories to database", syncedRepos.Count);
+
+            // Step 2: Sync commits for each repository
+            var totalCommitsSynced = 0;
+            foreach (var repo in syncedRepos)
+            {
+                try
+                {
+                    _logger.LogInformation("Syncing commits for repository {RepoName}", repo.Name);
+
+                    // Parse owner/repo from FullName
+                    var parts = repo.FullName?.Split('/');
+                    if (parts == null || parts.Length != 2)
+                    {
+                        _logger.LogWarning("Invalid repository FullName format: {FullName}", repo.FullName);
+                        continue;
+                    }
+
+                    var owner = parts[0];
+                    var repoName = parts[1];
+
+                    // Fetch commits (incremental sync using LastSyncedAt)
+                    var commits = await _commitsService.GetRepositoryCommitsAsync(
+                        owner,
+                        repoName,
+                        user.GitHubAccessToken,
+                        repo.LastSyncedAt,
+                        CancellationToken.None);
+
+                    var commitsList = commits.ToList();
+                    _logger.LogInformation("Found {Count} commits for repository {RepoName}", 
+                        commitsList.Count, repoName);
+
+                    // Save commits to database
+                    if (commitsList.Any())
+                    {
+                        var (added, updated) = await SaveCommitsToDatabaseAsync(commitsList, repo.Id);
+                        totalCommitsSynced += added + updated;
+
+                        // Update LastSyncedAt
+                        repo.LastSyncedAt = DateTime.UtcNow;
+                        await _unitOfWork.Repository<Core.Entities.Repository>().UpdateAsync(repo);
+                        await _unitOfWork.SaveChangesAsync();
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error syncing commits for repository {RepoName}", repo.Name);
+                    // Continue with next repository
+                }
+            }
+
+            _logger.LogInformation(
+                "GitHub data sync completed for user {UserId}. " +
+                "Synced {RepoCount} repositories and {CommitCount} commits",
+                userId, syncedRepos.Count, totalCommitsSynced);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error during GitHub data sync for user {UserId}", userId);
+            throw; // Re-throw to let Hangfire handle retry
+        }
+    }
+
+    private async Task<List<Core.Entities.Repository>> SaveRepositoriesToDatabaseAsync(
+        List<Application.DTOs.GitHub.GitHubRepositoryDto> githubRepos)
+    {
+        var savedRepos = new List<Core.Entities.Repository>();
+        var repoRepository = _unitOfWork.Repository<Core.Entities.Repository>();
+
+        foreach (var githubRepo in githubRepos)
+        {
+            // Check if repository already exists
+            var existingRepos = await repoRepository.GetAllAsync();
+            var existingRepo = existingRepos.FirstOrDefault(r =>
+                r.ExternalId == githubRepo.Id.ToString() &&
+                r.Platform == PlatformType.GitHub);
+
+            if (existingRepo != null)
+            {
+                // Update existing repository
+                existingRepo.Name = githubRepo.Name;
+                existingRepo.Description = githubRepo.Description;
+                existingRepo.Url = githubRepo.HtmlUrl;
+                existingRepo.FullName = githubRepo.FullName;
+                existingRepo.IsPrivate = githubRepo.IsPrivate;
+                existingRepo.IsFork = githubRepo.IsFork;
+                existingRepo.StargazersCount = githubRepo.StargazersCount;
+                existingRepo.ForksCount = githubRepo.ForksCount;
+                existingRepo.OpenIssuesCount = githubRepo.OpenIssuesCount;
+                existingRepo.Language = githubRepo.Language;
+                existingRepo.PushedAt = githubRepo.PushedAt;
+                existingRepo.UpdatedAt = DateTime.UtcNow;
+
+                await repoRepository.UpdateAsync(existingRepo);
+                savedRepos.Add(existingRepo);
+            }
+            else
+            {
+                // Create new repository
+                var newRepo = new Core.Entities.Repository
+                {
+                    Name = githubRepo.Name,
+                    Description = githubRepo.Description,
+                    Platform = PlatformType.GitHub,
+                    ExternalId = githubRepo.Id.ToString(),
+                    Url = githubRepo.HtmlUrl,
+                    FullName = githubRepo.FullName,
+                    IsPrivate = githubRepo.IsPrivate,
+                    IsFork = githubRepo.IsFork,
+                    StargazersCount = githubRepo.StargazersCount,
+                    ForksCount = githubRepo.ForksCount,
+                    OpenIssuesCount = githubRepo.OpenIssuesCount,
+                    Language = githubRepo.Language,
+                    PushedAt = githubRepo.PushedAt,
+                    CreatedAt = DateTime.UtcNow,
+                    UpdatedAt = DateTime.UtcNow
+                };
+
+                var added = await repoRepository.AddAsync(newRepo);
+                savedRepos.Add(added);
+            }
+        }
+
+        await _unitOfWork.SaveChangesAsync();
+        return savedRepos;
+    }
+
+    private async Task<(int addedCount, int updatedCount)> SaveCommitsToDatabaseAsync(
+        List<Application.DTOs.GitHub.GitHubCommitDto> githubCommits,
+        Guid repositoryId)
+    {
+        var addedCount = 0;
+        var updatedCount = 0;
+        var commitRepository = _unitOfWork.Repository<Commit>();
+        var developerRepository = _unitOfWork.Repository<Developer>();
+
+        foreach (var githubCommit in githubCommits)
+        {
+            // Check if commit already exists
+            var existingCommits = await commitRepository.GetAllAsync();
+            var existingCommit = existingCommits.FirstOrDefault(c =>
+                c.Sha == githubCommit.Sha &&
+                c.RepositoryId == repositoryId);
+
+            // Find or create developer
+            var developers = await developerRepository.GetAllAsync();
+            var developer = developers.FirstOrDefault(d =>
+                d.Email == githubCommit.CommitterEmail);
+
+            if (developer == null)
+            {
+                // Create new developer
+                developer = new Developer
+                {
+                    DisplayName = githubCommit.CommitterName,
+                    Email = githubCommit.CommitterEmail,
+                    GitHubUsername = githubCommit.CommitterEmail.Split('@')[0], // Temporary
+                    CreatedAt = DateTime.UtcNow,
+                    UpdatedAt = DateTime.UtcNow
+                };
+                developer = await developerRepository.AddAsync(developer);
+                await _unitOfWork.SaveChangesAsync(); // Save to get ID
+            }
+
+            if (existingCommit != null)
+            {
+                // Update existing commit
+                existingCommit.Message = githubCommit.Message;
+                existingCommit.LinesAdded = githubCommit.Additions;
+                existingCommit.LinesRemoved = githubCommit.Deletions;
+                existingCommit.FilesChanged = githubCommit.TotalChanges > 0 ? githubCommit.TotalChanges : 1;
+                existingCommit.CommittedAt = githubCommit.CommitterDate;
+                existingCommit.DeveloperId = developer.Id;
+                existingCommit.UpdatedAt = DateTime.UtcNow;
+
+                await commitRepository.UpdateAsync(existingCommit);
+                updatedCount++;
+            }
+            else
+            {
+                // Create new commit
+                var newCommit = new Commit
+                {
+                    Sha = githubCommit.Sha,
+                    Message = githubCommit.Message,
+                    CommittedAt = githubCommit.CommitterDate,
+                    LinesAdded = githubCommit.Additions,
+                    LinesRemoved = githubCommit.Deletions,
+                    FilesChanged = githubCommit.TotalChanges > 0 ? githubCommit.TotalChanges : 1,
+                    RepositoryId = repositoryId,
+                    DeveloperId = developer.Id,
+                    CreatedAt = DateTime.UtcNow,
+                    UpdatedAt = DateTime.UtcNow
+                };
+
+                await commitRepository.AddAsync(newCommit);
+                addedCount++;
+            }
+        }
+
+        await _unitOfWork.SaveChangesAsync();
+        return (addedCount, updatedCount);
+    }
+}
+

src/DevMetricsPro.Web/Middleware/HangfireAuthorizationFilter.cs

@@ -0,0 +1,25 @@
+using Hangfire.Dashboard;
+
+namespace DevMetricsPro.Web.Middleware;
+
+/// <summary>
+/// Authorization filter for Hangfire Dashboard.
+/// In development: allows all access
+/// In production: requires authentication
+/// </summary>
+public class HangfireAuthorizationFilter : IDashboardAuthorizationFilter
+{
+    public bool Authorize(DashboardContext context)
+    {
+        var httpContext = context.GetHttpContext();
+        
+        // In development, allow all access for testing
+        // TODO: In production, require authentication
+        #if DEBUG
+            return true;
+        #else
+            return httpContext.User.Identity?.IsAuthenticated ?? false;
+        #endif
+    }
+}
+