2c176c052d
* make uses a private field for ConstructUses * expose capped list of uses in ConstructUses * filter capped construct uses in getUses
531 lines
18 KiB
Dart
531 lines
18 KiB
Dart
import 'package:flutter/material.dart';
|
|
|
|
import 'package:fluffychat/l10n/l10n.dart';
|
|
import 'package:fluffychat/pangea/analytics_data/construct_merge_table.dart';
|
|
import 'package:fluffychat/pangea/analytics_data/derived_analytics_data_model.dart';
|
|
import 'package:fluffychat/pangea/analytics_downloads/space_analytics_summary_enum.dart';
|
|
import 'package:fluffychat/pangea/analytics_misc/construct_type_enum.dart';
|
|
import 'package:fluffychat/pangea/analytics_misc/construct_use_model.dart';
|
|
import 'package:fluffychat/pangea/analytics_misc/construct_use_type_enum.dart';
|
|
import 'package:fluffychat/pangea/analytics_misc/constructs_event.dart';
|
|
import 'package:fluffychat/pangea/analytics_misc/constructs_model.dart';
|
|
import 'package:fluffychat/pangea/constructs/construct_identifier.dart';
|
|
|
|
class SpaceAnalyticsSummaryModel {
|
|
String username;
|
|
bool dataAvailable;
|
|
int? level;
|
|
int? totalXP;
|
|
|
|
int? numLemmas;
|
|
int? numLemmasUsedCorrectly;
|
|
int? numLemmasUsedIncorrectly;
|
|
|
|
/// 0 - 30 XP
|
|
int? numLemmasSmallXP;
|
|
|
|
/// 31 - 200 XP
|
|
int? numLemmasMediumXP;
|
|
|
|
/// > 200 XP
|
|
int? numLemmasLargeXP;
|
|
|
|
int? numMorphConstructs;
|
|
List<String>? listMorphConstructs;
|
|
List<String>? listMorphConstructsUsedCorrectlyOriginal;
|
|
List<String>? listMorphConstructsUsedIncorrectlyOriginal;
|
|
List<String>? listMorphConstructsUsedCorrectlySystem;
|
|
List<String>? listMorphConstructsUsedIncorrectlySystem;
|
|
|
|
// list morph 0 - 30 XP
|
|
List<String>? listMorphSmallXP;
|
|
|
|
// list morph 31 - 200 XP
|
|
List<String>? listMorphMediumXP;
|
|
|
|
// list morph 200 - 500 XP
|
|
List<String>? listMorphLargeXP;
|
|
|
|
// list morph > 500 XP
|
|
List<String>? listMorphHugeXP;
|
|
|
|
int? numMessagesSent;
|
|
int? numWordsTyped;
|
|
int? numChoicesCorrect;
|
|
int? numChoicesIncorrect;
|
|
|
|
int numCompletedActivities;
|
|
|
|
SpaceAnalyticsSummaryModel({
|
|
required this.username,
|
|
required this.dataAvailable,
|
|
this.level,
|
|
this.totalXP,
|
|
this.numLemmas,
|
|
this.numLemmasUsedCorrectly,
|
|
this.numLemmasUsedIncorrectly,
|
|
this.numLemmasSmallXP,
|
|
this.numLemmasMediumXP,
|
|
this.numLemmasLargeXP,
|
|
this.numMorphConstructs,
|
|
this.listMorphConstructs,
|
|
this.listMorphConstructsUsedCorrectlyOriginal,
|
|
this.listMorphConstructsUsedIncorrectlyOriginal,
|
|
this.listMorphConstructsUsedCorrectlySystem,
|
|
this.listMorphConstructsUsedIncorrectlySystem,
|
|
this.listMorphSmallXP,
|
|
this.listMorphMediumXP,
|
|
this.listMorphLargeXP,
|
|
this.listMorphHugeXP,
|
|
this.numMessagesSent,
|
|
this.numWordsTyped,
|
|
this.numChoicesCorrect,
|
|
this.numChoicesIncorrect,
|
|
this.numCompletedActivities = 0,
|
|
});
|
|
|
|
static SpaceAnalyticsSummaryModel emptyModel(String userID) {
|
|
return SpaceAnalyticsSummaryModel(
|
|
username: userID,
|
|
dataAvailable: false,
|
|
);
|
|
}
|
|
|
|
static SpaceAnalyticsSummaryModel fromEvents(
|
|
String username,
|
|
List<ConstructAnalyticsEvent> events,
|
|
Set<ConstructIdentifier> blockedConstructs,
|
|
int numCompletedActivities,
|
|
) {
|
|
int totalXP = 0;
|
|
int numWordsTyped = 0;
|
|
int numChoicesCorrect = 0;
|
|
int numChoicesIncorrect = 0;
|
|
|
|
final Set<String> sentEventIds = {};
|
|
final List<OneConstructUse> allUses = [];
|
|
|
|
final Map<ConstructIdentifier, List<OneConstructUse>> aggregatedVocab = {};
|
|
final Map<ConstructIdentifier, List<OneConstructUse>> aggregatedMorph = {};
|
|
|
|
final ConstructMergeTable mergeTable = ConstructMergeTable();
|
|
|
|
for (final e in events) {
|
|
mergeTable.addConstructsByUses(e.content.uses, blockedConstructs);
|
|
|
|
for (final use in e.content.uses) {
|
|
totalXP += use.xp;
|
|
allUses.add(use);
|
|
|
|
if (use.useType.summaryEnumType ==
|
|
SpaceAnalyticsSummaryEnum.numWordsTyped) {
|
|
numWordsTyped = numWordsTyped + 1;
|
|
} else if (use.useType.summaryEnumType ==
|
|
SpaceAnalyticsSummaryEnum.numChoicesCorrect) {
|
|
numChoicesCorrect = numChoicesCorrect + 1;
|
|
} else if (use.useType.summaryEnumType ==
|
|
SpaceAnalyticsSummaryEnum.numChoicesIncorrect) {
|
|
numChoicesIncorrect = numChoicesIncorrect + 1;
|
|
}
|
|
|
|
if (use.useType.sentByUser && use.metadata.eventId != null) {
|
|
sentEventIds.add(use.metadata.eventId!);
|
|
}
|
|
|
|
final id = use.identifier;
|
|
final existing = id.type == ConstructTypeEnum.vocab
|
|
? aggregatedVocab[id]
|
|
: aggregatedMorph[id];
|
|
|
|
if (existing != null) {
|
|
existing.add(use);
|
|
} else {
|
|
id.type == ConstructTypeEnum.vocab
|
|
? aggregatedVocab[id] = [use]
|
|
: aggregatedMorph[id] = [use];
|
|
}
|
|
}
|
|
}
|
|
|
|
final Map<ConstructIdentifier, ConstructUses> aggregatedVocabUses = {};
|
|
for (final entry in aggregatedVocab.entries) {
|
|
aggregatedVocabUses[entry.key] = ConstructUses(
|
|
lemma: entry.value.first.lemma,
|
|
constructType: entry.value.first.constructType,
|
|
category: entry.value.first.category,
|
|
uses: entry.value,
|
|
);
|
|
}
|
|
|
|
final Map<ConstructIdentifier, ConstructUses> aggregatedMorphUses = {};
|
|
for (final entry in aggregatedMorph.entries) {
|
|
aggregatedMorphUses[entry.key] = ConstructUses(
|
|
lemma: entry.value.first.lemma,
|
|
constructType: entry.value.first.constructType,
|
|
category: entry.value.first.category,
|
|
uses: entry.value,
|
|
);
|
|
}
|
|
|
|
final cleanedVocab = <ConstructIdentifier, ConstructUses>{};
|
|
for (final entry in aggregatedVocabUses.values) {
|
|
final canonical = mergeTable.resolve(entry.id);
|
|
final existing = cleanedVocab[canonical];
|
|
if (existing != null) {
|
|
existing.merge(entry);
|
|
} else {
|
|
cleanedVocab[canonical] = entry;
|
|
}
|
|
}
|
|
|
|
final cleanedMorph = <ConstructIdentifier, ConstructUses>{};
|
|
for (final entry in aggregatedMorphUses.values) {
|
|
final canonical = mergeTable.resolve(entry.id);
|
|
final existing = cleanedMorph[canonical];
|
|
if (existing != null) {
|
|
existing.merge(entry);
|
|
} else {
|
|
cleanedMorph[canonical] = entry;
|
|
}
|
|
}
|
|
|
|
final level = DerivedAnalyticsDataModel.calculateLevelWithXp(totalXP);
|
|
final uniqueVocabCount = cleanedVocab.length;
|
|
final uniqueMorphCount = cleanedMorph.length;
|
|
|
|
int vocabUsedCorrectly = 0;
|
|
int vocabUsedIncorrectly = 0;
|
|
int vocabSmallXP = 0;
|
|
int vocabMediumXP = 0;
|
|
int vocabLargeXP = 0;
|
|
|
|
for (final entry in cleanedVocab.values) {
|
|
final xp = entry.points;
|
|
|
|
if (xp >= 0 && xp <= 29) {
|
|
vocabSmallXP += 1;
|
|
} else if (xp >= 30 && xp < 200) {
|
|
vocabMediumXP += 1;
|
|
} else if (xp >= 200) {
|
|
vocabLargeXP += 1;
|
|
}
|
|
|
|
if (entry.hasCorrectUse) {
|
|
vocabUsedCorrectly += 1;
|
|
} else {
|
|
vocabUsedIncorrectly += 1;
|
|
}
|
|
}
|
|
|
|
final originalUseTypes = {
|
|
ConstructUseTypeEnum.wa,
|
|
ConstructUseTypeEnum.ga,
|
|
ConstructUseTypeEnum.ta,
|
|
};
|
|
|
|
final List<String> morphConstructs = [];
|
|
final List<String> morphSmallXP = [];
|
|
final List<String> morphMediumXP = [];
|
|
final List<String> morphLargeXP = [];
|
|
final List<String> morphHugeXP = [];
|
|
final List<String> morphCorrectOriginal = [];
|
|
final List<String> morphIncorrectOriginal = [];
|
|
final List<String> morphCorrectSystem = [];
|
|
final List<String> morphIncorrectSystem = [];
|
|
|
|
for (final entry in cleanedMorph.values) {
|
|
morphConstructs.add(entry.lemma);
|
|
final xp = entry.points;
|
|
|
|
if (xp >= 0 && xp <= 50) {
|
|
morphSmallXP.add(entry.lemma);
|
|
} else if (xp >= 51 && xp <= 200) {
|
|
morphMediumXP.add(entry.lemma);
|
|
} else if (xp >= 201 && xp <= 500) {
|
|
morphLargeXP.add(entry.lemma);
|
|
} else if (xp >= 501) {
|
|
morphHugeXP.add(entry.lemma);
|
|
}
|
|
|
|
final originalUsesCorrect = [];
|
|
final originalUsesIncorrect = [];
|
|
final systemUsesCorrect = [];
|
|
final systemUsesIncorrect = [];
|
|
|
|
for (final use in entry.cappedUses) {
|
|
if (originalUseTypes.contains(use.useType)) {
|
|
use.xp > 0
|
|
? originalUsesCorrect.add(use)
|
|
: originalUsesIncorrect.add(use);
|
|
} else {
|
|
use.xp > 0
|
|
? systemUsesCorrect.add(use)
|
|
: systemUsesIncorrect.add(use);
|
|
}
|
|
}
|
|
|
|
// if >= 80% correct original uses
|
|
if (originalUsesCorrect.length + originalUsesIncorrect.length > 0) {
|
|
final percentCorrect = originalUsesCorrect.length /
|
|
(originalUsesCorrect.length + originalUsesIncorrect.length);
|
|
if (percentCorrect >= 0.8) {
|
|
morphCorrectOriginal.add(entry.lemma);
|
|
} else {
|
|
morphIncorrectOriginal.add(entry.lemma);
|
|
}
|
|
|
|
if (systemUsesCorrect.length + systemUsesIncorrect.length > 0) {
|
|
final percentCorrectSystem = systemUsesCorrect.length /
|
|
(systemUsesCorrect.length + systemUsesIncorrect.length);
|
|
if (percentCorrectSystem >= 0.8) {
|
|
morphCorrectSystem.add(entry.lemma);
|
|
} else {
|
|
morphIncorrectSystem.add(entry.lemma);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return SpaceAnalyticsSummaryModel(
|
|
username: username,
|
|
dataAvailable: true,
|
|
level: level,
|
|
totalXP: totalXP,
|
|
numLemmas: uniqueVocabCount,
|
|
numLemmasUsedCorrectly: vocabUsedCorrectly,
|
|
numLemmasUsedIncorrectly: vocabUsedIncorrectly,
|
|
numLemmasSmallXP: vocabSmallXP,
|
|
numLemmasMediumXP: vocabMediumXP,
|
|
numLemmasLargeXP: vocabLargeXP,
|
|
numMorphConstructs: uniqueMorphCount,
|
|
listMorphConstructs: morphConstructs,
|
|
listMorphSmallXP: morphSmallXP,
|
|
listMorphMediumXP: morphMediumXP,
|
|
listMorphLargeXP: morphLargeXP,
|
|
listMorphHugeXP: morphHugeXP,
|
|
listMorphConstructsUsedCorrectlyOriginal: morphCorrectOriginal,
|
|
listMorphConstructsUsedIncorrectlyOriginal: morphIncorrectOriginal,
|
|
listMorphConstructsUsedCorrectlySystem: morphCorrectSystem,
|
|
listMorphConstructsUsedIncorrectlySystem: morphIncorrectSystem,
|
|
numMessagesSent: sentEventIds.length,
|
|
numWordsTyped: numWordsTyped,
|
|
numChoicesCorrect: numChoicesCorrect,
|
|
numChoicesIncorrect: numChoicesIncorrect,
|
|
numCompletedActivities: numCompletedActivities,
|
|
);
|
|
}
|
|
|
|
// static SpaceAnalyticsSummaryModel fromConstructListModel(
|
|
// String userID,
|
|
// ConstructListModel? model,
|
|
// int numCompletedActivities,
|
|
// String Function(ConstructUses) getCopy,
|
|
// BuildContext context,
|
|
// ) {
|
|
// final vocabLemmas = model != null
|
|
// ? LemmasToUsesWrapper(
|
|
// model.lemmasToUses(type: ConstructTypeEnum.vocab),
|
|
// )
|
|
// : null;
|
|
// final morphLemmas = model != null
|
|
// ? LemmasToUsesWrapper(
|
|
// model.lemmasToUses(type: ConstructTypeEnum.morph),
|
|
// )
|
|
// : null;
|
|
|
|
// final List<String> correctOriginalUseLemmas = [];
|
|
// final List<String> correctSystemUseLemmas = [];
|
|
// final List<String> incorrectOriginalUseLemmas = [];
|
|
// final List<String> incorrectSystemUseLemmas = [];
|
|
|
|
// if (morphLemmas != null) {
|
|
// final originalWrittenUses = morphLemmas.lemmasByPercent(
|
|
// filter: (use) =>
|
|
// use.useType == ConstructUseTypeEnum.wa ||
|
|
// use.useType == ConstructUseTypeEnum.ga ||
|
|
// use.useType == ConstructUseTypeEnum.ta,
|
|
// percent: 0.8,
|
|
// context: context,
|
|
// );
|
|
|
|
// correctOriginalUseLemmas.addAll(originalWrittenUses.over);
|
|
// incorrectOriginalUseLemmas.addAll(originalWrittenUses.under);
|
|
|
|
// final systemGeneratedUses = morphLemmas.lemmasByPercent(
|
|
// filter: (use) =>
|
|
// use.useType != ConstructUseTypeEnum.wa &&
|
|
// use.useType != ConstructUseTypeEnum.ga &&
|
|
// use.useType != ConstructUseTypeEnum.ta &&
|
|
// use.useType != ConstructUseTypeEnum.unk &&
|
|
// use.xp != 0,
|
|
// percent: 0.8,
|
|
// context: context,
|
|
// );
|
|
|
|
// correctSystemUseLemmas.addAll(systemGeneratedUses.over);
|
|
// incorrectSystemUseLemmas.addAll(systemGeneratedUses.under);
|
|
// }
|
|
|
|
// final vocabLemmasCorrect = vocabLemmas?.lemmasByCorrectUse();
|
|
|
|
// int? numWordsTyped;
|
|
// int? numChoicesCorrect;
|
|
// int? numChoicesIncorrect;
|
|
// if (model != null) {
|
|
// numWordsTyped = 0;
|
|
// numChoicesCorrect = 0;
|
|
// numChoicesIncorrect = 0;
|
|
// for (final use in model.uses) {
|
|
// if (use.useType.summaryEnumType ==
|
|
// SpaceAnalyticsSummaryEnum.numWordsTyped) {
|
|
// numWordsTyped = numWordsTyped! + 1;
|
|
// } else if (use.useType.summaryEnumType ==
|
|
// SpaceAnalyticsSummaryEnum.numChoicesCorrect) {
|
|
// numChoicesCorrect = numChoicesCorrect! + 1;
|
|
// } else if (use.useType.summaryEnumType ==
|
|
// SpaceAnalyticsSummaryEnum.numChoicesIncorrect) {
|
|
// numChoicesIncorrect = numChoicesIncorrect! + 1;
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// final numMessageSent = model?.uses
|
|
// .where((use) => use.useType.sentByUser)
|
|
// .map((use) => use.metadata.eventId)
|
|
// .toSet()
|
|
// .length;
|
|
|
|
// return SpaceAnalyticsSummaryModel(
|
|
// username: userID,
|
|
// dataAvailable: model != null,
|
|
// level: model?.level,
|
|
// totalXP: model?.totalXP,
|
|
// numLemmas: model?.numConstructs(ConstructTypeEnum.vocab),
|
|
// numLemmasUsedCorrectly: vocabLemmasCorrect?.over.length,
|
|
// numLemmasUsedIncorrectly: vocabLemmasCorrect?.under.length,
|
|
// numLemmasSmallXP:
|
|
// vocabLemmas?.thresholdedLemmas(start: 0, end: 30).length,
|
|
// numLemmasMediumXP:
|
|
// vocabLemmas?.thresholdedLemmas(start: 31, end: 200).length,
|
|
// numLemmasLargeXP: vocabLemmas?.thresholdedLemmas(start: 201).length,
|
|
// numMorphConstructs: model?.numConstructs(ConstructTypeEnum.morph),
|
|
// listMorphConstructs: morphLemmas?.lemmasToUses.entries
|
|
// .map((entry) => getCopy(entry.value.first))
|
|
// .toList(),
|
|
// listMorphConstructsUsedCorrectlyOriginal: correctOriginalUseLemmas,
|
|
// listMorphConstructsUsedIncorrectlyOriginal: incorrectOriginalUseLemmas,
|
|
// listMorphConstructsUsedCorrectlySystem: correctSystemUseLemmas,
|
|
// listMorphConstructsUsedIncorrectlySystem: incorrectSystemUseLemmas,
|
|
// listMorphSmallXP: morphLemmas?.thresholdedLemmas(
|
|
// start: 0,
|
|
// end: 50,
|
|
// getCopy: getCopy,
|
|
// ),
|
|
// listMorphMediumXP: morphLemmas?.thresholdedLemmas(
|
|
// start: 51,
|
|
// end: 200,
|
|
// getCopy: getCopy,
|
|
// ),
|
|
// listMorphLargeXP: morphLemmas?.thresholdedLemmas(
|
|
// start: 201,
|
|
// end: 500,
|
|
// getCopy: getCopy,
|
|
// ),
|
|
// listMorphHugeXP: morphLemmas?.thresholdedLemmas(
|
|
// start: 501,
|
|
// getCopy: getCopy,
|
|
// ),
|
|
// numMessagesSent: numMessageSent,
|
|
// numWordsTyped: numWordsTyped,
|
|
// numChoicesCorrect: numChoicesCorrect,
|
|
// numChoicesIncorrect: numChoicesIncorrect,
|
|
// numCompletedActivities: numCompletedActivities,
|
|
// );
|
|
// }
|
|
|
|
dynamic getValue(SpaceAnalyticsSummaryEnum key, BuildContext context) {
|
|
switch (key) {
|
|
case SpaceAnalyticsSummaryEnum.username:
|
|
return username;
|
|
case SpaceAnalyticsSummaryEnum.dataAvailable:
|
|
return dataAvailable
|
|
? L10n.of(context).available
|
|
: L10n.of(context).unavailable;
|
|
case SpaceAnalyticsSummaryEnum.level:
|
|
return level;
|
|
case SpaceAnalyticsSummaryEnum.totalXP:
|
|
return totalXP;
|
|
case SpaceAnalyticsSummaryEnum.numLemmas:
|
|
return numLemmas;
|
|
case SpaceAnalyticsSummaryEnum.numLemmasUsedCorrectly:
|
|
return numLemmasUsedCorrectly;
|
|
case SpaceAnalyticsSummaryEnum.numLemmasUsedIncorrectly:
|
|
return numLemmasUsedIncorrectly;
|
|
case SpaceAnalyticsSummaryEnum.numLemmasSmallXP:
|
|
return numLemmasSmallXP;
|
|
case SpaceAnalyticsSummaryEnum.numLemmasMediumXP:
|
|
return numLemmasMediumXP;
|
|
case SpaceAnalyticsSummaryEnum.numLemmasLargeXP:
|
|
return numLemmasLargeXP;
|
|
case SpaceAnalyticsSummaryEnum.numMorphConstructs:
|
|
return numMorphConstructs;
|
|
case SpaceAnalyticsSummaryEnum.listMorphConstructs:
|
|
return listMorphConstructs;
|
|
case SpaceAnalyticsSummaryEnum.listMorphConstructsUsedCorrectlyOriginal:
|
|
return listMorphConstructsUsedCorrectlyOriginal;
|
|
case SpaceAnalyticsSummaryEnum.listMorphConstructsUsedIncorrectlyOriginal:
|
|
return listMorphConstructsUsedIncorrectlyOriginal;
|
|
case SpaceAnalyticsSummaryEnum.listMorphConstructsUsedCorrectlySystem:
|
|
return listMorphConstructsUsedCorrectlySystem;
|
|
case SpaceAnalyticsSummaryEnum.listMorphConstructsUsedIncorrectlySystem:
|
|
return listMorphConstructsUsedIncorrectlySystem;
|
|
case SpaceAnalyticsSummaryEnum.listMorphSmallXP:
|
|
return listMorphSmallXP;
|
|
case SpaceAnalyticsSummaryEnum.listMorphMediumXP:
|
|
return listMorphMediumXP;
|
|
case SpaceAnalyticsSummaryEnum.listMorphLargeXP:
|
|
return listMorphLargeXP;
|
|
case SpaceAnalyticsSummaryEnum.listMorphHugeXP:
|
|
return listMorphHugeXP;
|
|
case SpaceAnalyticsSummaryEnum.numMessagesSent:
|
|
return numMessagesSent;
|
|
case SpaceAnalyticsSummaryEnum.numWordsTyped:
|
|
return numWordsTyped;
|
|
case SpaceAnalyticsSummaryEnum.numChoicesCorrect:
|
|
return numChoicesCorrect;
|
|
case SpaceAnalyticsSummaryEnum.numChoicesIncorrect:
|
|
return numChoicesIncorrect;
|
|
case SpaceAnalyticsSummaryEnum.numCompletedActivities:
|
|
return numCompletedActivities;
|
|
}
|
|
}
|
|
|
|
Map<String, dynamic> toJson() {
|
|
return {
|
|
'username': username,
|
|
'level': level,
|
|
'totalXP': totalXP,
|
|
'numLemmas': numLemmas,
|
|
'numLemmasUsedCorrectly': numLemmasUsedCorrectly,
|
|
'numLemmasUsedIncorrectly': numLemmasUsedIncorrectly,
|
|
'numLemmasSmallXP': numLemmasSmallXP,
|
|
'numLemmasMediumXP': numLemmasMediumXP,
|
|
'numLemmasLargeXP': numLemmasLargeXP,
|
|
'numMorphConstructs': numMorphConstructs,
|
|
'listMorphConstructs': listMorphConstructs,
|
|
'listMorphConstructsUsedCorrectly':
|
|
listMorphConstructsUsedCorrectlyOriginal,
|
|
'listMorphConstructsUsedIncorrectly':
|
|
listMorphConstructsUsedIncorrectlyOriginal,
|
|
'listMorphSmallXP': listMorphSmallXP,
|
|
'listMorphMediumXP': listMorphMediumXP,
|
|
'listMorphLargeXP': listMorphLargeXP,
|
|
'listMorphHugeXP': listMorphHugeXP,
|
|
'numMessagesSent': numMessagesSent,
|
|
'numWordsWithoutAssistance': numWordsTyped,
|
|
'numChoicesCorrect': numChoicesCorrect,
|
|
'numChoicesIncorrect': numChoicesIncorrect,
|
|
'numCompletedActivities': numCompletedActivities,
|
|
};
|
|
}
|
|
}
|