Use upcoming invoice

Author: AlexTugarev

components/server/ee/src/billing/billing-service.ts

@@ -7,9 +7,14 @@
 import { CostCenterDB } from "@gitpod/gitpod-db/lib";
 import { User } from "@gitpod/gitpod-protocol";
 import { AttributionId } from "@gitpod/gitpod-protocol/lib/attribution";
-import { BillableSession, BillableSessionRequest, SortOrder } from "@gitpod/gitpod-protocol/lib/usage";
+import { BillableSession, BillableSessionRequest } from "@gitpod/gitpod-protocol/lib/usage";
 import { log } from "@gitpod/gitpod-protocol/lib/util/logging";
-import { CachingUsageServiceClientProvider, UsageService } from "@gitpod/usage-api/lib/usage/v1/sugar";
+import { GetUpcomingInvoiceResponse } from "@gitpod/usage-api/lib/usage/v1/billing_pb";
+import {
+    CachingUsageServiceClientProvider,
+    UsageService,
+    CachingBillingServiceClientProvider,
+} from "@gitpod/usage-api/lib/usage/v1/sugar";
 import { Timestamp } from "google-protobuf/google/protobuf/timestamp_pb";
 import { inject, injectable } from "inversify";
 import { UserService } from "../../../src/user/user-service";
@@ -26,6 +31,8 @@ export class BillingService {
     @inject(CostCenterDB) protected readonly costCenterDB: CostCenterDB;
     @inject(CachingUsageServiceClientProvider)
     protected readonly usageServiceClientProvider: CachingUsageServiceClientProvider;
+    @inject(CachingBillingServiceClientProvider)
+    protected readonly billingServiceClientProvider: CachingBillingServiceClientProvider;
 
     async checkSpendingLimitReached(user: User): Promise<SpendingLimitReachedResult> {
         const attributionId = await this.userService.getWorkspaceUsageAttributionId(user);
@@ -40,50 +47,45 @@ export class BillingService {
             };
         }
 
-        const allSessions = await this.listBilledUsage({
-            attributionId: AttributionId.render(attributionId),
-            startedTimeOrder: SortOrder.Descending,
-        });
-        const totalUsage = allSessions.map((s) => s.credits).reduce((a, b) => a + b, 0);
-        if (totalUsage >= costCenter.spendingLimit) {
-            return {
-                reached: true,
-                attributionId,
-            };
-        } else if (totalUsage > costCenter.spendingLimit * 0.8) {
-            return {
-                reached: false,
-                almostReached: true,
-                attributionId,
-            };
+        if (attributionId.kind === "team") {
+            const upcomingInvoice = await this.getUpcomingInvoice(attributionId.teamId);
+            const currentUsage = upcomingInvoice.getCredits();
+            if (currentUsage >= costCenter.spendingLimit) {
+                log.info({ userId: user.id }, "Spending limit reached", {
+                    attributionId,
+                    currentUsage,
+                    spendingLimit: costCenter.spendingLimit,
+                });
+                return {
+                    reached: true,
+                    attributionId,
+                };
+            } else if (currentUsage > costCenter.spendingLimit * 0.8) {
+                log.info({ userId: user.id }, "Spending limit almost reached", {
+                    attributionId,
+                    currentUsage,
+                    spendingLimit: costCenter.spendingLimit,
+                });
+                return {
+                    reached: false,
+                    almostReached: true,
+                    attributionId,
+                };
+            }
         }
+
+        if (attributionId.kind === "user") {
+            // TODO
+        }
+
         return {
             reached: false,
             attributionId,
         };
     }
 
-    // TODO (gpl): Replace this with call to stripeService.getInvoice()
-    async listBilledUsage(req: BillableSessionRequest): Promise<BillableSession[]> {
-        const { attributionId, startedTimeOrder, from, to } = req;
-        let timestampFrom;
-        let timestampTo;
-
-        if (from) {
-            timestampFrom = Timestamp.fromDate(new Date(from));
-        }
-        if (to) {
-            timestampTo = Timestamp.fromDate(new Date(to));
-        }
-        const usageClient = this.usageServiceClientProvider.getDefault();
-        const response = await usageClient.listBilledUsage(
-            {},
-            attributionId,
-            startedTimeOrder as number,
-            timestampFrom,
-            timestampTo,
-        );
-        const sessions = response.getSessionsList().map((s) => UsageService.mapBilledSession(s));
-        return sessions;
+    async getUpcomingInvoice(teamId: string): Promise<GetUpcomingInvoiceResponse> {
+        const response = await this.billingServiceClientProvider.getDefault().getUpcomingInvoice(teamId);
+        return response;
     }
 }