Merge pull request #12 from armitage-labs/feat/store-cred-interval

Store interval data for an contributor

Author: AlecErasmus

cred-manager/packages/@types/sourcecred/index.d.ts

@@ -924,7 +924,7 @@ declare module 'sourcecred' {
   export class CredGrainView {
     constructor(graph: CredGraph, ledger: Ledger);
     participants: () => ParticipantCredGrain[];
-
+    
     totalCredPerInterval: () => number[];
 
     totalGrainPerInterval: () => string[];
@@ -938,6 +938,11 @@ declare module 'sourcecred' {
     grainEarnedPerInterval: string[];
   }
 
+  export interface Interval {
+    startTimeMs: number;
+    endTimeMs: number;
+  }
+
   export interface LedgerManager {
     reloadLedger: () => Promise<ReloadResult>;
     ledger: Ledger;

cred-manager/prisma/schema.prisma

@@ -73,4 +73,14 @@ model UserScore {
   user_type                   String                  @db.VarChar(255)
   score                       String                  @db.VarChar(255)
   created_at                  DateTime                @default(now()) @db.Timestamp(6)
+  UserScoreInterval           UserScoreInterval[]
+}
+
+model UserScoreInterval {
+  id             String    @id @default(uuid())
+  user_score_id  String
+  UserScore      UserScore @relation(fields: [user_score_id], references: [id], onDelete: Cascade)
+  score          String    @db.VarChar(255)
+  interval_start String    @db.VarChar(255)
+  interval_end   String    @db.VarChar(255)
 }

cred-manager/src/sourcecred/service/calculationQueue.service.ts

@@ -29,13 +29,18 @@ export class CalculationQueueService {
       });
       if (unhandledCalculation) {
         this.logger.debug("Handling unhandled calculation request.");
-        // update semaphore to unavailable
-        await this.prismaService.calculationSemaphore.update({
-          where: { id: semaphore.id },
-          data: { available: false }
-        })
-        // calculate cred scores
-        await this.sourceCredService.calculateCredScores(unhandledCalculation.team_id, unhandledCalculation.access_token, unhandledCalculation.email);
+        try {
+          // update semaphore to unavailable
+          await this.prismaService.calculationSemaphore.update({
+            where: { id: semaphore.id },
+            data: { available: false }
+          })
+          // calculate cred scores
+          await this.sourceCredService.calculateCredScores(unhandledCalculation.team_id, unhandledCalculation.access_token, unhandledCalculation.email);
+        } catch(e) {
+            this.logger.error(e);
+        }
+      
         // delete the contribution request
         await this.prismaService.contributionRequest.delete({
           where: { id: unhandledCalculation.id }
@@ -45,7 +50,6 @@ export class CalculationQueueService {
           where: { id: semaphore.id },
           data: { available: true }
         });
-
       }
     } else {
       this.logger.debug("Semaphore unavailable.");

cred-manager/src/sourcecred/service/sourcecred.service.ts

@@ -54,6 +54,7 @@ export class SourceCredService {
     const pluginConfigString = this.craftPluginConfigString(
       userRegisteredRepos.map((repo) => repo.full_name),
     );
+    await this.deleteContribution(teamId);
     const contribution = await this.saveContribution(teamId);
     await this.configureSourcecredGithubPlugin(pluginConfigString);
     await this.loadSourceCredPlugins(gitHubToken);
@@ -124,6 +125,8 @@ export class SourceCredService {
           totalCred: participant.cred,
           userName: participant.identity.name,
           type: participant.identity.subtype.toString(),
+          credPerInterval: participant.credPerInterval,
+          grainEarnedPerInterval: participant.grainEarnedPerInterval,
         });
       },
     );
@@ -134,6 +137,23 @@ export class SourceCredService {
     return userDtoArray.sort((a, b) => b.totalCred - a.totalCred);
   }
 
+  async deleteContribution(teamId: string) {
+    const contribution = await this.prismaService.contributionCalculation.findFirst({
+      where: {
+        team_id: teamId,
+      }
+    });
+
+
+    if (contribution != null) {
+      await this.prismaService.contributionCalculation.deleteMany({
+        where: {
+          id : contribution.id
+        }
+      });
+    }
+  }
+
   async saveContribution(teamId: string): Promise<ContributionCalculationDto> {
     try {
       const contribution =
@@ -153,17 +173,29 @@ export class SourceCredService {
     contributionCalculationId: string,
     userCredDtos: UserCredDto[],
   ) {
+    // need to delete the user score and interval for the team before we insert new one
     try {
-      return await this.prismaService.userScore.createMany({
-        data: userCredDtos.map((userCredDto) => {
-          return {
-            username: userCredDto.userName,
-            user_type: userCredDto.type,
-            score: userCredDto.totalCred.toString(),
-            contribution_calculation_id: contributionCalculationId,
-          };
-        }),
-      });
+      for(var i = 0; i < userCredDtos.length; i++) {
+        const userScore = await this.prismaService.userScore.create({ 
+          data : {
+              username: userCredDtos[i].userName,
+              user_type: userCredDtos[i].type,
+              score: userCredDtos[i].totalCred.toString(),
+              contribution_calculation_id: contributionCalculationId,
+            }
+        });
+
+        await this.prismaService.userScoreInterval.createMany({
+          data: userCredDtos[i].credPerInterval.map((interval) => {
+            return {
+              user_score_id: userScore.id,
+              score: interval.toString(),
+              interval_start: new Date().getTime().toString(), // TODO we need to get interval from graph
+              interval_end: new Date().getTime().toString(), // TODO we need to get interval from graph
+            };
+          }),
+        });
+      }
     } catch (error) {
       console.error('Error creating users scores', error);
       throw error;

cred-manager/src/sourcecred/types/userCredDto.ts

@@ -2,24 +2,30 @@ export interface UserCredJson {
   totalCred: number;
   userName: string;
   type: string;
+  credPerInterval?: number[];
+  grainEarnedPerInterval?: string[];
 }
 
 export class UserCredDto {
   constructor(
     public totalCred: number,
     public userName: string,
     public type: string,
+    public credPerInterval?: number[],
+    public grainEarnedPerInterval?: string[]
   ) {}
 
   toJSON(): UserCredJson {
     return {
       totalCred: this.totalCred,
       userName: this.userName,
       type: this.type,
+      credPerInterval: this.credPerInterval,
+      grainEarnedPerInterval: this.grainEarnedPerInterval
     };
   }
 
   static fromJSON(json: UserCredJson): UserCredDto {
-    return new UserCredDto(json.totalCred, json.userName, json.type);
+    return new UserCredDto(json.totalCred, json.userName, json.type, json.credPerInterval, json.grainEarnedPerInterval);
   }
 }

prisma/schema.prisma

@@ -73,4 +73,14 @@ model UserScore {
   user_type                   String                  @db.VarChar(255)
   score                       String                  @db.VarChar(255)
   created_at                  DateTime                @default(now()) @db.Timestamp(6)
+  UserScoreInterval           UserScoreInterval[]
+}
+
+model UserScoreInterval {
+  id             String    @id @default(uuid())
+  user_score_id  String
+  UserScore      UserScore @relation(fields: [user_score_id], references: [id], onDelete: Cascade)
+  score          String    @db.VarChar(255)
+  interval_start String    @db.VarChar(255)
+  interval_end   String    @db.VarChar(255)
 }