Refactor query param handling to service

src-ui/src/app/services/document-list-view.service.ts

@@ -1,5 +1,5 @@
 import { Injectable } from '@angular/core'
-import { ActivatedRoute, Router } from '@angular/router'
+import { ActivatedRoute, Params, Router } from '@angular/router'
 import { Observable } from 'rxjs'
 import {
   cloneFilterRules,
@@ -9,6 +9,7 @@ import {
 import { PaperlessDocument } from '../data/paperless-document'
 import { PaperlessSavedView } from '../data/paperless-saved-view'
 import { DOCUMENT_LIST_SERVICE } from '../data/storage-keys'
+import { QueryParamsService } from './query-params.service'
 import { DocumentService, DOCUMENT_SORT_FIELDS } from './rest/document.service'
 import { SettingsService, SETTINGS_KEYS } from './settings.service'
 
@@ -220,6 +221,13 @@ export class DocumentListViewService {
     return this.activeListViewState.sortReverse
   }
 
+  get sortParams(): Params {
+    return {
+      sortField: this.sortField,
+      sortReverse: this.sortReverse,
+    }
+  }
+
   get collectionSize(): number {
     return this.activeListViewState.collectionSize
   }
@@ -265,14 +273,6 @@ export class DocumentListViewService {
     }
   }
 
-  quickFilter(filterRules: FilterRule[]) {
-    const params = this.documentService.filterRulesToQueryParams(filterRules)
-    this.router.navigate(['/documents'], {
-      relativeTo: this.route,
-      queryParams: params,
-    })
-  }
-
   getLastPage(): number {
     return Math.ceil(this.collectionSize / this.currentPageSize)
   }
@@ -435,8 +435,7 @@ export class DocumentListViewService {
   constructor(
     private documentService: DocumentService,
     private settings: SettingsService,
-    private router: Router,
-    private route: ActivatedRoute
+    private queryParamsService: QueryParamsService
   ) {
     let documentListViewConfigJson = localStorage.getItem(
       DOCUMENT_LIST_SERVICE.CURRENT_VIEW_CONFIG

src-ui/src/app/services/query-params.service.ts

@@ -0,0 +1,101 @@
+import { Injectable } from '@angular/core'
+import {
+  ActivatedRoute,
+  convertToParamMap,
+  ParamMap,
+  Params,
+  Router,
+} from '@angular/router'
+import { FilterRule } from '../data/filter-rule'
+import { FILTER_RULE_TYPES } from '../data/filter-rule-type'
+
+@Injectable({
+  providedIn: 'root',
+})
+export class QueryParamsService {
+  constructor(private router: Router, private route: ActivatedRoute) {}
+
+  private filterParams: Params
+  private _filterRules: FilterRule[]
+
+  set filterRules(filterRules: FilterRule[]) {
+    this._filterRules = filterRules
+    this.filterParams = this.filterRulesToQueryParams(filterRules)
+  }
+
+  get filterRules(): FilterRule[] {
+    return this._filterRules
+  }
+
+  set params(params: any) {
+    this.filterParams = params
+    this._filterRules = this.filterRulesFromQueryParams(
+      params.keys ? params : convertToParamMap(params) // ParamMap
+    )
+  }
+
+  get params(): Params {
+    return {
+      ...this.filterParams,
+    }
+  }
+
+  private filterRulesToQueryParams(filterRules: FilterRule[]): Object {
+    if (filterRules) {
+      let params = {}
+      for (let rule of filterRules) {
+        let ruleType = FILTER_RULE_TYPES.find((t) => t.id == rule.rule_type)
+        if (ruleType.multi) {
+          params[ruleType.filtervar] = params[ruleType.filtervar]
+            ? params[ruleType.filtervar] + ',' + rule.value
+            : rule.value
+        } else if (ruleType.isnull_filtervar && rule.value == null) {
+          params[ruleType.isnull_filtervar] = true
+        } else {
+          params[ruleType.filtervar] = rule.value
+        }
+      }
+      return params
+    } else {
+      return null
+    }
+  }
+
+  private filterRulesFromQueryParams(queryParams: ParamMap) {
+    const allFilterRuleQueryParams: string[] = FILTER_RULE_TYPES.map(
+      (rt) => rt.filtervar
+    )
+
+    // transform query params to filter rules
+    let filterRulesFromQueryParams: FilterRule[] = []
+    allFilterRuleQueryParams
+      .filter((frqp) => queryParams.has(frqp))
+      .forEach((filterQueryParamName) => {
+        const filterQueryParamValues: string[] = queryParams
+          .get(filterQueryParamName)
+          .split(',')
+
+        filterRulesFromQueryParams = filterRulesFromQueryParams.concat(
+          // map all values to filter rules
+          filterQueryParamValues.map((val) => {
+            return {
+              rule_type: FILTER_RULE_TYPES.find(
+                (rt) => rt.filtervar == filterQueryParamName
+              ).id,
+              value: val,
+            }
+          })
+        )
+      })
+
+    return filterRulesFromQueryParams
+  }
+
+  loadFilterRules(filterRules: FilterRule[]) {
+    this.filterRules = filterRules
+    this.router.navigate(['/documents'], {
+      relativeTo: this.route,
+      queryParams: this.params,
+    })
+  }
+}

src-ui/src/app/services/rest/document.service.ts

@@ -12,6 +12,7 @@ import { DocumentTypeService } from './document-type.service'
 import { TagService } from './tag.service'
 import { FILTER_RULE_TYPES } from 'src/app/data/filter-rule-type'
 import { PaperlessDocumentSuggestions } from 'src/app/data/paperless-document-suggestions'
+import { QueryParamsService } from '../query-params.service'
 
 export const DOCUMENT_SORT_FIELDS = [
   { field: 'archive_serial_number', name: $localize`ASN` },
@@ -52,32 +53,12 @@ export class DocumentService extends AbstractPaperlessService<PaperlessDocument>
     http: HttpClient,
     private correspondentService: CorrespondentService,
     private documentTypeService: DocumentTypeService,
-    private tagService: TagService
+    private tagService: TagService,
+    private queryParamsService: QueryParamsService
   ) {
     super(http, 'documents')
   }
 
-  public filterRulesToQueryParams(filterRules: FilterRule[]): Object {
-    if (filterRules) {
-      let params = {}
-      for (let rule of filterRules) {
-        let ruleType = FILTER_RULE_TYPES.find((t) => t.id == rule.rule_type)
-        if (ruleType.multi) {
-          params[ruleType.filtervar] = params[ruleType.filtervar]
-            ? params[ruleType.filtervar] + ',' + rule.value
-            : rule.value
-        } else if (ruleType.isnull_filtervar && rule.value == null) {
-          params[ruleType.isnull_filtervar] = true
-        } else {
-          params[ruleType.filtervar] = rule.value
-        }
-      }
-      return params
-    } else {
-      return null
-    }
-  }
-
   addObservablesToDocument(doc: PaperlessDocument) {
     if (doc.correspondent) {
       doc.correspondent$ = this.correspondentService.getCached(
@@ -101,12 +82,13 @@ export class DocumentService extends AbstractPaperlessService<PaperlessDocument>
     filterRules?: FilterRule[],
     extraParams = {}
   ): Observable<Results<PaperlessDocument>> {
+    this.queryParamsService.filterRules = filterRules
     return this.list(
       page,
       pageSize,
       sortField,
       sortReverse,
-      Object.assign(extraParams, this.filterRulesToQueryParams(filterRules))
+      Object.assign(extraParams, this.queryParamsService.params)
     ).pipe(
       map((results) => {
         results.results.forEach((doc) => this.addObservablesToDocument(doc))