Remove the Pro gate from goals

architecture.json

@@ -4848,6 +4848,7 @@
         "testClass": "PayGateServiceTests",
         "file": "tests/Orbit.Application.Tests/Common/PayGateServiceTests.cs",
         "references": [
+          "Goal",
           "Habit",
           "User"
         ]
@@ -7499,7 +7500,6 @@
         "references": [
           "ApiKey",
           "AppFeatureFlag",
-          "Goal",
           "User"
         ]
       },

src/Orbit.Application/Chat/Tools/Implementations/GoalReviewTool.cs

@@ -11,6 +11,7 @@
 
 public class GoalReviewTool(
     IGenericRepository<Goal> goalRepository,
+    IPayGateService payGate,
     IUserDateService userDateService,
     IGoalProgressReadSyncer goalProgressReadSyncer) : IAiTool
 {
@@ -22,13 +23,17 @@
 
     public async Task<ToolResult> ExecuteAsync(JsonElement args, Guid userId, CancellationToken ct)
     {
+        var gateCheck = await payGate.CanUseGoalReview(userId, ct);
+        if (gateCheck.IsFailure)
+            return ToolResult.FromFailure(gateCheck);
+
         var userToday = await userDateService.GetUserTodayAsync(userId, ct);
         var freshValues = await goalProgressReadSyncer.ComputeFreshValuesAsync(userId, userToday, ct);
         var streakWindowStart = userToday.AddDays(-AppConstants.MaxStreakLookbackDays);
 
         var goals = await goalRepository.FindAsync(
             g => g.UserId == userId && g.Status == GoalStatus.Active,
             q => q.Include(g => g.ProgressLogs).Include(g => g.Habits).ThenInclude(h => h.Logs.Where(l => l.Date >= streakWindowStart)),
             ct);
 
         if (goals.Count == 0)

src/Orbit.Application/Common/AppConfigKeys.cs

@@ -14,7 +14,6 @@ public static class AppConfigKeys
     public const string DailySummaryProOnly = "DailySummaryProOnly";
     public const string SmartRescheduleProOnly = "SmartRescheduleProOnly";
     public const string RetrospectiveProOnly = "RetrospectiveProOnly";
-    public const string GoalsProOnly = "GoalsProOnly";
     public const string MinSupportedVersion = "MinSupportedVersion";
     public const string RequireApiKeyCreationStepUp = "RequireApiKeyCreationStepUp";
 }

src/Orbit.Application/Common/PayGateService.cs

@@ -142,21 +142,8 @@ public async Task<Result> CanUseRetrospective(Guid userId, CancellationToken ct
         return Result.Success();
     }
 
-    public async Task<Result> CanAccessGoals(Guid userId, CancellationToken ct = default)
-    {
-        var user = await userRepository.GetByIdAsync(userId, ct);
-        if (user is null)
-            return Result.Failure(ErrorMessages.UserNotFound);
-
-        var goalsProOnly = await appConfig.GetAsync(AppConfigKeys.GoalsProOnly, true, ct);
-        if (goalsProOnly && !user.HasProAccess)
-            return Result.PayGateFailure("Goals are a Pro feature. Upgrade to unlock!");
-
-        return Result.Success();
-    }
-
-    public Task<Result> CanCreateGoals(Guid userId, CancellationToken ct = default) =>
-        CanAccessGoals(userId, ct);
+    public Task<Result> CanUseGoalReview(Guid userId, CancellationToken ct = default) =>
+        RequireProAccess(userId, "Goal reviews are a Pro feature. Upgrade to unlock!", ct);
 
     public Task<Result> CanAccessCalendar(Guid userId, CancellationToken ct = default) =>
         RequireProAccess(userId, "Calendar integration is a Pro feature. Upgrade to unlock!", ct);
@@ -191,9 +178,6 @@ public Task<Result> CanManageUserFacts(Guid userId, CancellationToken ct = defau
     public Task<Result> CanUseSlipAlerts(Guid userId, CancellationToken ct = default) =>
         RequireProAccess(userId, "Slip alerts are a Pro feature. Upgrade to unlock!", ct);
 
-    public Task<Result> CanLinkGoalsToHabits(Guid userId, CancellationToken ct = default) =>
-        CanAccessGoals(userId, ct);
-
     public async Task<Result> CanCreateApiKeys(Guid userId, CancellationToken ct = default)
     {
         return await CanManageApiKeys(userId, ct);

src/Orbit.Application/Goals/Commands/CreateGoalCommand.cs

@@ -22,10 +22,9 @@
     GoalType Type = GoalType.Standard,
     IReadOnlyList<Guid>? HabitIds = null) : IRequest<Result<Guid>>, IIdempotentCommand;
 
 public partial class CreateGoalCommandHandler(
     IGenericRepository<Goal> goalRepository,
     IGenericRepository<Habit> habitRepository,
-    IPayGateService payGate,
     IUserDateService userDateService,
     IGamificationService gamificationService,
     IGoalCompletionService goalCompletionService,
@@ -35,10 +34,6 @@
 {
     public async Task<Result<Guid>> Handle(CreateGoalCommand request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck.PropagateError<Guid>();
-
         var today = await userDateService.GetUserTodayAsync(request.UserId, cancellationToken);
         if (request.Deadline is { } deadline && deadline < today)
             return Result.Failure<Guid>(ErrorMessages.DeadlineInPast);

src/Orbit.Application/Goals/Commands/DeleteGoalCommand.cs

@@ -14,17 +14,12 @@ public record DeleteGoalCommand(
 
 public class DeleteGoalCommandHandler(
     IGenericRepository<Goal> goalRepository,
-    IPayGateService payGate,
     IUnitOfWork unitOfWork,
     IUserDateService userDateService,
     IMemoryCache cache) : IRequestHandler<DeleteGoalCommand, Result>
 {
     public async Task<Result> Handle(DeleteGoalCommand request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck;
-
         var goal = await goalRepository.FindOneTrackedAsync(
             g => g.Id == request.GoalId && g.UserId == request.UserId,
             cancellationToken: cancellationToken);

src/Orbit.Application/Goals/Commands/LinkHabitsToGoalCommand.cs

@@ -18,17 +18,12 @@ public record LinkHabitsToGoalCommand(
 public class LinkHabitsToGoalCommandHandler(
     IGenericRepository<Goal> goalRepository,
     IGenericRepository<Habit> habitRepository,
-    IPayGateService payGate,
     IGoalCompletionService goalCompletionService,
     IUserDateService userDateService,
     IMemoryCache cache) : IRequestHandler<LinkHabitsToGoalCommand, Result>
 {
     public async Task<Result> Handle(LinkHabitsToGoalCommand request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck;
-
         if (request.HabitIds.Count > AppConstants.MaxHabitsPerGoal)
             return Result.Failure(ErrorMessages.MaxHabitsPerGoal.Format(AppConstants.MaxHabitsPerGoal));
 

src/Orbit.Application/Goals/Commands/ReorderGoalsCommand.cs

@@ -16,17 +16,12 @@ public record ReorderGoalsCommand(
 
 public class ReorderGoalsCommandHandler(
     IGenericRepository<Goal> goalRepository,
-    IPayGateService payGate,
     IUnitOfWork unitOfWork,
     IUserDateService userDateService,
     IMemoryCache cache) : IRequestHandler<ReorderGoalsCommand, Result>
 {
     public async Task<Result> Handle(ReorderGoalsCommand request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck;
-
         var ids = request.Positions.Select(p => p.GoalId).ToHashSet();
 
         var goals = await goalRepository.FindTrackedAsync(

src/Orbit.Application/Goals/Commands/RestoreGoalCommand.cs

@@ -14,17 +14,12 @@ public record RestoreGoalCommand(
 
 public class RestoreGoalCommandHandler(
     IGenericRepository<Goal> goalRepository,
-    IPayGateService payGate,
     IUnitOfWork unitOfWork,
     IUserDateService userDateService,
     IMemoryCache cache) : IRequestHandler<RestoreGoalCommand, Result>
 {
     public async Task<Result> Handle(RestoreGoalCommand request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck;
-
         var goals = await goalRepository.FindTrackedIgnoringFiltersAsync(
             g => g.Id == request.GoalId && g.UserId == request.UserId,
             cancellationToken);

src/Orbit.Application/Goals/Commands/UpdateGoalCommand.cs

@@ -21,18 +21,13 @@ public record UpdateGoalCommand(
 
 public class UpdateGoalCommandHandler(
     GoalRepositories repos,
-    IPayGateService payGate,
     IUserDateService userDateService,
     IGoalCompletionService goalCompletionService,
     IUnitOfWork unitOfWork,
     IMemoryCache cache) : IRequestHandler<UpdateGoalCommand, Result>
 {
     public async Task<Result> Handle(UpdateGoalCommand request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck;
-
         var today = await userDateService.GetUserTodayAsync(request.UserId, cancellationToken);
         if (request.Deadline is { } deadline && deadline < today)
             return Result.Failure(ErrorMessages.DeadlineInPast);

src/Orbit.Application/Goals/Commands/UpdateGoalProgressCommand.cs

@@ -17,18 +17,13 @@ public record UpdateGoalProgressCommand(
 
 public class UpdateGoalProgressCommandHandler(
     GoalRepositories repos,
-    IPayGateService payGate,
     IGoalCompletionService goalCompletionService,
     IUnitOfWork unitOfWork,
     IUserDateService userDateService,
     IMemoryCache cache) : IRequestHandler<UpdateGoalProgressCommand, Result>
 {
     public async Task<Result> Handle(UpdateGoalProgressCommand request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck;
-
         var saved = await unitOfWork.ExecuteInTransactionAsync(async transactionToken =>
         {
             var justCompleted = false;

src/Orbit.Application/Goals/Commands/UpdateGoalStatusCommand.cs

@@ -17,18 +17,13 @@ public record UpdateGoalStatusCommand(
 
 public class UpdateGoalStatusCommandHandler(
     IGenericRepository<Goal> goalRepository,
-    IPayGateService payGate,
     IGoalCompletionService goalCompletionService,
     IUnitOfWork unitOfWork,
     IUserDateService userDateService,
     IMemoryCache cache) : IRequestHandler<UpdateGoalStatusCommand, Result>
 {
     public async Task<Result> Handle(UpdateGoalStatusCommand request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck;
-
         var goal = await goalRepository.FindOneTrackedAsync(
             g => g.Id == request.GoalId && g.UserId == request.UserId,
             cancellationToken: cancellationToken);

src/Orbit.Application/Goals/Queries/GetGoalByIdQuery.cs

@@ -37,15 +37,10 @@ public record GetGoalByIdQuery(
 
 public class GetGoalByIdQueryHandler(
     IGenericRepository<Goal> goalRepository,
-    IPayGateService payGate,
     IUserDateService userDateService) : IRequestHandler<GetGoalByIdQuery, Result<GoalDetailDto>>
 {
     public async Task<Result<GoalDetailDto>> Handle(GetGoalByIdQuery request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck.PropagateError<GoalDetailDto>();
-
         var loaded = await GoalDetailLoader.BuildGoalDetailAsync(
             goalRepository, userDateService, request.GoalId, request.UserId, cancellationToken);
         if (loaded is null)

src/Orbit.Application/Goals/Queries/GetGoalDetailQuery.cs

@@ -18,15 +18,10 @@ public record GetGoalDetailQuery(
 
 public class GetGoalDetailQueryHandler(
     IGenericRepository<Goal> goalRepository,
-    IPayGateService payGate,
     IUserDateService userDateService) : IRequestHandler<GetGoalDetailQuery, Result<GoalDetailWithMetricsResponse>>
 {
     public async Task<Result<GoalDetailWithMetricsResponse>> Handle(GetGoalDetailQuery request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck.PropagateError<GoalDetailWithMetricsResponse>();
-
         var loaded = await GoalDetailLoader.BuildGoalDetailAsync(
             goalRepository, userDateService, request.GoalId, request.UserId, cancellationToken);
         if (loaded is null)

src/Orbit.Application/Goals/Queries/GetGoalMetricsQuery.cs

@@ -13,16 +13,11 @@
 
 public class GetGoalMetricsQueryHandler(
     IGenericRepository<Goal> goalRepository,
-    IPayGateService payGate,
     IUserDateService userDateService,
     IGoalProgressReadSyncer goalProgressReadSyncer) : IRequestHandler<GetGoalMetricsQuery, Result<GoalMetrics>>
 {
     public async Task<Result<GoalMetrics>> Handle(GetGoalMetricsQuery request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck.PropagateError<GoalMetrics>();
-
         var userToday = await userDateService.GetUserTodayAsync(request.UserId, cancellationToken);
         var freshValues = await goalProgressReadSyncer.ComputeFreshValuesAsync(
             request.UserId,
@@ -32,7 +27,7 @@
 
         var goals = await goalRepository.FindAsync(
             g => g.Id == request.GoalId && g.UserId == request.UserId,
             q => q.Include(g => g.ProgressLogs)
                   .Include(g => g.Habits).ThenInclude(h => h.Logs.Where(l => l.Date >= streakWindowStart)),
             cancellationToken);
         var goal = goals.Count > 0 ? goals[0] : null;

src/Orbit.Application/Goals/Queries/GetGoalProgressHistoryQuery.cs

@@ -18,19 +18,14 @@ public record GetGoalProgressHistoryQuery(
 
 /// <summary>
 /// Returns a goal's progress-log entries within a date range as an ascending series, for charting
-/// progress over time. Pro-gated behind goals access; scoped to the requesting user's own goal.
+/// progress over time, scoped to the requesting user's own goal.
 /// </summary>
 public class GetGoalProgressHistoryQueryHandler(
     IGenericRepository<Goal> goalRepository,
-    IGenericRepository<GoalProgressLog> progressLogRepository,
-    IPayGateService payGate) : IRequestHandler<GetGoalProgressHistoryQuery, Result<GoalProgressHistoryResponse>>
+    IGenericRepository<GoalProgressLog> progressLogRepository) : IRequestHandler<GetGoalProgressHistoryQuery, Result<GoalProgressHistoryResponse>>
 {
     public async Task<Result<GoalProgressHistoryResponse>> Handle(GetGoalProgressHistoryQuery request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck.PropagateError<GoalProgressHistoryResponse>();
-
         var goalExists = await goalRepository.AnyAsync(
             g => g.Id == request.GoalId && g.UserId == request.UserId,
             cancellationToken);

src/Orbit.Application/Goals/Queries/GetGoalReviewQuery.cs

@@ -26,7 +26,7 @@
         GetGoalReviewQuery request,
         CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
+        var gateCheck = await payGate.CanUseGoalReview(request.UserId, cancellationToken);
         if (gateCheck.IsFailure)
             return gateCheck.PropagateError<GoalReviewResponse>();
 
@@ -44,7 +44,7 @@
 
         var goals = await goalRepository.FindAsync(
             g => g.UserId == request.UserId && g.Status == GoalStatus.Active,
             q => q.Include(g => g.ProgressLogs)
                   .Include(g => g.Habits).ThenInclude(h => h.Logs.Where(l => l.Date >= streakWindowStart)),
             cancellationToken);
 

src/Orbit.Application/Goals/Queries/GetGoalsQuery.cs

@@ -38,16 +38,11 @@ public record GetGoalsQuery(
 
 public class GetGoalsQueryHandler(
     IGenericRepository<Goal> goalRepository,
-    IPayGateService payGate,
     IUserDateService userDateService,
     IGoalProgressReadSyncer goalProgressReadSyncer) : IRequestHandler<GetGoalsQuery, Result<PaginatedResponse<GoalDto>>>
 {
     public async Task<Result<PaginatedResponse<GoalDto>>> Handle(GetGoalsQuery request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanAccessGoals(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck.PropagateError<PaginatedResponse<GoalDto>>();
-
         var userToday = await userDateService.GetUserTodayAsync(request.UserId, cancellationToken);
         var freshProgressValues = await goalProgressReadSyncer.ComputeFreshValuesAsync(request.UserId, userToday, cancellationToken);
 

src/Orbit.Application/Habits/Commands/CreateHabitCommand.cs

@@ -34,7 +34,7 @@
     IGenericRepository<Tag> TagRepository,
     IGenericRepository<Goal> GoalRepository);
 
 public partial class CreateHabitCommandHandler(
     CreateHabitRepositories repos,
     IUserDateService userDateService,
     IPayGateService payGate,
@@ -149,13 +149,6 @@
                 return subGateCheck;
         }
 
-        if (request.GoalIds is { Count: > 0 })
-        {
-            var goalLinkGate = await payGate.CanLinkGoalsToHabits(request.UserId, cancellationToken);
-            if (goalLinkGate.IsFailure)
-                return goalLinkGate;
-        }
-
         if (opts.SlipAlertEnabled)
         {
             var slipAlertGate = await payGate.CanUseSlipAlerts(request.UserId, cancellationToken);

src/Orbit.Application/Habits/Commands/LinkGoalsToHabitCommand.cs

@@ -16,16 +16,11 @@ public record LinkGoalsToHabitCommand(
 public class LinkGoalsToHabitCommandHandler(
     IGenericRepository<Habit> habitRepository,
     IGenericRepository<Goal> goalRepository,
-    IPayGateService payGate,
     IGoalCompletionService goalCompletionService,
     IUserDateService userDateService) : IRequestHandler<LinkGoalsToHabitCommand, Result>
 {
     public async Task<Result> Handle(LinkGoalsToHabitCommand request, CancellationToken cancellationToken)
     {
-        var gateCheck = await payGate.CanLinkGoalsToHabits(request.UserId, cancellationToken);
-        if (gateCheck.IsFailure)
-            return gateCheck;
-
         var habit = await habitRepository.FindOneTrackedAsync(
             h => h.Id == request.HabitId && h.UserId == request.UserId,
             q => q.Include(h => h.Goals),

src/Orbit.Application/Habits/Commands/UpdateHabitCommand.cs

@@ -25,7 +25,7 @@
     IReadOnlyList<Guid>? GoalIds = null,
     string? Emoji = null) : IRequest<Result>;
 
 public class UpdateHabitCommandHandler(
     IGenericRepository<Habit> habitRepository,
     IGenericRepository<SentReminder> sentReminderRepository,
     IGenericRepository<Goal> goalRepository,
@@ -37,13 +37,6 @@
 {
     public async Task<Result> Handle(UpdateHabitCommand request, CancellationToken cancellationToken)
     {
-        if (request.GoalIds is not null)
-        {
-            var goalLinkGate = await payGate.CanLinkGoalsToHabits(request.UserId, cancellationToken);
-            if (goalLinkGate.IsFailure)
-                return goalLinkGate;
-        }
-
         if (request.Options?.SlipAlertEnabled is not null)
         {
             var slipAlertGate = await payGate.CanUseSlipAlerts(request.UserId, cancellationToken);