feat: AI Agent 处理器扩展 + 服药打卡确认链路 + AI 气泡配色微调 + 数据刷新 providers 抽离 + 多端页面细节调整

2026-07-20 17:12:00 +08:00
parent 9cea41705e
commit 0cb5b8e85a
45 changed files with 1435 additions and 276 deletions
--- a/backend/src/Health.Application/AI/PatientContextService.cs
+++ b/backend/src/Health.Application/AI/PatientContextService.cs
@@ -1,24 +1,20 @@
 using System.Text;
 using Health.Application.HealthArchives;
 using Health.Application.HealthRecords;
-using Health.Application.Medications;

 namespace Health.Application.AI;

 public sealed class PatientContextService(
    IHealthArchiveService archives,
-    IHealthRecordService healthRecords,
-    IMedicationService medications) : IPatientContextService
+    IHealthRecordService healthRecords) : IPatientContextService
 {
    private readonly IHealthArchiveService _archives = archives;
    private readonly IHealthRecordService _healthRecords = healthRecords;
-    private readonly IMedicationService _medications = medications;

    public async Task<string> BuildAsync(Guid userId, CancellationToken ct)
    {
        var archive = await _archives.GetAsync(userId, ct);
        var recentRecords = (await _healthRecords.GetRecordsAsync(userId, null, 30, ct)).Take(10).ToList();
-        var activeMedications = await _medications.ListActiveAsync(userId, ct);

        var sb = new StringBuilder();
        if (archive != null)
@@ -36,23 +32,11 @@ public sealed class PatientContextService(
            if (archive.DietRestrictions.Count > 0) sb.AppendLine($"饮食限制: {string.Join(", ", archive.DietRestrictions)}");
        }

-        if (activeMedications.Count > 0)
-        {
-            sb.AppendLine("当前用药:");
-            foreach (var medication in activeMedications.Take(20))
-            {
-                var times = medication.TimeOfDay.Count > 0
-                    ? string.Join("/", medication.TimeOfDay.Select(t => t.ToString("HH:mm")))
-                    : "未设置时间";
-                sb.AppendLine($"  {medication.Name} {medication.Dosage ?? ""} {medication.Frequency} {times}");
-            }
-        }
-
        if (recentRecords.Count > 0)
        {
            sb.AppendLine("近期健康数据:");
            foreach (var record in recentRecords)
-                sb.AppendLine($"  {record.Type}: {RecordValue(record)} ({record.RecordedAt:MM-dd HH:mm})");
+                sb.AppendLine($"  {record.Type}: {RecordValue(record)} ({ToBeijing(record.RecordedAt):MM-dd HH:mm} 北京时间)");
        }

        return sb.ToString();
@@ -67,4 +51,15 @@ public sealed class PatientContextService(
        "Weight" => $"{record.Value}kg",
        _ => "—"
    };
+
+    private static DateTime ToBeijing(DateTime value)
+    {
+        var utc = value.Kind switch
+        {
+            DateTimeKind.Utc => value,
+            DateTimeKind.Local => value.ToUniversalTime(),
+            _ => DateTime.SpecifyKind(value, DateTimeKind.Utc),
+        };
+        return utc.AddHours(8);
+    }
 }
--- a/backend/src/Health.Application/Exercises/ExerciseContracts.cs
+++ b/backend/src/Health.Application/Exercises/ExerciseContracts.cs
@@ -42,19 +42,19 @@ public interface IExerciseService
    Task<ExercisePlanDto?> GetCurrentAsync(Guid userId, CancellationToken ct);
    Task<Guid> CreateAsync(Guid userId, ExercisePlanCreateRequest request, CancellationToken ct);
    Task<IReadOnlyList<ExercisePlanSummaryDto>> ListAsync(Guid userId, CancellationToken ct);
+    Task<IReadOnlyList<ExercisePlanSummaryDto>> ListAllAsync(Guid userId, CancellationToken ct);
    Task<ExercisePlanDto?> GetByIdAsync(Guid userId, Guid planId, CancellationToken ct);
    Task<bool> DeleteAsync(Guid userId, Guid planId, CancellationToken ct);
    Task<bool?> ToggleCheckInAsync(Guid userId, Guid itemId, CancellationToken ct);
    Task<bool> CheckInAsync(Guid userId, Guid itemId, CancellationToken ct);
-    Task<ExercisePlanDto?> GetLatestAsync(Guid userId, CancellationToken ct);
 }

 public interface IExerciseRepository
 {
    Task<IReadOnlyList<ExercisePlan>> ListActiveOnAsync(Guid userId, DateOnly date, CancellationToken ct);
    Task<IReadOnlyList<ExercisePlan>> ListAsync(Guid userId, int limit, CancellationToken ct);
+    Task<IReadOnlyList<ExercisePlan>> ListAllAsync(Guid userId, CancellationToken ct);
    Task<ExercisePlan?> GetOwnedPlanAsync(Guid userId, Guid planId, CancellationToken ct);
-    Task<ExercisePlan?> GetLatestAsync(Guid userId, CancellationToken ct);
    Task<ExercisePlanItem?> GetOwnedItemAsync(Guid userId, Guid itemId, CancellationToken ct);
    Task AddAsync(ExercisePlan plan, CancellationToken ct);
    void Delete(ExercisePlan plan);
--- a/backend/src/Health.Application/Exercises/ExerciseService.cs
+++ b/backend/src/Health.Application/Exercises/ExerciseService.cs
@@ -33,8 +33,11 @@ public sealed class ExerciseService(IExerciseRepository exercises) : IExerciseSe
        {
            plan.Items.Add(new ExercisePlanItem
            {
-                Id = Guid.NewGuid(), ScheduledDate = date, ExerciseType = exerciseType,
-                DurationMinutes = duration, IsRestDay = false,
+                Id = Guid.NewGuid(),
+                ScheduledDate = date,
+                ExerciseType = exerciseType,
+                DurationMinutes = duration,
+                IsRestDay = false,
            });
        }
        await SaveNewAsync(plan, ct);
@@ -52,10 +55,13 @@ public sealed class ExerciseService(IExerciseRepository exercises) : IExerciseSe
    public async Task<IReadOnlyList<ExercisePlanSummaryDto>> ListAsync(Guid userId, CancellationToken ct)
    {
        var plans = await _exercises.ListAsync(userId, 20, ct);
-        return plans.Select(p => new ExercisePlanSummaryDto(
-            p.Id, p.StartDate, p.EndDate, p.ReminderTime, p.CreatedAt,
-            p.Items.Count, p.Items.Count(i => i.IsCompleted),
-            p.Items.OrderBy(i => i.ScheduledDate).Select(ToItemDto).ToList())).ToList();
+        return plans.Select(ToSummaryDto).ToList();
+    }
+
+    public async Task<IReadOnlyList<ExercisePlanSummaryDto>> ListAllAsync(Guid userId, CancellationToken ct)
+    {
+        var plans = await _exercises.ListAllAsync(userId, ct);
+        return plans.Select(ToSummaryDto).ToList();
    }

    public async Task<ExercisePlanDto?> GetByIdAsync(Guid userId, Guid planId, CancellationToken ct)
@@ -103,12 +109,6 @@ public sealed class ExerciseService(IExerciseRepository exercises) : IExerciseSe
        return true;
    }

-    public async Task<ExercisePlanDto?> GetLatestAsync(Guid userId, CancellationToken ct)
-    {
-        var plan = await _exercises.GetLatestAsync(userId, ct);
-        return plan == null ? null : ToDto(plan);
-    }
-
    private async Task SaveNewAsync(ExercisePlan plan, CancellationToken ct)
    {
        await _exercises.AddAsync(plan, ct);
@@ -117,15 +117,24 @@ public sealed class ExerciseService(IExerciseRepository exercises) : IExerciseSe

    private static ExercisePlan NewPlan(Guid userId, DateOnly startDate, DateOnly endDate, TimeOnly? reminderTime) => new()
    {
-        Id = Guid.NewGuid(), UserId = userId, StartDate = startDate, EndDate = endDate,
+        Id = Guid.NewGuid(),
+        UserId = userId,
+        StartDate = startDate,
+        EndDate = endDate,
        ReminderTime = reminderTime ?? DefaultReminderTime,
-        CreatedAt = DateTime.UtcNow, UpdatedAt = DateTime.UtcNow,
+        CreatedAt = DateTime.UtcNow,
+        UpdatedAt = DateTime.UtcNow,
    };

    private static ExercisePlanDto ToDto(ExercisePlan plan) => new(
        plan.Id, plan.StartDate, plan.EndDate, plan.ReminderTime, plan.CreatedAt, plan.UpdatedAt,
        plan.Items.OrderBy(i => i.ScheduledDate).Select(ToItemDto).ToList());

+    private static ExercisePlanSummaryDto ToSummaryDto(ExercisePlan plan) => new(
+        plan.Id, plan.StartDate, plan.EndDate, plan.ReminderTime, plan.CreatedAt,
+        plan.Items.Count, plan.Items.Count(i => i.IsCompleted),
+        plan.Items.OrderBy(i => i.ScheduledDate).Select(ToItemDto).ToList());
+
    private static ExercisePlanItemDto ToItemDto(ExercisePlanItem item) => new(
        item.Id, item.ScheduledDate, item.ExerciseType, item.DurationMinutes,
        item.IsCompleted, item.CompletedAt, item.IsRestDay);
--- a/backend/src/Health.Application/Medications/MedicationContracts.cs
+++ b/backend/src/Health.Application/Medications/MedicationContracts.cs
@@ -45,6 +45,21 @@ public sealed record MedicationReminderDto(
    string ScheduledTime,
    string Status);

+public sealed record AiMedicationDoseDto(
+    string ScheduledTime,
+    string Status);
+
+public sealed record AiMedicationPlanDto(
+    Guid Id,
+    string Name,
+    string? Dosage,
+    string Frequency,
+    DateOnly? StartDate,
+    DateOnly? EndDate,
+    string Phase,
+    bool ScheduledOnDate,
+    IReadOnlyList<AiMedicationDoseDto> Doses);
+
 public sealed record MedicationReminderTask(
    Guid TaskId,
    Guid UserId,
@@ -60,12 +75,10 @@ public interface IMedicationService
    Task<Guid> CreateAsync(Guid userId, MedicationUpsertRequest request, CancellationToken ct);
    Task<bool> UpdateAsync(Guid userId, Guid medicationId, MedicationPatchRequest request, CancellationToken ct);
    Task<bool> DeleteAsync(Guid userId, Guid medicationId, CancellationToken ct);
-    Task<bool?> ToggleTodayTakenAsync(Guid userId, Guid medicationId, CancellationToken ct);
    Task<IReadOnlyList<MedicationReminderDto>> GetRemindersAsync(Guid userId, CancellationToken ct);
    Task<bool?> ConfirmDoseAsync(Guid userId, Guid medicationId, TimeOnly scheduledTime, MedicationLogStatus status, CancellationToken ct);
    Task<bool> CancelDoseAsync(Guid userId, Guid medicationId, TimeOnly scheduledTime, CancellationToken ct);
-    Task<IReadOnlyList<MedicationDto>> ListActiveAsync(Guid userId, CancellationToken ct);
-    Task<bool> ConfirmNowAsync(Guid userId, Guid medicationId, CancellationToken ct);
+    Task<IReadOnlyList<AiMedicationPlanDto>> GetAiOverviewAsync(Guid userId, DateOnly date, CancellationToken ct);
 }

 public interface IMedicationRepository
@@ -74,8 +87,6 @@ public interface IMedicationRepository
    Task<IReadOnlyList<Medication>> ListActiveForRemindersAsync(Guid userId, DateOnly today, CancellationToken ct);
    Task<IReadOnlyList<MedicationLog>> ListLogsInWindowAsync(Guid userId, DateTime startUtc, DateTime endUtc, CancellationToken ct);
    Task<Medication?> GetOwnedAsync(Guid userId, Guid medicationId, CancellationToken ct);
-    Task<bool> ExistsOwnedAsync(Guid userId, Guid medicationId, CancellationToken ct);
-    Task<MedicationLog?> GetTodayTakenLogAsync(Guid userId, Guid medicationId, DateTime startUtc, DateTime endUtc, CancellationToken ct);
    Task<bool> DoseLogExistsAsync(Guid userId, Guid medicationId, TimeOnly scheduledTime, DateTime startUtc, DateTime endUtc, CancellationToken ct);
    Task<MedicationLog?> GetDoseLogAsync(Guid userId, Guid medicationId, TimeOnly scheduledTime, DateTime startUtc, DateTime endUtc, CancellationToken ct);
    Task<IReadOnlyList<Medication>> ListActiveForReminderScanAsync(CancellationToken ct);
--- a/backend/src/Health.Application/Medications/MedicationService.cs
+++ b/backend/src/Health.Application/Medications/MedicationService.cs
@@ -96,23 +96,6 @@ public sealed class MedicationService(IMedicationRepository medications) : IMedi
        return true;
    }

-    public async Task<bool?> ToggleTodayTakenAsync(Guid userId, Guid medicationId, CancellationToken ct)
-    {
-        if (!await _medications.ExistsOwnedAsync(userId, medicationId, ct)) return null;
-
-        var (todayStartUtc, todayEndUtc) = GetBeijingTodayUtcWindow();
-        var existing = await _medications.GetTodayTakenLogAsync(userId, medicationId, todayStartUtc, todayEndUtc, ct);
-        if (existing != null)
-        {
-            _medications.DeleteLog(existing);
-            await _medications.SaveChangesAsync(ct);
-            return false;
-        }
-
-        await AddLogAsync(userId, medicationId, MedicationLogStatus.Taken, TimeOnly.FromDateTime(DateTime.UtcNow.AddHours(8)), ct);
-        return true;
-    }
-
    public async Task<IReadOnlyList<MedicationReminderDto>> GetRemindersAsync(Guid userId, CancellationToken ct)
    {
        var beijingNow = DateTime.UtcNow.AddHours(8);
@@ -147,7 +130,14 @@ public sealed class MedicationService(IMedicationRepository medications) : IMedi

    public async Task<bool?> ConfirmDoseAsync(Guid userId, Guid medicationId, TimeOnly scheduledTime, MedicationLogStatus status, CancellationToken ct)
    {
-        if (!await _medications.ExistsOwnedAsync(userId, medicationId, ct)) return null;
+        var medication = await _medications.GetOwnedAsync(userId, medicationId, ct);
+        if (medication == null) return null;
+
+        var today = BeijingToday();
+        if (!IsActiveOn(medication, today) ||
+            !GetDosesForToday(medication, today) ||
+            !medication.TimeOfDay.Contains(scheduledTime))
+            return false;

        var (todayStartUtc, todayEndUtc) = GetBeijingTodayUtcWindow();
        var existing = await _medications.DoseLogExistsAsync(userId, medicationId, scheduledTime, todayStartUtc, todayEndUtc, ct);
@@ -168,18 +158,48 @@ public sealed class MedicationService(IMedicationRepository medications) : IMedi
        return true;
    }

-    public Task<IReadOnlyList<MedicationDto>> ListActiveAsync(Guid userId, CancellationToken ct) =>
-        ListAsync(userId, "active", ct);
-
-    public async Task<bool> ConfirmNowAsync(Guid userId, Guid medicationId, CancellationToken ct)
+    public async Task<IReadOnlyList<AiMedicationPlanDto>> GetAiOverviewAsync(
+        Guid userId,
+        DateOnly date,
+        CancellationToken ct)
    {
-        var result = await ConfirmDoseAsync(
-            userId,
-            medicationId,
-            TimeOnly.FromDateTime(DateTime.UtcNow.AddHours(8)),
-            MedicationLogStatus.Taken,
-            ct);
-        return result == true;
+        var medications = await _medications.ListAsync(userId, null, ct);
+        var (startUtc, endUtc) = GetBeijingDateUtcWindow(date);
+        var logs = await _medications.ListLogsInWindowAsync(userId, startUtc, endUtc, ct);
+        var today = BeijingToday();
+        var now = TimeOnly.FromDateTime(DateTime.UtcNow.AddHours(8));
+
+        return medications.Select(medication =>
+        {
+            var phase = ResolvePhase(medication, date);
+            var scheduled = phase == "active" && GetDosesForToday(medication, date);
+            var doses = scheduled
+                ? medication.TimeOfDay.OrderBy(time => time).Select(time =>
+                {
+                    var log = logs.FirstOrDefault(item =>
+                        item.MedicationId == medication.Id && item.ScheduledTime == time);
+                    var status = log != null
+                        ? log.Status.ToString().ToLowerInvariant()
+                        : date < today
+                            ? "missed"
+                            : date > today
+                                ? "scheduled"
+                                : MedicationScheduleStatus.Resolve(time, now, null);
+                    return new AiMedicationDoseDto(time.ToString("HH:mm"), status);
+                }).ToList()
+                : [];
+
+            return new AiMedicationPlanDto(
+                medication.Id,
+                medication.Name,
+                medication.Dosage,
+                medication.Frequency.ToString(),
+                medication.StartDate,
+                medication.EndDate,
+                phase,
+                scheduled,
+                doses);
+        }).ToList();
    }

    private async Task AddLogAsync(Guid userId, Guid medicationId, MedicationLogStatus status, TimeOnly scheduledTime, CancellationToken ct)
@@ -217,9 +237,28 @@ public sealed class MedicationService(IMedicationRepository medications) : IMedi

    private static (DateTime StartUtc, DateTime EndUtc) GetBeijingTodayUtcWindow()
    {
-        var beijingToday = DateTime.UtcNow.AddHours(8).Date;
-        var todayStartUtc = beijingToday.AddHours(-8);
-        return (todayStartUtc, todayStartUtc.AddDays(1));
+        return GetBeijingDateUtcWindow(BeijingToday());
+    }
+
+    private static (DateTime StartUtc, DateTime EndUtc) GetBeijingDateUtcWindow(DateOnly date)
+    {
+        var startUtc = DateTime.SpecifyKind(date.ToDateTime(TimeOnly.MinValue).AddHours(-8), DateTimeKind.Utc);
+        return (startUtc, startUtc.AddDays(1));
+    }
+
+    private static DateOnly BeijingToday() => DateOnly.FromDateTime(DateTime.UtcNow.AddHours(8));
+
+    private static bool IsActiveOn(Medication medication, DateOnly date) =>
+        medication.IsActive &&
+        (!medication.StartDate.HasValue || medication.StartDate.Value <= date) &&
+        (!medication.EndDate.HasValue || medication.EndDate.Value >= date);
+
+    private static string ResolvePhase(Medication medication, DateOnly date)
+    {
+        if (!medication.IsActive) return "inactive";
+        if (medication.StartDate.HasValue && medication.StartDate.Value > date) return "upcoming";
+        if (medication.EndDate.HasValue && medication.EndDate.Value < date) return "ended";
+        return "active";
    }

    private static bool GetDosesForToday(Medication med, DateOnly today)