Change: Extract parsing a filter from a response element into new method

The former fromElement method of the Filter model did mix parsing of
different XML responses. First for the `<get_filters>` responses and
second for all filters included in all other get responses like
`<get_tasks>`.

Author: bjoernricks

src/gmp/models/__tests__/filter.test.ts

@@ -263,7 +263,7 @@ describe('Filter parse from string tests', () => {
   });
 });
 
-describe('Filter parse from keywords', () => {
+describe('Filter fromResponseElement', () => {
   test('should parse approx relation without column', () => {
     const elem = {
       keywords: {
@@ -276,7 +276,7 @@ describe('Filter parse from keywords', () => {
         ],
       },
     };
-    const filter = Filter.fromElement(elem);
+    const filter = Filter.fromResponseElement(elem);
     expect(filter.toFilterString()).toEqual('~abc');
   });
 
@@ -307,7 +307,7 @@ describe('Filter parse from keywords', () => {
         ],
       },
     };
-    let filter = Filter.fromElement(elem);
+    let filter = Filter.fromResponseElement(elem);
     expect(filter.toFilterString()).toEqual('~abc and not ~def');
 
     elem = {
@@ -351,7 +351,7 @@ describe('Filter parse from keywords', () => {
         ],
       },
     };
-    filter = Filter.fromElement(elem);
+    filter = Filter.fromResponseElement(elem);
     expect(filter.toFilterString()).toEqual(
       '~abc and not ~def rows=10 first=1 sort=name',
     );
@@ -395,7 +395,7 @@ describe('Filter parse from keywords', () => {
       },
     };
 
-    const filter = Filter.fromElement(elem);
+    const filter = Filter.fromResponseElement(elem);
     const filterString =
       'severity>3.9 and severity<7 first=1 rows=10 sort=name';
     expect(filter.toFilterString()).toEqual(filterString);
@@ -416,9 +416,20 @@ describe('Filter parse from keywords', () => {
         ],
       },
     };
-    const filter = Filter.fromElement(elem);
+    const filter = Filter.fromResponseElement(elem);
     expect(filter.toFilterString()).toEqual('_foo=abc');
   });
+
+  test('should parse id', () => {
+    const filter1 = Filter.fromResponseElement();
+    expect(filter1.id).toBeUndefined();
+
+    const filter2 = Filter.fromResponseElement({_id: '123'});
+    expect(filter2.id).toBe('123');
+
+    const filter3 = Filter.fromResponseElement({_id: UNKNOWN_FILTER_ID});
+    expect(filter3.id).toBeUndefined();
+  });
 });
 
 describe('Filter set', () => {
@@ -1613,6 +1624,7 @@ describe('should lower the case of capitalized keywords', () => {
       'severity>3.9 and qod_min=70 rows=14',
     );
   });
+
   test('should do the same for filters from arrays', () => {
     const element = {
       keywords: {
@@ -1655,15 +1667,17 @@ describe('should lower the case of capitalized keywords', () => {
         ],
       },
     };
-    const filter = Filter.fromElement(element);
+    const filter = Filter.fromResponseElement(element);
     expect(filter.toFilterString()).toEqual(
       '~abc and not ~def rows=10 first=1 sort=name',
     );
   });
+
   test('a more wacky scenario', () => {
     const filter1 = Filter.fromString('~abc SorT=name');
     expect(filter1.toFilterString()).toEqual('~abc sort=name');
   });
+
   test('just a value', () => {
     const filter2 = Filter.fromString('~AbC');
     expect(filter2.toFilterString()).toEqual('~AbC');

src/gmp/models/filter.ts

@@ -11,25 +11,81 @@ import Model, {type ModelElement, type ModelProperties} from 'gmp/models/model';
 import {parseInt} from 'gmp/parser';
 import {map} from 'gmp/utils/array';
 import {isDefined, isString, isArray, hasValue} from 'gmp/utils/identity';
+import {isEmpty} from 'gmp/utils/string';
 
 export interface FilterKeyword {
   column?: string;
   relation?: string;
   value?: string;
 }
 
+/**
+ * XML Structure of a filter model element as returned by `<get_filters>`
+ * queries.
+ *
+ * Example XML Structure:
+ * ```xml
+ * <get_filters_response status="200" status_text="OK">
+ *   <filter id="0c239c16-d597-48a1-9f51-347627a23dac">
+ *     ...
+ *     <term>apply_overrides=0 min_qod=70 sort=name first=1 rows=1</term>
+ *   </filter>
+ * </get_filters_response>
+ * ```
+ */
 export interface FilterModelElement extends ModelElement {
   alerts?: {
     alert: ModelElement[];
   };
   filter_type?: string;
-  keywords?: {
-    keyword?: FilterKeyword | FilterKeyword[];
-  };
   term?: string;
 }
 
+/**
+ * XML Structure of a filter response element
+ * as returned by all `<get_xyz>` queries, for example `<get_tasks>`.
+ *
+ * Example XML Structure:
+ * ```xml
+ * <get_tasks_response>
+ *   <task>
+ *     ...
+ *   </task>
+ *   <filters id="">
+ *     <term>apply_overrides=0 min_qod=70 sort=name first=1 rows=1</term>
+ *     <keywords>
+ *       <keyword>
+ *         <column>apply_overrides</column>
+ *         <relation>=</relation>
+ *         <value>0</value>
+ *       </keyword>
+ *       <keyword>
+ *         <column>min_qod</column>
+ *         <relation>=</relation>
+ *         <value>70</value>
+ *       </keyword>
+ *       <keyword>
+ *         <column>sort</column>
+ *         <relation>=</relation>
+ *         <value>name</value>
+ *       </keyword>
+ *       <keyword>
+ *         <column>first</column>
+ *         <relation>=</relation>
+ *         <value>1</value>
+ *       </keyword>
+ *       <keyword>
+ *         <column>rows</column>
+ *         <relation>=</relation>
+ *         <value>1</value>
+ *       </keyword>
+ *     </keywords>
+ *   </filters>
+ * </get_tasks_response>
+ * ```
+ */
 export interface FilterResponseElement {
+  _id?: string;
   keywords?: {
     keyword?: FilterKeyword | FilterKeyword[];
   };
@@ -201,15 +257,7 @@ class Filter extends EntityModel implements FilterType {
     if (ret.id === UNKNOWN_FILTER_ID) {
       ret.id = undefined;
     }
-    if (isDefined(element.keywords)) {
-      ret.terms = map(
-        element.keywords.keyword,
-        ({relation, value, column: key}: FilterKeyword) =>
-          new FilterTerm(convert(key, value, relation)),
-      );
-      // @ts-expect-error
-      delete ret.keywords;
-    } else if (isDefined(element.term)) {
+    if (isDefined(element.term)) {
       ret.terms = parseFilterTermsFromString(element.term);
 
       // ret.term should not be part of the public api
@@ -230,6 +278,26 @@ class Filter extends EntityModel implements FilterType {
     return new Filter(ret);
   }
 
+  static fromResponseElement(element: FilterResponseElement = {}): Filter {
+    const id =
+      !isEmpty(element._id) && element._id !== UNKNOWN_FILTER_ID
+        ? element._id
+        : undefined;
+
+    let terms: FilterTerm[] = [];
+    if (isDefined(element.keywords)) {
+      terms = map(
+        element.keywords.keyword,
+        ({relation, value, column: key}: FilterKeyword) =>
+          new FilterTerm(convert(key, value, relation)),
+      );
+    } else if (isDefined(element.term)) {
+      terms = parseFilterTermsFromString(element.term);
+    }
+
+    return new Filter({id, terms});
+  }
+
   /**
    * @private
    *