support sort fields & some refactoring

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

@@ -9,7 +9,6 @@ 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'
 
@@ -434,8 +433,7 @@ export class DocumentListViewService {
 
   constructor(
     private documentService: DocumentService,
-    private settings: SettingsService,
-    private queryParamsService: QueryParamsService
+    private settings: SettingsService
   ) {
     let documentListViewConfigJson = localStorage.getItem(
       DOCUMENT_LIST_SERVICE.CURRENT_VIEW_CONFIG

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

@@ -1,101 +1,138 @@
 import { Injectable } from '@angular/core'
-import {
-  ActivatedRoute,
-  convertToParamMap,
-  ParamMap,
-  Params,
-  Router,
-} from '@angular/router'
+import { ParamMap, Params, Router } from '@angular/router'
 import { FilterRule } from '../data/filter-rule'
 import { FILTER_RULE_TYPES } from '../data/filter-rule-type'
+import { DocumentListViewService } from './document-list-view.service'
+
+const SORT_FIELD_PARAMETER = 'sort'
+const SORT_REVERSE_PARAMETER = 'reverse'
 
 @Injectable({
   providedIn: 'root',
 })
 export class QueryParamsService {
-  constructor(private router: Router, private route: ActivatedRoute) {}
+  constructor(private router: Router, private list: DocumentListViewService) {}
 
-  private filterParams: Params
-  private _filterRules: FilterRule[]
+  private filterParams: Params = {}
+  private sortParams: Params = {}
 
-  set filterRules(filterRules: FilterRule[]) {
-    this._filterRules = filterRules
-    this.filterParams = this.filterRulesToQueryParams(filterRules)
+  updateFilterRules(
+    filterRules: FilterRule[],
+    updateQueryParams: boolean = true
+  ) {
+    this.filterParams = filterRulesToQueryParams(filterRules)
+    if (updateQueryParams) this.updateQueryParams()
   }
 
-  get filterRules(): FilterRule[] {
-    return this._filterRules
+  set sortField(field: string) {
+    this.sortParams[SORT_FIELD_PARAMETER] = field
+    this.updateQueryParams()
   }
 
-  set params(params: any) {
-    this.filterParams = params
-    this._filterRules = this.filterRulesFromQueryParams(
-      params.keys ? params : convertToParamMap(params) // ParamMap
-    )
+  set sortReverse(reverse: boolean) {
+    if (!reverse) this.sortParams[SORT_REVERSE_PARAMETER] = undefined
+    else this.sortParams[SORT_REVERSE_PARAMETER] = reverse
+    this.updateQueryParams()
   }
 
   get params(): Params {
     return {
+      ...this.sortParams,
       ...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 updateQueryParams() {
+    // if we were on a saved view we navigate 'away' to /documents
+    let base = []
+    if (this.router.routerState.snapshot.url.includes('/view/'))
+      base = ['/documents']
+
+    this.router.navigate(base, {
+      queryParams: this.params,
+    })
+  }
+
+  public parseQueryParams(queryParams: ParamMap) {
+    let filterRules = filterRulesFromQueryParams(queryParams)
+    if (
+      filterRules.length ||
+      queryParams.has(SORT_FIELD_PARAMETER) ||
+      queryParams.has(SORT_REVERSE_PARAMETER)
+    ) {
+      this.list.filterRules = filterRules
+      this.list.sortField = queryParams.get(SORT_FIELD_PARAMETER)
+      this.list.sortReverse =
+        queryParams.has(SORT_REVERSE_PARAMETER) ||
+        (!queryParams.has(SORT_FIELD_PARAMETER) &&
+          !queryParams.has(SORT_REVERSE_PARAMETER))
+      this.list.reload()
+    } else if (
+      filterRules.length == 0 &&
+      !queryParams.has(SORT_FIELD_PARAMETER)
+    ) {
+      // this is navigating to /documents so we need to update the params from the list
+      this.updateFilterRules(this.list.filterRules, false)
+      this.sortField = this.list.sortField
+      this.sortReverse = this.list.sortReverse
     }
   }
 
-  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
+  navigateWithFilterRules(filterRules: FilterRule[]) {
+    this.updateFilterRules(filterRules)
     this.router.navigate(['/documents'], {
-      relativeTo: this.route,
       queryParams: this.params,
     })
   }
 }
+
+export function 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
+  }
+}
+
+export function 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
+}

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

@@ -10,9 +10,8 @@ import { map } from 'rxjs/operators'
 import { CorrespondentService } from './correspondent.service'
 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'
+import { filterRulesToQueryParams } from '../query-params.service'
 
 export const DOCUMENT_SORT_FIELDS = [
   { field: 'archive_serial_number', name: $localize`ASN` },
@@ -53,8 +52,7 @@ export class DocumentService extends AbstractPaperlessService<PaperlessDocument>
     http: HttpClient,
     private correspondentService: CorrespondentService,
     private documentTypeService: DocumentTypeService,
-    private tagService: TagService,
-    private queryParamsService: QueryParamsService
+    private tagService: TagService
   ) {
     super(http, 'documents')
   }
@@ -82,13 +80,12 @@ 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.queryParamsService.params)
+      Object.assign(extraParams, filterRulesToQueryParams(filterRules))
     ).pipe(
       map((results) => {
         results.results.forEach((doc) => this.addObservablesToDocument(doc))