Teams: Fixed: Last updated date

Author: vbakke

src/app/model/activity-store.ts

@@ -63,16 +63,11 @@ export class ActivityStore {
   private _categoryNames: string[] = [];
   private _allDimensions: Record<string, Activity[]> = {};
   private _maxLevel: number = -1;
-  private _progress: Progress = {};
 
   public getData(): Data {
     return this.data;
   }
 
-  // public getProgress(): Progress {
-  //   return this._progress;
-  // }
-
   public getAllActivities(): Activity[] {
     return this._activityList;
   }
@@ -121,10 +116,6 @@ export class ActivityStore {
       this.data = yaml;
     } else {
       this.removeIgnoredActivities(ignoreList, this._activityList);
-      // let activityByName: Record<string, Activity> = {};
-      // let activityByUuid: Record<string, Activity> = {};
-      //this._ensureNoDuplicateIds(...)
-      //this.buildLookups(activityList, activityByName, activityByUuid,errors);
       this.mergeActivities(activityList, this._activityList, errors);
 
       // Reset lookup tables after merge

src/app/model/progress-store.ts

@@ -160,6 +160,19 @@ export class ProgressStore {
     return this._progressTitles[0];
   }
 
+  public getInProgressTitles(): ProgressTitle[] {
+    if (!this._progressTitles) return [];
+    return this._progressTitles.slice(1, -1);
+  }
+
+  public getCompletedProgressTitle(): ProgressTitle {
+    if (!this._progressTitles) return '';
+    return this._progressTitles.slice(-1)[0];
+  }
+
+  /* All activities:
+   *  - where all teams have Completed status
+   */
   public getActivitiesCompletedForTeams(teamNames: TeamName[]): TeamActivityProgress[] {
     let completedName: ProgressTitle = this._progressTitlesDescOrder?.[0] || '';
 
@@ -184,16 +197,32 @@ export class ProgressStore {
     return activitiesCompleted;
   }
 
-  public getInProgressTitles(): ProgressTitle[] {
-    if (!this._progressTitles) return [];
-    return this._progressTitles.slice(1, -1);
-  }
+  /* Activities Started:
+   *  - where at least one teams have a progress stage > 0%
+   */
+  public getActivitiesStartedForTeams(teamNames: TeamName[]): TeamActivityProgress[] {
+    let initiatedName: ProgressTitle = this._progressTitles?.[1] || '';
 
-  public getCompleetedProgressTitle(): ProgressTitle {
-    if (!this._progressTitles) return '';
-    return this._progressTitles.slice(-1)[0];
+    let activitiesCompleted: TeamActivityProgress[] = [];
+    for (let activityUuid in this._progress) {
+      for (let teamName of teamNames) {
+        // Only include started activities
+        if (this._progress?.[activityUuid]?.[teamName]?.[initiatedName]) {
+          let teamActivityProgress: TeamActivityProgress = {
+            team: teamName,
+            activityUuid: activityUuid,
+            progress: this._progress[activityUuid][teamName],
+          };
+          activitiesCompleted.push(teamActivityProgress);
+        }
+      }
+    }
+    return activitiesCompleted;
   }
 
+  /* Activities In Progress:
+   *  - where at least one teams have a progress stage > 0%, but also less than 100%
+   */
   public getActivitiesInProgressForTeams(teamNames: TeamName[]): TeamActivityProgress[] {
     let initiatedName: ProgressTitle = this._progressTitles?.[1] || '';
     let completedName: ProgressTitle = this._progressTitlesDescOrder?.[0] || '';

src/app/pages/teams/teams.component.ts

@@ -1,6 +1,7 @@
 import { AfterViewInit, Component, OnInit, ViewChild } from '@angular/core';
 import { MatSort } from '@angular/material/sort';
 import { MatTableDataSource } from '@angular/material/table';
+import { sum } from 'd3';
 import {
   DialogInfo,
   ModalMessageComponent,
@@ -33,7 +34,7 @@ export class TeamsComponent implements OnInit, AfterViewInit {
   infoTeams: TeamNames = [];
   info: Record<string, TeamSummary> = {};
 
-  dataSource: MatTableDataSource<TeamActivityProgress> = new MatTableDataSource<TeamActivityProgress>([]); // eslint-disable-line
+  dataSource: MatTableDataSource<TeamSummaryActivityProgress> = new MatTableDataSource<TeamSummaryActivityProgress>([]); // eslint-disable-line
   allColumnNames: string[] = [];
   progressColumnNames: string[] = [];
   @ViewChild(MatSort, { static: false }) sort!: MatSort;
@@ -60,7 +61,10 @@ export class TeamsComponent implements OnInit, AfterViewInit {
   ngAfterViewInit() {
     if (this.sort) {
       this.dataSource.sort = this.sort;
-      this.dataSource.sortingDataAccessor = (item: TeamActivityProgress, property: string) => {
+      this.dataSource.sortingDataAccessor = (
+        item: TeamSummaryActivityProgress,
+        property: string
+      ) => {
         if (property === 'Team') {
           return item.team;
         }
@@ -170,12 +174,13 @@ export class TeamsComponent implements OnInit, AfterViewInit {
 
   makeTeamSummary(name: string, teams: TeamNames): TeamSummary {
     /* eslint-disable */
-    let activitiesCompleted: progressStoreMapping[] = this.dataStore?.progressStore?.getActivitiesCompletedForTeams(teams) || [];
+    let activitiesStarted: progressStoreMapping[] = this.dataStore?.progressStore?.getActivitiesStartedForTeams(teams) || [];
     let activitiesInProgress: progressStoreMapping[] = this.dataStore?.progressStore?.getActivitiesInProgressForTeams(teams) || [];
+    let activitiesCompleted: progressStoreMapping[] = this.dataStore?.progressStore?.getActivitiesCompletedForTeams(teams) || [];
 
     let summary: TeamSummary = {
       teams,
-      lastUpdated: new Date(),
+      lastUpdated: null,
       activitiesCompleted: [],
       activitiesInProgress: [],
       uniqueActivitiesCompletedCount: 0,
@@ -186,32 +191,43 @@ export class TeamsComponent implements OnInit, AfterViewInit {
     summary.activitiesInProgress = activitiesInProgress.map(activityProgress => _self.mapIncludeActivity(activityProgress));
     summary.uniqueActivitiesCompletedCount = uniqueCount(summary.activitiesCompleted.map(item => item.activity.uuid));
     summary.uniqueActivitiesInProgressCount = uniqueCount(summary.activitiesInProgress.map(item => item.activity.uuid));
+    if (activitiesStarted.length == 0) {
+      summary.lastUpdated = null;
+    } else {
+      summary.lastUpdated = activitiesStarted.map(activityProgress => _self.mapIncludeActivity(activityProgress).lastUpdated)
+        // .map(activityProgress => activityProgress.lastUpdated)
+        .reduce((max, current) => (current > max ? current : max));
+    }
     /* eslint-enable */
 
     return summary;
   }
 
-  mapIncludeActivity(input: progressStoreMapping): TeamActivityProgress {
+  mapIncludeActivity(input: progressStoreMapping): TeamSummaryActivityProgress {
     return {
       team: input.team,
       activity:
         this.dataStore?.activityStore?.getActivityByUuid(input.activityUuid) || ({} as Activity),
       progress: input.progress,
+      lastUpdated: Object.values(input.progress).reduce((max, current) =>
+        current > max ? current : max
+      ),
     };
   }
 }
 
 export interface TeamSummary {
   teams: TeamNames;
-  lastUpdated: Date;
-  activitiesCompleted: TeamActivityProgress[];
-  activitiesInProgress: TeamActivityProgress[];
+  lastUpdated: Date | null;
+  activitiesCompleted: TeamSummaryActivityProgress[];
+  activitiesInProgress: TeamSummaryActivityProgress[];
   uniqueActivitiesCompletedCount: number;
   uniqueActivitiesInProgressCount: number;
 }
 
-export interface TeamActivityProgress {
+export interface TeamSummaryActivityProgress {
   team: TeamName;
   activity: Activity;
   progress: TeamProgress;
+  lastUpdated: Date;
 }

src/assets/Markdown Files/TODO-central-loader.md

@@ -1,6 +1,5 @@
 ## Doing
  - Bug: Teams: Reads progress heading from activityStore, not metaStore
- - Bug: Teams: Last updated gives the incorrect date
 
 ## Next
 ### Dependency graph