Fix organization billing page to use config-based limits

- Use LimitsConfiguration for plan limits instead of hardcoded values
- Add FormatLimit() helper for consistent limit formatting
- Fix BYOK limits showing wrong values

Author: nickprotop

cloud/src/LrmCloud.Api/Services/IUsageService.cs

@@ -16,4 +16,19 @@ public interface IUsageService
     /// Gets usage statistics for an organization.
     /// </summary>
     Task<OrganizationUsageDto?> GetOrganizationStatsAsync(int organizationId, int userId);
+
+    /// <summary>
+    /// Gets user's usage broken down by personal vs organization contributions.
+    /// </summary>
+    Task<UserUsageBreakdownDto> GetUserUsageBreakdownAsync(int userId);
+
+    /// <summary>
+    /// Gets organization usage breakdown by member (for admins/owners only).
+    /// </summary>
+    Task<List<OrgMemberUsageDto>> GetOrgMemberUsageAsync(int organizationId, int userId);
+
+    /// <summary>
+    /// Gets project usage breakdown by contributor.
+    /// </summary>
+    Task<ProjectUsageDto?> GetProjectUsageAsync(int projectId, int userId);
 }

cloud/src/LrmCloud.Api/Services/UsageService.cs

@@ -1,5 +1,6 @@
 using LrmCloud.Api.Data;
 using LrmCloud.Shared.Configuration;
+using LrmCloud.Shared.Constants;
 using LrmCloud.Shared.DTOs.Usage;
 using Microsoft.EntityFrameworkCore;
 
@@ -66,11 +67,11 @@ public async Task<UsageStatsDto> GetUserStatsAsync(int userId)
         {
             // LRM Translation usage (counts against plan)
             TranslationCharsUsed = user.TranslationCharsUsed,
-            TranslationCharsLimit = user.TranslationCharsLimit,
+            TranslationCharsLimit = _limits.GetTranslationCharsLimit(user.Plan),
             TranslationCharsResetAt = user.TranslationCharsResetAt,
             // Other providers usage (BYOK + free community)
             OtherCharsUsed = user.OtherCharsUsed,
-            OtherCharsLimit = user.OtherCharsLimit,
+            OtherCharsLimit = _limits.GetOtherCharsLimit(user.Plan),
             OtherCharsResetAt = user.OtherCharsResetAt,
             // Other stats
             ProjectCount = projectCount,
@@ -99,15 +100,18 @@ public async Task<UsageStatsDto> GetUserStatsAsync(int userId)
         }
 
         var org = await _db.Organizations
+            .Include(o => o.Owner) // Include owner for quota info
             .Include(o => o.Members)
             .Include(o => o.Projects)
             .FirstOrDefaultAsync(o => o.Id == organizationId);
 
-        if (org == null)
+        if (org?.Owner == null)
         {
             return null;
         }
 
+        var owner = org.Owner;
+
         // Storage tracking not implemented yet - return 0
         var storageBytes = 0L;
 
@@ -117,18 +121,130 @@ public async Task<UsageStatsDto> GetUserStatsAsync(int userId)
         var resetDate = new DateTime(nextMonth.Year, nextMonth.Month, 1);
         var daysRemaining = (int)(resetDate - now).TotalDays;
 
+        // Organization shares the owner's quota - no separate org limits
         return new OrganizationUsageDto
         {
-            LrmCharsUsed = org.TranslationCharsUsed,
-            LrmCharsLimit = org.TranslationCharsLimit,
-            OtherCharsUsed = 0, // TODO: Track organization-level BYOK usage
+            // Show OWNER's usage (org shares owner's quota)
+            LrmCharsUsed = owner.TranslationCharsUsed,
+            LrmCharsLimit = _limits.GetTranslationCharsLimit(owner.Plan),
+            OtherCharsUsed = owner.OtherCharsUsed,
+            OtherCharsLimit = _limits.GetOtherCharsLimit(owner.Plan),
             ApiCalls = 0, // TODO: Track organization-level API calls
             StorageBytes = storageBytes,
             DaysRemaining = daysRemaining,
-            Plan = org.Plan,
+            Plan = owner.Plan, // Show owner's plan
             MemberCount = org.Members.Count,
-            MaxMembers = _limits.GetMaxTeamMembers(org.Plan),
+            MaxMembers = _limits.GetMaxTeamMembers(owner.Plan),
             ProjectCount = org.Projects.Count
         };
     }
+
+    public async Task<UserUsageBreakdownDto> GetUserUsageBreakdownAsync(int userId)
+    {
+        var events = await _db.UsageEvents
+            .Where(e => e.ActingUserId == userId)
+            .ToListAsync();
+
+        var personalEvents = events.Where(e => e.OrganizationId == null).ToList();
+        var orgGroups = events
+            .Where(e => e.OrganizationId != null)
+            .GroupBy(e => e.OrganizationId!.Value)
+            .ToList();
+
+        var orgContributions = new List<OrgUsageContributionDto>();
+        foreach (var orgGroup in orgGroups)
+        {
+            var org = await _db.Organizations.FindAsync(orgGroup.Key);
+            orgContributions.Add(new OrgUsageContributionDto
+            {
+                OrganizationId = orgGroup.Key,
+                OrganizationName = org?.Name ?? "Unknown",
+                LrmCharsUsed = orgGroup.Where(e => e.IsLrmProvider).Sum(e => e.CharactersUsed),
+                ByokCharsUsed = orgGroup.Where(e => !e.IsLrmProvider).Sum(e => e.CharactersUsed)
+            });
+        }
+
+        return new UserUsageBreakdownDto
+        {
+            PersonalLrmChars = personalEvents.Where(e => e.IsLrmProvider).Sum(e => e.CharactersUsed),
+            PersonalByokChars = personalEvents.Where(e => !e.IsLrmProvider).Sum(e => e.CharactersUsed),
+            OrganizationContributions = orgContributions.OrderByDescending(c => c.LrmCharsUsed + c.ByokCharsUsed).ToList()
+        };
+    }
+
+    public async Task<List<OrgMemberUsageDto>> GetOrgMemberUsageAsync(int organizationId, int userId)
+    {
+        // Check if user is admin/owner
+        var membership = await _db.OrganizationMembers
+            .FirstOrDefaultAsync(m => m.OrganizationId == organizationId && m.UserId == userId);
+
+        if (membership == null || !OrganizationRole.IsAdminOrOwner(membership.Role))
+        {
+            return new List<OrgMemberUsageDto>();
+        }
+
+        var events = await _db.UsageEvents
+            .Include(e => e.ActingUser)
+            .Where(e => e.OrganizationId == organizationId)
+            .ToListAsync();
+
+        return events
+            .GroupBy(e => e.ActingUserId)
+            .Select(g => new OrgMemberUsageDto
+            {
+                UserId = g.Key,
+                UserName = g.First().ActingUser?.DisplayName ?? g.First().ActingUser?.Email ?? "Unknown",
+                Email = g.First().ActingUser?.Email ?? "",
+                LrmCharsUsed = g.Where(e => e.IsLrmProvider).Sum(e => e.CharactersUsed),
+                ByokCharsUsed = g.Where(e => !e.IsLrmProvider).Sum(e => e.CharactersUsed)
+            })
+            .OrderByDescending(m => m.TotalCharsUsed)
+            .ToList();
+    }
+
+    public async Task<ProjectUsageDto?> GetProjectUsageAsync(int projectId, int userId)
+    {
+        var project = await _db.Projects.FindAsync(projectId);
+        if (project == null)
+        {
+            return null;
+        }
+
+        // Check access: user is project owner, or member of the owning org
+        bool hasAccess = project.UserId == userId;
+        if (!hasAccess && project.OrganizationId.HasValue)
+        {
+            hasAccess = await _db.OrganizationMembers
+                .AnyAsync(m => m.OrganizationId == project.OrganizationId && m.UserId == userId);
+        }
+
+        if (!hasAccess)
+        {
+            return null;
+        }
+
+        var events = await _db.UsageEvents
+            .Include(e => e.ActingUser)
+            .Where(e => e.ProjectId == projectId)
+            .ToListAsync();
+
+        return new ProjectUsageDto
+        {
+            ProjectId = projectId,
+            ProjectName = project.Name,
+            TotalLrmChars = events.Where(e => e.IsLrmProvider).Sum(e => e.CharactersUsed),
+            TotalByokChars = events.Where(e => !e.IsLrmProvider).Sum(e => e.CharactersUsed),
+            MemberBreakdown = events
+                .GroupBy(e => e.ActingUserId)
+                .Select(g => new ProjectMemberUsageDto
+                {
+                    UserId = g.Key,
+                    UserName = g.First().ActingUser?.DisplayName ?? g.First().ActingUser?.Email ?? "Unknown",
+                    LrmCharsUsed = g.Where(e => e.IsLrmProvider).Sum(e => e.CharactersUsed),
+                    ByokCharsUsed = g.Where(e => !e.IsLrmProvider).Sum(e => e.CharactersUsed)
+                })
+                .OrderByDescending(m => m.TotalCharsUsed)
+                .ToList()
+        };
+    }
 }