Feature/responses operator (#4352)

frontend/v1/domain/entities/common/Filter.ts

@@ -9,6 +9,11 @@ export interface RangeValue {
   le?: number;
 }
 
+export type ValuesOption = {
+  values: string[];
+  operator?: "and" | "or";
+};
+
 export abstract class Filter {
   abstract get name(): string;
 

frontend/v1/domain/entities/response/ResponseCriteria.test.ts

@@ -88,4 +88,34 @@ describe("ResponseCriteria", () => {
       },
     ]);
   });
+
+  test("should be able to parse url params for options with operator", () => {
+    const criteria = new ResponseCriteria();
+    criteria.complete("multi-label.operator.or.values.label2.label3.label4");
+
+    expect(criteria.value).toEqual([
+      {
+        name: "multi-label",
+        value: {
+          operator: "or",
+          values: ["label2", "label3", "label4"],
+        },
+      },
+    ]);
+  });
+
+  test("should be able to parse url params for options with operator", () => {
+    const criteria = new ResponseCriteria();
+    criteria.complete("multi-label.operator.and.values.label2.label3.label4");
+
+    expect(criteria.value).toEqual([
+      {
+        name: "multi-label",
+        value: {
+          operator: "and",
+          values: ["label2", "label3", "label4"],
+        },
+      },
+    ]);
+  });
 });

frontend/v1/domain/entities/response/ResponseCriteria.ts

@@ -1,5 +1,5 @@
 import { Criteria } from "../common/Criteria";
-import { RangeValue } from "../common/Filter";
+import { RangeValue, ValuesOption } from "../common/Filter";
 import { ResponseSearch } from "./ResponseFilter";
 
 export class ResponseCriteria extends Criteria {
@@ -9,7 +9,7 @@ export class ResponseCriteria extends Criteria {
     if (!urlParams) return;
 
     urlParams.split("~").forEach((response) => {
-      const [name] = response.split(".");
+      const [name, ...rest] = response.split(".");
 
       const score = this.getRangeValue(response);
 
@@ -21,14 +21,31 @@ export class ResponseCriteria extends Criteria {
             le: score.le,
           },
         });
-      } else {
-        const values = response.split(".").slice(1);
+
+        return;
+      }
+
+      if (rest[0] === "operator" && rest[2] === "values") {
+        const operator = rest[1];
+        const values = rest.slice(3);
 
         this.value.push({
           name,
-          value: values,
+          value: {
+            operator: operator as ValuesOption["operator"],
+            values,
+          },
         });
+
+        return;
       }
+
+      const values = response.split(".").slice(1);
+
+      this.value.push({
+        name,
+        value: values,
+      });
     });
   }
 
@@ -60,10 +77,65 @@ export class ResponseCriteria extends Criteria {
           return `${response.name}.ge${rangeValue.ge}.le${rangeValue.le}`;
         }
 
+        const valuesOption = response.value as ValuesOption;
+
+        if ("operator" in valuesOption && valuesOption) {
+          return `${response.name}.operator.${
+            valuesOption.operator
+          }.values.${valuesOption.values.join(".")}`;
+        }
+
         const values = response.value as string[];
 
-        return `${response.name}.${values.map((v) => v).join(".")}`;
+        return `${response.name}.${values.join(".")}`;
       })
       .join("~");
   }
+
+  get or() {
+    if (!this.isCompleted) return [];
+
+    const orResponses = this.value.filter((s) => {
+      const { operator } = s.value as ValuesOption;
+
+      return operator !== "and";
+    });
+
+    return orResponses.map((r) => {
+      const { operator, values } = r.value as ValuesOption;
+
+      if (operator) {
+        return {
+          name: r.name,
+          value: values,
+        };
+      }
+
+      return {
+        name: r.name,
+        value: r.value,
+      };
+    });
+  }
+
+  get and() {
+    if (!this.isCompleted) return [];
+
+    const andResponses = this.value.filter((s) => {
+      const { operator } = s.value as ValuesOption;
+
+      return operator === "and";
+    });
+
+    return andResponses.flatMap((s) => {
+      const value = s.value as ValuesOption;
+
+      return value.values.map((value) => {
+        return {
+          name: s.name,
+          value,
+        };
+      });
+    });
+  }
 }

frontend/v1/domain/entities/response/ResponseFilter.ts

@@ -4,31 +4,80 @@ import {
   FilterWithScore,
   OptionForFilter,
   RangeValue,
+  ValuesOption,
 } from "../common/Filter";
 import { Question } from "../question/Question";
 
 export interface ResponseSearch {
   name: string;
-  value: string[] | RangeValue;
+  value: string[] | RangeValue | ValuesOption;
+}
+
+class FilterWithOptionAndOperator {
+  public operator: "and" | "or" = "and";
+  public readonly options: FilterWithOption;
+
+  constructor(private readonly question: Question) {
+    this.options = new FilterWithOption(
+      question.name,
+      question.settings.options.map(({ value, text }) => {
+        return {
+          selected: false,
+          value: value.toString(),
+          text,
+        } as OptionForFilter;
+      })
+    );
+  }
+
+  get value(): string[] | ValuesOption {
+    if (this.question.isMultiLabelType)
+      return {
+        operator: this.operator,
+        values: this.options.value,
+      };
+
+    return this.options.value;
+  }
+
+  filterByText(text: string) {
+    return this.options.filterByText(text);
+  }
+
+  get selectedOptions(): OptionForFilter[] {
+    return this.options.selectedOptions;
+  }
+
+  complete(value: string[] | ValuesOption) {
+    if ("operator" in value) {
+      this.operator = value.operator;
+      this.options.complete(value.values);
+    } else {
+      this.options.complete(value as string[]);
+    }
+  }
+
+  clear() {
+    this.options.clear();
+  }
+
+  get hasOperator() {
+    return this.question.isMultiLabelType;
+  }
+
+  get isAnswered(): boolean {
+    return this.options.isAnswered;
+  }
 }
 
 class ResponseFilter extends Filter {
   public readonly rangeValue: FilterWithScore;
-  public readonly options: FilterWithOption;
+  public readonly options: FilterWithOptionAndOperator;
   constructor(private readonly question: Question) {
     super();
 
     if (this.isTerms) {
-      this.options = new FilterWithOption(
-        question.name,
-        question.settings.options.map(({ value, text }) => {
-          return {
-            selected: false,
-            value: value.toString(),
-            text,
-          } as OptionForFilter;
-        })
-      );
+      this.options = new FilterWithOptionAndOperator(question);
     } else {
       this.rangeValue = new FilterWithScore(
         question.name,
@@ -51,17 +100,17 @@ class ResponseFilter extends Filter {
     return this.question.name;
   }
 
-  get value(): unknown {
+  get value(): string[] | RangeValue | ValuesOption {
     if (this.isTerms) {
       return this.options.value;
     }
 
     return this.rangeValue.value;
   }
 
-  complete(value: unknown): void {
+  complete(value: string[] | RangeValue | ValuesOption): void {
     if (this.isTerms) {
-      this.options.complete(value as string[]);
+      this.options.complete(value as string[] | ValuesOption);
     } else {
       this.rangeValue.complete(value as RangeValue);
     }

frontend/v1/domain/entities/suggestion/SuggestionCriteria.ts

@@ -1,10 +1,5 @@
 import { Criteria } from "../common/Criteria";
-import { RangeValue } from "../common/Filter";
-
-export type ValuesOption = {
-  values: string[];
-  operator?: "and" | "or";
-};
+import { RangeValue, ValuesOption } from "../common/Filter";
 
 export interface ConfigurationSearch {
   name: "score" | "value" | "agent";

frontend/v1/domain/entities/suggestion/SuggestionFilter.ts

@@ -4,14 +4,11 @@ import {
   FilterWithScore,
   OptionForFilter,
   RangeValue,
+  ValuesOption,
 } from "../common/Filter";
 import { Question } from "../question/Question";
 import { Agent } from "./Agent";
-import {
-  ConfigurationSearch,
-  SuggestionSearch,
-  ValuesOption,
-} from "./SuggestionCriteria";
+import { ConfigurationSearch, SuggestionSearch } from "./SuggestionCriteria";
 
 class ConfigurationValues extends Filter {
   public readonly rangeValue: FilterWithScore;

frontend/v1/infrastructure/repositories/RecordRepository.ts

@@ -17,8 +17,7 @@ import { Question } from "@/v1/domain/entities/question/Question";
 import { RecordCriteria } from "@/v1/domain/entities/record/RecordCriteria";
 import { Pagination } from "@/v1/domain/entities/Pagination";
 import { SimilarityOrder } from "@/v1/domain/entities/similarity/SimilarityCriteria";
-import { RangeValue } from "~/v1/domain/entities/common/Filter";
-import { ValuesOption } from "~/v1/domain/entities/suggestion/SuggestionCriteria";
+import { RangeValue, ValuesOption } from "~/v1/domain/entities/common/Filter";
 
 const RECORD_API_ERRORS = {
   ERROR_FETCHING_RECORDS: "ERROR_FETCHING_RECORDS",
@@ -251,9 +250,8 @@ export class RecordRepository {
       }
 
       if (isFilteringByResponse) {
-        response.value.forEach((r) => {
+        response.or.forEach((r) => {
           const value = r.value as RangeValue;
-
           if ("ge" in value && "le" in value) {
             body.filters.and.push({
               type: "range",
@@ -264,10 +262,8 @@ export class RecordRepository {
               ge: value.ge,
               le: value.le,
             });
-
             return;
           }
-
           body.filters.and.push({
             type: "terms",
             scope: {
@@ -277,6 +273,17 @@ export class RecordRepository {
             values: r.value as string[],
           });
         });
+
+        response.and.forEach((r) => {
+          body.filters.and.push({
+            type: "terms",
+            scope: {
+              entity: "response",
+              question: r.name,
+            },
+            values: [r.value],
+          });
+        });
       }
 
       if (isFilteringBySuggestion) {