codeplay/CodePlay.Persistence/DatabaseStorageService.cs

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using CodePlay.Core.Models;
using CodePlay.Core.Services;
using CodePlay.Core.Common;

namespace CodePlay.Persistence;

public class DatabaseStorageService : IReportStorageService
{
    private readonly AppDbContext _context;
    
    public DatabaseStorageService(AppDbContext context)
    {
        _context = context;
    }
    
    public async Task<ConversionReport> SaveReportAsync(ConversionReport report, string? projectId = null)
    {
        if (string.IsNullOrEmpty(report.Id))
            report.Id = Guid.NewGuid().ToString("N")[..20];
        
        report.ProjectId = projectId ?? "default";
        report.CreatedAt = DateTime.UtcNow;
        
        _context.ConversionReports.Add(report);
        await _context.SaveChangesAsync();
        
        // 更新项目统计
        if (projectId != null)
        {
            var project = await _context.Projects.FindAsync(projectId);
            if (project != null)
            {
                project.TotalConversions++;
                project.UpdatedAt = DateTime.UtcNow;
                await _context.SaveChangesAsync();
            }
        }
        
        return report;
    }
    
    public async Task<ConversionReport?> GetReportAsync(string reportId)
    {
        return await _context.ConversionReports.FindAsync(reportId);
    }
    
    public async Task<List<ConversionReport>> GetReportsByProjectAsync(string projectId)
    {
        return await _context.ConversionReports
            .Where(r => r.ProjectId == projectId)
            .OrderByDescending(r => r.CreatedAt)
            .ToListAsync();
    }
    
    public async Task<List<ConversionReport>> GetAllReportsAsync()
    {
        return await _context.ConversionReports
            .OrderByDescending(r => r.CreatedAt)
            .ToListAsync();
    }
    
    public async Task DeleteReportAsync(string reportId)
    {
        var report = await _context.ConversionReports.FindAsync(reportId);
        if (report != null)
        {
            _context.ConversionReports.Remove(report);
            await _context.SaveChangesAsync();
        }
    }
    
    public async Task<ConversionStatistics> GetStatisticsAsync()
    {
        var reports = await _context.ConversionReports.ToListAsync();
        var projects = await _context.Projects.ToListAsync();
        
        return new ConversionStatistics
        {
            TotalConversions = reports.Count,
            TotalProjects = projects.Count,
            ConversionsByLanguage = reports.GroupBy(r => r.TargetLanguage)
                .ToDictionary(g => g.Key, g => g.Count()),
            AverageLinesConverted = reports.Any() ? reports.Average(r => r.LinesConverted) : 0,
            TotalIssuesDetected = reports.Sum(r => r.IssueCount),
            TotalTODOs = reports.Sum(r => r.TodoCount)
        };
    }
}

public static class PersistenceServiceExtensions
{
    public static IServiceCollection AddPersistence(this IServiceCollection services, string connectionString)
    {
        services.AddDbContext<AppDbContext>(options =>
            options.UseSqlite(connectionString));
        
        services.AddScoped<IReportStorageService, DatabaseStorageService>();
        
        return services;
    }
}