[RELEASE] Gleaming Garnet

apps/dashboard-service/src/app.module.ts

@@ -10,6 +10,8 @@ import { CacheService } from "./dashboard/dto/cache.service";
 import { RedisModule } from "@nestjs-modules/ioredis";
 import { ConfigModule, ConfigService } from "@nestjs/config";
 import { DashboardProcessor } from "./dashboard/worker/dashboard.processor";
+import { TreeRestorationGoalController } from "./dashboard/tree-restoration-goal.controller";
+import { TreeRestorationGoalService } from "./dashboard/dto/tree-restoration-goal.service";
 
 @Module({
   imports: [
@@ -30,15 +32,16 @@ import { DashboardProcessor } from "./dashboard/worker/dashboard.processor";
     }),
     BullModule.registerQueue({ name: "dashboard" })
   ],
-  controllers: [TotalSectionHeaderController],
+  controllers: [TotalSectionHeaderController, TreeRestorationGoalController],
   providers: [
     {
       provide: APP_FILTER,
       useClass: SentryGlobalFilter
     },
     TotalSectionHeaderService,
     CacheService,
-    DashboardProcessor
+    DashboardProcessor,
+    TreeRestorationGoalService
   ]
 })
 export class AppModule {}

apps/dashboard-service/src/dashboard/dto/cache.service.spec.ts

@@ -115,11 +115,33 @@ describe("CacheService", () => {
       expect(result).toBe("not-json");
     });
 
-    it("should return null if redis returns null", async () => {
+    it("should return null if redis returns null and no factory provided", async () => {
       (redisMock.get as jest.Mock).mockResolvedValue(null);
       const result = await service.get("key1");
       expect(result).toBeNull();
     });
+
+    it("should use factory to generate and cache value when cache miss", async () => {
+      (redisMock.get as jest.Mock).mockResolvedValue(null);
+      const factory = jest.fn().mockResolvedValue({ newData: "value" });
+
+      const result = await service.get("key1", factory);
+
+      expect(factory).toHaveBeenCalled();
+      expect(redisMock.set).toHaveBeenCalledWith("key1", JSON.stringify({ newData: "value" }));
+      expect(result).toEqual({ newData: "value" });
+    });
+
+    it("should handle string values from factory", async () => {
+      (redisMock.get as jest.Mock).mockResolvedValue(null);
+      const factory = jest.fn().mockResolvedValue("string value");
+
+      const result = await service.get("key1", factory);
+
+      expect(factory).toHaveBeenCalled();
+      expect(redisMock.set).toHaveBeenCalledWith("key1", "string value");
+      expect(result).toBe("string value");
+    });
   });
 
   describe("getCacheKeyFromQuery", () => {

apps/dashboard-service/src/dashboard/dto/cache.service.ts

@@ -26,16 +26,27 @@ export class CacheService {
     await this.redis.set(key, value);
   }
 
-  async get(key: string) {
+  async get(key: string, factory?: () => Promise<string | object>) {
     const data = await this.redis.get(key);
-    if (typeof data === "string") {
-      try {
-        return JSON.parse(data);
-      } catch {
-        return data;
+    if (data !== null) {
+      if (typeof data === "string") {
+        try {
+          return JSON.parse(data);
+        } catch {
+          return data;
+        }
       }
+      return data;
     }
-    return data;
+
+    if (factory != null) {
+      const result = await factory();
+      const valueToStore = typeof result === "string" ? result : JSON.stringify(result);
+      await this.redis.set(key, valueToStore);
+      return result;
+    }
+
+    return null;
   }
 
   async del(key: string) {

apps/dashboard-service/src/dashboard/dto/tree-restoration-goal.dto.ts

@@ -0,0 +1,67 @@
+import { JsonApiDto } from "@terramatch-microservices/common/decorators";
+import { ApiProperty } from "@nestjs/swagger";
+import { populateDto } from "@terramatch-microservices/common/dto/json-api-attributes";
+
+class TreeRestorationData {
+  @ApiProperty({
+    description: "Due date for this restoration data"
+  })
+  dueDate: Date;
+
+  @ApiProperty({
+    description: "Number of tree species for this period"
+  })
+  treeSpeciesAmount: number;
+
+  @ApiProperty({
+    description: "Tree species goal for calculating percentage"
+  })
+  treeSpeciesGoal: number;
+}
+
+@JsonApiDto({ type: "treeRestorationGoals" })
+export class TreeRestorationGoalDto {
+  constructor(data: TreeRestorationGoalDto) {
+    populateDto<TreeRestorationGoalDto>(this, data);
+  }
+
+  @ApiProperty({
+    description: "Total number of trees grown goal for for-profit organizations"
+  })
+  forProfitTreeCount: number;
+
+  @ApiProperty({
+    description: "Total number of trees grown goal for non-profit organizations"
+  })
+  nonProfitTreeCount: number;
+
+  @ApiProperty({
+    description: "Total trees grown goal across all organizations"
+  })
+  totalTreesGrownGoal: number;
+
+  @ApiProperty({
+    description: "Trees under restoration data across all organizations by due date",
+    type: [TreeRestorationData]
+  })
+  treesUnderRestorationActualTotal: TreeRestorationData[];
+
+  @ApiProperty({
+    description: "Trees under restoration data for for-profit organizations by due date",
+    type: [TreeRestorationData]
+  })
+  treesUnderRestorationActualForProfit: TreeRestorationData[];
+
+  @ApiProperty({
+    description: "Trees under restoration data for non-profit organizations by due date",
+    type: [TreeRestorationData]
+  })
+  treesUnderRestorationActualNonProfit: TreeRestorationData[];
+
+  @ApiProperty({
+    description: "Timestamp when the data was last updated",
+    type: String,
+    nullable: true
+  })
+  lastUpdatedAt: string | null;
+}