add tracker compatibility for version 41

i18n/en.pot

@@ -5,8 +5,8 @@ msgstr ""
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=2; plural=(n != 1)\n"
-"POT-Creation-Date: 2024-05-16T07:04:50.457Z\n"
-"PO-Revision-Date: 2024-05-16T07:04:50.458Z\n"
+"POT-Creation-Date: 2024-11-04T15:12:23.322Z\n"
+"PO-Revision-Date: 2024-11-04T15:12:23.322Z\n"
 
 msgid "ID"
 msgstr ""
@@ -56,6 +56,9 @@ msgstr ""
 msgid "No"
 msgstr ""
 
+msgid "Select at least one organisation unit"
+msgstr ""
+
 msgid "Cannot be blank: {{fieldName}}"
 msgstr ""
 
@@ -199,6 +202,9 @@ msgstr ""
 msgid "Summary"
 msgstr ""
 
+msgid "You must save the Analysis configuration before running any step"
+msgstr ""
+
 msgid "Algorithm"
 msgstr ""
 

i18n/es.po

@@ -1,7 +1,7 @@
 msgid ""
 msgstr ""
 "Project-Id-Version: i18next-conv\n"
-"POT-Creation-Date: 2024-05-16T07:04:50.457Z\n"
+"POT-Creation-Date: 2024-11-04T15:12:23.322Z\n"
 "PO-Revision-Date: 2018-10-25T09:02:35.143Z\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
@@ -56,6 +56,9 @@ msgstr ""
 msgid "No"
 msgstr ""
 
+msgid "Select at least one organisation unit"
+msgstr ""
+
 msgid "Cannot be blank: {{fieldName}}"
 msgstr ""
 
@@ -199,6 +202,9 @@ msgstr ""
 msgid "Summary"
 msgstr ""
 
+msgid "You must save the Analysis configuration before running any step"
+msgstr ""
+
 msgid "Algorithm"
 msgstr ""
 

src/CompositionRoot.ts

@@ -88,7 +88,9 @@ type Repositories = {
 
 function getCompositionRoot(repositories: Repositories, metadata: MetadataItem) {
     return {
-        countries: { getByIds: new GetCountriesByIdsUseCase(repositories.countryRepository) },
+        countries: {
+            getByIds: new GetCountriesByIdsUseCase(repositories.countryRepository, metadata),
+        },
         users: { getCurrent: new GetCurrentUserUseCase(repositories.usersRepository) },
         modules: {
             get: new GetModulesUseCase(repositories.moduleRepository),

src/data/common/utils.ts

@@ -1,5 +1,7 @@
 import { MetadataItem } from "$/domain/entities/MetadataItem";
 import { Id } from "$/domain/entities/Ref";
+import { TrackedEntitiesGetResponse } from "$/types/d2-api";
+import { TrackerEventsResponse } from "@eyeseetea/d2-api/api/trackerEvents";
 
 export function getProgramStageIndexById(programStageId: Id, metadata: MetadataItem): number {
     const programStageIndex = metadata.programs.qualityIssues.programStages.findIndex(
@@ -8,3 +10,31 @@ export function getProgramStageIndexById(programStageId: Id, metadata: MetadataI
     if (programStageIndex === -1) throw Error(`Cannot found programStage: ${programStageId}`);
     return programStageIndex;
 }
+
+export function buildTrackerResponse(
+    response: TrackedEntitiesGetResponse & {
+        trackedEntities?: TrackedEntitiesGetResponse["instances"];
+    }
+): TrackedEntitiesGetResponse {
+    if (!response.instances && response.trackedEntities) {
+        return { ...response, instances: response.trackedEntities };
+    } else if (!response.trackedEntities && response.instances) {
+        return response;
+    } else {
+        return response;
+    }
+}
+
+export function buildTrackerEventsResponse(
+    response: TrackerEventsResponse & {
+        events?: TrackerEventsResponse["instances"];
+    }
+): TrackerEventsResponse {
+    if (!response.instances && response.events) {
+        return { ...response, instances: response.events };
+    } else if (!response.events && response.instances) {
+        return response;
+    } else {
+        return response;
+    }
+}

src/data/repositories/IssueD2Repository.ts

@@ -21,7 +21,11 @@ import { Maybe } from "$/utils/ts-utils";
 import { IssueAction } from "$/domain/entities/IssueAction";
 import { IssueStatus } from "$/domain/entities/IssueStatus";
 import { getDefaultModules } from "$/data/common/D2Module";
-import { getProgramStageIndexById } from "$/data/common/utils";
+import {
+    buildTrackerEventsResponse,
+    buildTrackerResponse,
+    getProgramStageIndexById,
+} from "$/data/common/utils";
 
 export class IssueD2Repository implements IssueRepository {
     d2DataElement: D2DataElement;
@@ -61,7 +65,7 @@ export class IssueD2Repository implements IssueRepository {
                 event: filters.id ? filters.id : undefined,
             })
         ).flatMap(d2Response => {
-            const instances = d2Response.instances;
+            const instances = buildTrackerEventsResponse(d2Response).instances;
             const orgUnitIds = this.getRelatedIdsFromDataValues(
                 instances,
                 this.getDataElementIdOrThrow("country")
@@ -100,7 +104,7 @@ export class IssueD2Repository implements IssueRepository {
                 event: id ? id : undefined,
             })
         ).flatMap(d2Response => {
-            const d2Event = d2Response.instances[0];
+            const d2Event = buildTrackerEventsResponse(d2Response).instances[0];
             if (!d2Event) return Future.error(new Error(`Cannot found event: ${id}`));
 
             const orgUnitIds = this.getRelatedIdsFromDataValues(
@@ -146,7 +150,8 @@ export class IssueD2Repository implements IssueRepository {
                 trackedEntity: analysisId,
             })
         ).flatMap(d2Response => {
-            const tei = d2Response.instances.find(tei => tei.trackedEntity === analysisId);
+            const instances = buildTrackerResponse(d2Response).instances;
+            const tei = instances.find(tei => tei.trackedEntity === analysisId);
             if (!tei) return Future.error(new Error(`Cannot found TEI: ${tei}`));
             const enrollment = _(tei.enrollments || []).first();
             if (!enrollment)

src/data/repositories/QualityAnalysisD2Repository.ts

@@ -35,7 +35,7 @@ import { D2OrgUnit } from "$/data/common/D2Country";
 import { getUid } from "$/utils/uid";
 import { DATA_QUALITY_NAMESPACE } from "$/domain/entities/Settings";
 import { getDefaultModules } from "$/data/common/D2Module";
-import { getProgramStageIndexById } from "$/data/common/utils";
+import { buildTrackerResponse, getProgramStageIndexById } from "$/data/common/utils";
 
 export class QualityAnalysisD2Repository implements QualityAnalysisRepository {
     d2DataElement: D2DataElement;
@@ -67,8 +67,8 @@ export class QualityAnalysisD2Repository implements QualityAnalysisRepository {
                 totalPages: true,
             })
         ).flatMap(d2Response => {
-            const instances = d2Response.instances;
-            const teiIds = _(d2Response.instances)
+            const instances = buildTrackerResponse(d2Response).instances;
+            const teiIds = _(instances)
                 .map(instance => instance.trackedEntity)
                 .compact()
                 .value();
@@ -240,10 +240,9 @@ export class QualityAnalysisD2Repository implements QualityAnalysisRepository {
                 trackedEntity: qaIds.join(";"),
             })
         ).flatMap(d2Response => {
+            const instances = buildTrackerResponse(d2Response).instances;
             const qualityAnalysisToPost = qaIds.map(qaId => {
-                const existingTei = d2Response.instances.find(
-                    d2Tei => d2Tei.trackedEntity === qaId
-                );
+                const existingTei = instances.find(d2Tei => d2Tei.trackedEntity === qaId);
                 const qAnalysis = qualityAnalysis.find(qai => qai.id === qaId);
                 if (!qAnalysis) {
                     throw Error(`Cannot find qualityAnalysis: ${qaId}`);

src/data/repositories/ValidationRuleAnalysisD2Repository.ts

@@ -9,11 +9,14 @@ import {
 import { ValidationRule } from "$/domain/entities/ValidationRuleGroup";
 import _ from "$/domain/entities/generic/Collection";
 import { Future } from "$/domain/entities/generic/Future";
+import i18n from "$/utils/i18n";
 
 export class ValidationRuleAnalysisD2Repository implements ValidationRuleAnalysisRepository {
     constructor(private api: D2Api) {}
 
     get(options: ValidationRuleOptions): FutureData<ValidationRuleAnalysis[]> {
+        if (!options.countryId)
+            return Future.error(new Error(i18n.t("Select at least one organisation unit")));
         return apiToFuture(
             this.api.request<D2ValidationRuleAnalysis[]>({
                 method: "post",

src/domain/entities/QualityAnalysis.ts

@@ -26,12 +26,31 @@ export class QualityAnalysis extends Struct<QualityAnalysisAttrs>() {
     static build(
         attrs: QualityAnalysisAttrs
     ): Either<ValidationError<QualityAnalysis>[], QualityAnalysis> {
-        const qualityAnalysis = new QualityAnalysis({
-            ...attrs,
-            name: attrs.name,
-        });
+        const qualityAnalysis = new QualityAnalysis({ ...attrs, name: attrs.name });
+        const errors: ValidationError<QualityAnalysis>[] = QualityAnalysis.getErrors(
+            qualityAnalysis,
+            { validateCountries: false }
+        );
+        return errors.length === 0 ? Either.success(qualityAnalysis) : Either.error(errors);
+    }
 
-        const errors: ValidationError<QualityAnalysis>[] = [
+    private static getErrors(
+        qualityAnalysis: QualityAnalysis,
+        options: { validateCountries: boolean }
+    ): ValidationError<QualityAnalysis>[] {
+        const countryProperty = options.validateCountries
+            ? [
+                  {
+                      property: "countriesAnalysis" as const,
+                      errors: validateRequired(
+                          qualityAnalysis.countriesAnalysis,
+                          "country_validation"
+                      ),
+                      value: qualityAnalysis.countriesAnalysis,
+                  },
+              ]
+            : [];
+        return [
             {
                 property: "name" as const,
                 errors: validateRequired(qualityAnalysis.name),
@@ -57,13 +76,19 @@ export class QualityAnalysis extends Struct<QualityAnalysisAttrs>() {
                 errors: validateRequired(qualityAnalysis.status),
                 value: qualityAnalysis.status,
             },
+            ...countryProperty,
         ].filter(validation => validation.errors.length > 0);
+    }
 
-        if (errors.length === 0) {
-            return Either.success(qualityAnalysis);
-        } else {
-            return Either.error(errors);
-        }
+    static updateConfiguration(
+        attrs: QualityAnalysisAttrs
+    ): Either<ValidationError<QualityAnalysis>[], QualityAnalysis> {
+        const qualityAnalysis = this.build(attrs).get();
+        const errors: ValidationError<QualityAnalysis>[] = QualityAnalysis.getErrors(
+            qualityAnalysis,
+            { validateCountries: true }
+        );
+        return errors.length === 0 ? Either.success(qualityAnalysis) : Either.error(errors);
     }
 
     static hasExecutedSections(qualityAnalysis: QualityAnalysis): boolean {
@@ -77,6 +102,7 @@ export class QualityAnalysis extends Struct<QualityAnalysisAttrs>() {
         const formattedDate = date.toISOString().replace(/[-:T.]/g, "_");
         return `${prefix} - ${formattedDate}`;
     }
+
     static isModuleTwo(qualityAnalysis: QualityAnalysis): boolean {
         return qualityAnalysis.module.code === MODULE_2_CODE;
     }

src/domain/entities/Settings.ts

@@ -48,11 +48,6 @@ export class Settings extends Struct<SettingsAttrs>() {
                 errors: validateRequired(settings.startDate),
                 value: settings.startDate,
             },
-            {
-                property: "countryIds" as const,
-                errors: validateRequired(settings.countryIds),
-                value: settings.countryIds,
-            },
         ].filter(validation => validation.errors.length > 0);
 
         if (errors.length === 0) {

src/domain/entities/generic/Errors.ts

@@ -1,8 +1,9 @@
 import i18n from "$/utils/i18n";
 
-export type ValidationErrorKey = "field_cannot_be_blank";
+export type ValidationErrorKey = "field_cannot_be_blank" | "country_validation";
 
 export const validationErrorMessages: Record<ValidationErrorKey, (fieldName: string) => string> = {
+    country_validation: () => i18n.t("Select at least one organisation unit"),
     field_cannot_be_blank: (fieldName: string) =>
         i18n.t(`Cannot be blank: {{fieldName}}`, { fieldName: fieldName, nsSeparator: false }),
 };

src/domain/entities/generic/validations.ts

@@ -1,7 +1,14 @@
 import { ValidationErrorKey } from "./Errors";
 
-export function validateRequired(value: any): ValidationErrorKey[] {
+export function validateRequired(
+    value: any,
+    errorCode: ValidationErrorKey = "field_cannot_be_blank"
+): ValidationErrorKey[] {
     const isBlank = !value || (value.length !== undefined && value.length === 0);
 
-    return isBlank ? ["field_cannot_be_blank"] : [];
+    return isBlank ? setErrorCode(errorCode) : [];
+}
+
+function setErrorCode(errorCode?: ValidationErrorKey): ValidationErrorKey[] {
+    return errorCode ? [errorCode] : ["field_cannot_be_blank"];
 }

src/domain/usecases/CreateQualityAnalysisUseCase.ts

@@ -49,9 +49,7 @@ export class CreateQualityAnalysisUseCase {
                 status: "In Progress",
                 lastModification: "",
                 countriesAnalysis: defaultSettings.countryIds,
-                sequential: {
-                    value: `DQ-${sequential.value}`,
-                },
+                sequential: { value: `DQ-${sequential.value}` },
             }).match({
                 error: errors => {
                     const errorMessages = getErrors(errors);

src/domain/usecases/GetCountriesByIdsUseCase.ts

@@ -1,14 +1,16 @@
 import { FutureData } from "$/data/api-futures";
 import { Country } from "$/domain/entities/Country";
+import { MetadataItem } from "$/domain/entities/MetadataItem";
 import { Id } from "$/domain/entities/Ref";
 import { Future } from "$/domain/entities/generic/Future";
 import { CountryRepository } from "$/domain/repositories/CountryRepository";
 
 export class GetCountriesByIdsUseCase {
-    constructor(private countryRepository: CountryRepository) {}
+    constructor(private countryRepository: CountryRepository, private config: MetadataItem) {}
 
     execute(ids: Id[]): FutureData<Country[]> {
         if (ids.length === 0) return Future.success([]);
+
         return this.countryRepository.getByIds(ids);
     }
 }

src/domain/usecases/RunOutlierUseCase.ts

@@ -34,7 +34,8 @@ export class RunOutlierUseCase {
                     analysis.startDate,
                     analysis.endDate,
                     analysis.countriesAnalysis,
-                    dataElements.map(dataElement => dataElement.id)
+                    dataElements.map(dataElement => dataElement.id),
+                    analysis.module.id
                 ).flatMap(outliers => {
                     return this.issueUseCase
                         .getTotalIssuesBySection(analysis, options.sectionId)
@@ -75,7 +76,8 @@ export class RunOutlierUseCase {
         startDate: string,
         endDate: string,
         countryIds: Id[],
-        dataElements: Id[]
+        dataElements: Id[],
+        moduleId: Id
     ): FutureData<Outlier[]> {
         const $requests = _(dataElements)
             .chunk(100)
@@ -85,7 +87,7 @@ export class RunOutlierUseCase {
                     countryIds: countryIds,
                     endDate: endDate,
                     startDate: startDate,
-                    moduleId: undefined,
+                    moduleId: moduleId,
                     threshold: options.threshold,
                     dataElementIds: dataElementsIds,
                 });