feat: improve search experience

Closes #230

backend/backend/config/b-tu/elasticsearchrc.js

@@ -8,8 +8,7 @@ const config = {
     database: {
       name: 'elasticsearch',
       query: {
-        minMatch: '60%',
+        fields: ["name"]
-        queryType: 'query_string',
       },
     },
   },

backend/backend/config/default/backend/boostings.js

@@ -39,7 +39,7 @@ const boostings = {
       type: SCThingType.AcademicEvent,
     },
     {
-      factor: 1.6,
+      factor: 2,
       type: SCThingType.Building,
     },
     {
@@ -85,7 +85,7 @@ const boostings = {
   ],
   place: [
     {
-      factor: 2,
+      factor: 3,
       type: SCThingType.Building,
     },
     {

backend/backend/config/default/elasticsearchrc.js

@@ -17,12 +17,21 @@ const config = {
       name: 'elasticsearch',
       version: '8.4.2',
       query: {
-        minMatch: '75%',
+        type: 'best_fields',
-        queryType: 'dis_max',
+        fields: [
-        matchBoosting: 1.3,
+          'identifiers^20',
-        fuzziness: 'AUTO',
+          'name^10',
-        cutoffFrequency: 0,
+          'translations.*.name^10',
-        tieBreaker: 0,
+          'alternateNames^10',
+          'translations.*.alternateNames^10',
+          'description^2',
+          'translations.*.description^2',
+          'categories^5',
+        ],
+      },
+      searchAsYouTypeQuery: {
+        type: 'phrase_prefix',
+        fields: ['name.completion', 'name.completion._2gram', 'name.completion._3gram'],
       },
     },
   },

backend/backend/src/storage/elasticsearch/elasticsearch.ts

@@ -20,6 +20,8 @@ import {
   IndicesGetAliasResponse,
   SearchHit,
   SearchResponse,
+  SearchTermSuggest,
+  SearchTermSuggestOption,
 } from '@elastic/elasticsearch/lib/api/types.js';
 import {SCConfigFile, SCSearchQuery, SCSearchResponse, SCThings, SCUuid} from '@openstapps/core';
 import {Logger} from '@openstapps/logger';
@@ -47,6 +49,9 @@ import {
 import {noUndefined} from './util/no-undefined.js';
 import {retryCatch, RetryOptions} from './util/retry.js';
 import {Feature, Point, Polygon} from 'geojson';
+import {parseSuggestions} from './util/parse-suggestions.js';
+import {buildScoringFunctions} from './query/boost/scoring-functions.js';
+import {buildFilter} from './query/filter.js';
 
 /**
  * A database interface for elasticsearch
@@ -355,6 +360,39 @@ export class Elasticsearch implements Database {
     throw new Error('You tried to PUT an non-existing object. PUT is only supported on existing objects.');
   }
 
+  public async searchAsYouType(parameters: SCSearchQuery): Promise<SCSearchResponse> {
+    const result = await this.client.search({
+      _source: 'name',
+      query: {
+        function_score: {
+          functions: buildScoringFunctions(this.config.internal.boostings, parameters.context),
+          query: {
+            bool: {
+              must: {
+                multi_match: {
+                  query: parameters.query,
+                  type: 'bool_prefix',
+                  fields: ['name.completion', 'name.completion._2gram', 'name.completion._3gram'],
+                },
+              },
+              should: [],
+              filter: parameters.filter === undefined ? undefined : buildFilter(parameters.filter),
+            },
+          },
+          score_mode: 'max',
+          boost_mode: 'multiply',
+        },
+      },
+      index: ACTIVE_INDICES_ALIAS,
+      allow_no_indices: true,
+      size: 5,
+    });
+
+    const suggestions = result.hits.hits.map(it => (it._source as any).name);
+    console.log(suggestions);
+    console.log(result.took);
+  }
+
   /**
    * Search all indexed data
    * @param parameters search query
@@ -364,18 +402,23 @@ export class Elasticsearch implements Database {
       throw new TypeError('Database is undefined. You have to configure the query build');
     }
 
-    const esConfig: ElasticsearchConfig = {
+    const esConfig = this.config.internal.database as object as ElasticsearchConfig;
-      name: this.config.internal.database.name as 'elasticsearch',
-      version: this.config.internal.database.version as string,
-      query: this.config.internal.database.query as
-        | ElasticsearchQueryDisMaxConfig
-        | ElasticsearchQueryQueryStringConfig
-        | undefined,
-    };
 
     const response: SearchResponse<SCThings> = await this.client.search({
       aggs: aggregations,
       query: buildQuery(parameters, this.config, esConfig),
+      suggest:
+        parameters.query === undefined
+          ? undefined
+          : {
+              text: parameters.query,
+              terms: {
+                term: {
+                  field: 'name',
+                  suggest_mode: 'missing',
+                },
+              },
+            },
       from: parameters.from,
       index: ACTIVE_INDICES_ALIAS,
       allow_no_indices: true,
@@ -395,6 +438,7 @@ export class Elasticsearch implements Database {
         response.aggregations === undefined
           ? []
           : parseAggregations(response.aggregations as Record<AggregateName, AggregationsMultiTermsBucket>),
+      suggestions: response.suggest === undefined ? undefined : parseSuggestions(response.suggest),
       pagination: {
         count: response.hits.hits.length,
         offset: typeof parameters.from === 'number' ? parameters.from : 0,

backend/backend/src/storage/elasticsearch/query/query.ts

@@ -30,84 +30,21 @@ export const buildQuery = function buildQuery(
   defaultConfig: SCConfigFile,
   elasticsearchConfig: ElasticsearchConfig,
 ): QueryDslQueryContainer {
-  // if config provides a minMatch parameter, we use query_string instead of a match query
+  return {
-  let query;
-  if (elasticsearchConfig.query === undefined) {
-    query = {
-      query_string: {
-        analyzer: 'search_german',
-        default_field: 'name',
-        minimum_should_match: '90%',
-        query: typeof parameters.query === 'string' ? parameters.query : '*',
-      },
-    };
-  } else if (elasticsearchConfig.query.queryType === 'query_string') {
-    query = {
-      query_string: {
-        analyzer: 'search_german',
-        default_field: 'name',
-        minimum_should_match: elasticsearchConfig.query.minMatch,
-        query: typeof parameters.query === 'string' ? parameters.query : '*',
-      },
-    };
-  } else if (elasticsearchConfig.query.queryType === 'dis_max') {
-    if (typeof parameters.query === 'string' && parameters.query !== '*') {
-      query = {
-        dis_max: {
-          boost: 1.2,
-          queries: [
-            {
-              match: {
-                name: {
-                  boost: elasticsearchConfig.query.matchBoosting,
-                  fuzziness: elasticsearchConfig.query.fuzziness,
-                  query: parameters.query,
-                },
-              },
-            },
-            {
-              query_string: {
-                default_field: 'name',
-                minimum_should_match: elasticsearchConfig.query.minMatch,
-                query: parameters.query,
-              },
-            },
-          ],
-          tie_breaker: elasticsearchConfig.query.tieBreaker,
-        },
-      };
-    }
-  } else {
-    throw new Error(
-      'Unsupported query type. Check your config file and reconfigure your elasticsearch query',
-    );
-  }
-
-  const functionScoreQuery: QueryDslQueryContainer = {
     function_score: {
       functions: buildScoringFunctions(defaultConfig.internal.boostings, parameters.context),
       query: {
         bool: {
-          minimum_should_match: 0, // if we have no should, nothing can match
+          must:
-          must: [],
+            parameters.query === undefined || parameters.query === '' || parameters.query === '*'
+              ? {match_all: {}}
+              : {multi_match: {...elasticsearchConfig.query, query: parameters.query}},
           should: [],
+          filter: parameters.filter === undefined ? undefined : buildFilter(parameters.filter),
         },
       },
-      score_mode: 'multiply',
+      score_mode: 'max',
+      boost_mode: 'multiply',
     },
   };
-
-  const mustMatch = functionScoreQuery.function_score?.query?.bool?.must;
-
-  if (Array.isArray(mustMatch)) {
-    if (query !== undefined) {
-      mustMatch.push(query);
-    }
-
-    if (parameters.filter !== undefined) {
-      mustMatch.push(buildFilter(parameters.filter));
-    }
-  }
-
-  return functionScoreQuery;
 };

backend/backend/src/storage/elasticsearch/types/elasticsearch-config.ts

@@ -13,68 +13,7 @@
  * this program. If not, see <https://www.gnu.org/licenses/>.
  */
 
-/**
+import {QueryDslMultiMatchQuery} from '@elastic/elasticsearch/lib/api/types.js';
- * A configuration for using the Dis Max Query
- *
- * See https://www.elastic.co/guide/en/elasticsearch/reference/5.5/query-dsl-dis-max-query.html for further
- * explanation of what the parameters mean
- */
-export interface ElasticsearchQueryDisMaxConfig {
-  /**
-   * Relative (to a total number of documents) or absolute number to exclude meaningless matches that frequently appear
-   */
-  cutoffFrequency: number;
-
-  /**
-   * The maximum allowed Levenshtein Edit Distance (or number of edits)
-   * @see https://www.elastic.co/guide/en/elasticsearch/reference/5.6/common-options.html#fuzziness
-   */
-  fuzziness: number | string;
-
-  /**
-   * Increase the importance (relevance score) of a field
-   * @see https://www.elastic.co/guide/en/elasticsearch/reference/5.6/mapping-boost.html
-   */
-  matchBoosting: number;
-
-  /**
-   * Minimal number (or percentage) of words that should match in a query
-   * @see https://www.elastic.co/guide/en/elasticsearch/reference/5.6/query-dsl-minimum-should-match.html
-   */
-  minMatch: string;
-
-  /**
-   * Type of the query - in this case 'dis_max' which is a union of its subqueries
-   * @see https://www.elastic.co/guide/en/elasticsearch/reference/5.6/query-dsl-dis-max-query.html
-   */
-  queryType: 'dis_max';
-
-  /**
-   * Changes behavior of default calculation of the score when multiple results match
-   * @see https://www.elastic.co/guide/en/elasticsearch/reference/5.6/query-dsl-multi-match-query.html#tie-breaker
-   */
-  tieBreaker: number;
-}
-
-/**
- * A configuration for using Query String Query
- *
- * See https://www.elastic.co/guide/en/elasticsearch/reference/5.5/query-dsl-query-string-query.html for further
- * explanation of what the parameters mean
- */
-export interface ElasticsearchQueryQueryStringConfig {
-  /**
-   * Minimal number (or percentage) of words that should match in a query
-   * @see https://www.elastic.co/guide/en/elasticsearch/reference/5.6/query-dsl-minimum-should-match.html
-   */
-  minMatch: string;
-
-  /**
-   * Type of the query - in this case 'query_string' which uses a query parser in order to parse content
-   * @see https://www.elastic.co/guide/en/elasticsearch/reference/5.6/query-dsl-query-string-query.html
-   */
-  queryType: 'query_string';
-}
 
 /**
  * An config file for the elasticsearch database interface
@@ -105,7 +44,12 @@ export interface ElasticsearchConfig {
   /**
    * Configuration for using queries
    */
-  query?: ElasticsearchQueryDisMaxConfig | ElasticsearchQueryQueryStringConfig;
+  query: Omit<QueryDslMultiMatchQuery, 'query'>;
+
+  /**
+   *
+   */
+  searchAsYouTypeQuery: Omit<QueryDslMultiMatchQuery, 'query'>;
 
   /**
    * Version of the used elasticsearch

backend/backend/src/storage/elasticsearch/util/parse-suggestions.ts

@@ -0,0 +1,28 @@
+import {
+  SearchSuggest,
+  SearchTermSuggest,
+  SearchTermSuggestOption,
+  SuggestionName,
+} from '@elastic/elasticsearch/lib/api/types.js';
+import {SCSearchSuggestions} from '@openstapps/core';
+
+/**
+ * Parse ES Suggestions to SC Search Suggestions
+ */
+export function parseSuggestions(suggest: Record<SuggestionName, SearchSuggest[]>): SCSearchSuggestions {
+  const termsSuggestions =
+    suggest.terms === undefined
+      ? []
+      : (suggest.terms as SearchTermSuggest[])
+          ?.map(
+            ({text, options}) =>
+              [
+                text,
+                (options as SearchTermSuggestOption[] | undefined)?.map(({text}) => text) ?? [],
+              ] as const,
+          )
+          .filter(([, suggestions]) => suggestions.length > 0) ?? [];
+  return {
+    terms: termsSuggestions.length === 0 ? undefined : Object.fromEntries(termsSuggestions),
+  };
+}

frontend/app/src/app/modules/auth/auth.service.ts

@@ -86,6 +86,8 @@ export abstract class AuthService implements IAuthService {
 
   private _authenticatedSubject = new BehaviorSubject<boolean>(false);
 
+  private _loggedInSubject = new BehaviorSubject<boolean>(false);
+
   private _initComplete = new BehaviorSubject<boolean>(false);
 
   protected tokenHandler: TokenRequestHandler;
@@ -133,6 +135,13 @@ export abstract class AuthService implements IAuthService {
     return this._authenticatedSubject.asObservable();
   }
 
+  /**
+   * Similar to isAuthenticated$, but will also return true if the token is expired
+   */
+  get isLoggedIn$(): Observable<boolean> {
+    return this._loggedInSubject.asObservable();
+  }
+
   get initComplete$(): Observable<boolean> {
     return this._initComplete.asObservable();
   }
@@ -183,19 +192,20 @@ export abstract class AuthService implements IAuthService {
   protected notifyActionListers(action: IAuthAction) {
     /* eslint-disable unicorn/no-useless-undefined */
     switch (action.action) {
-      case AuthActions.RefreshFailed:
       case AuthActions.SignInFailed:
       case AuthActions.SignOutSuccess:
       case AuthActions.SignOutFailed: {
         this._tokenSubject.next(undefined);
         this._userSubject.next(undefined);
         this._authenticatedSubject.next(false);
+        this._loggedInSubject.next(false);
         break;
       }
       case AuthActions.LoadTokenFromStorageFailed: {
         this._tokenSubject.next(undefined);
         this._userSubject.next(undefined);
         this._authenticatedSubject.next(false);
+        this._loggedInSubject.next(false);
         this._initComplete.next(true);
         break;
       }
@@ -203,11 +213,13 @@ export abstract class AuthService implements IAuthService {
       case AuthActions.RefreshSuccess: {
         this._tokenSubject.next(action.tokenResponse);
         this._authenticatedSubject.next(true);
+        this._loggedInSubject.next(true);
         break;
       }
       case AuthActions.LoadTokenFromStorageSuccess: {
         this._tokenSubject.next(action.tokenResponse);
         this._authenticatedSubject.next((action.tokenResponse as TokenResponse).isValid(0));
+        this._loggedInSubject.next(true);
         this._initComplete.next(true);
         break;
       }
@@ -442,7 +454,6 @@ export abstract class AuthService implements IAuthService {
 
   public async refreshToken() {
     await this.requestTokenRefresh().catch(error => {
-      this.storage.removeItem(TOKEN_RESPONSE_KEY);
       this.notifyActionListers(AuthActionBuilder.RefreshFailed(error));
     });
   }

frontend/app/src/app/modules/auth/paia/paia-auth.service.ts

@@ -81,6 +81,8 @@ export class PAIAAuthService {
 
   private _authenticatedSubject = new BehaviorSubject<boolean>(false);
 
+  private _loggedIn = new BehaviorSubject<boolean>(false);
+
   private _initComplete = new BehaviorSubject<boolean>(false);
 
   protected tokenHandler: PAIATokenRequestHandler;
@@ -118,6 +120,13 @@ export class PAIAAuthService {
     return this._authenticatedSubject.asObservable();
   }
 
+  /**
+   * Similar to isAuthenticated$, but will also return true if the token is expired
+   */
+  get isLoggedIn$(): Observable<boolean> {
+    return this._loggedIn.asObservable();
+  }
+
   get initComplete$(): Observable<boolean> {
     return this._initComplete.asObservable();
   }
@@ -170,23 +179,27 @@ export class PAIAAuthService {
         this._tokenSubject.next(undefined);
         this._userSubject.next(undefined);
         this._authenticatedSubject.next(false);
+        this._loggedIn.next(false);
         break;
       }
       case AuthActions.LoadTokenFromStorageFailed: {
         this._tokenSubject.next(undefined);
         this._userSubject.next(undefined);
         this._authenticatedSubject.next(false);
+        this._loggedIn.next(false);
         this._initComplete.next(true);
         break;
       }
       case AuthActions.SignInSuccess: {
         this._tokenSubject.next(action.tokenResponse);
         this._authenticatedSubject.next(true);
+        this._loggedIn.next(true);
         break;
       }
       case AuthActions.LoadTokenFromStorageSuccess: {
         this._tokenSubject.next(action.tokenResponse);
         this._authenticatedSubject.next((action.tokenResponse as TokenResponse).isValid(0));
+        this._loggedIn.next(true);
         this._initComplete.next(true);
         break;
       }

frontend/app/src/app/modules/data/list/search-page.component.ts

@@ -24,6 +24,7 @@ import {
   SCSearchQuery,
   SCSearchSort,
   SCThings,
+  SCSearchSuggestions,
 } from '@openstapps/core';
 import {NGXLogger} from 'ngx-logger';
 import {combineLatest, Subject} from 'rxjs';
@@ -110,6 +111,8 @@ export class SearchPageComponent implements OnInit {
    */
   items: Promise<SCThings[]>;
 
+  suggestions: SCSearchSuggestions | undefined;
+
   /**
    * Page size of queries
    */
@@ -219,6 +222,7 @@ export class SearchPageComponent implements OnInit {
 
     try {
       const result = await this.dataProvider.search(searchOptions);
+      this.suggestions = result.suggestions;
       this.singleTypeResponse = result.facets.find(facet => facet.field === 'type')?.buckets.length === 1;
       if (append) {
         // append results
@@ -283,6 +287,12 @@ export class SearchPageComponent implements OnInit {
     this.contextMenuService.updateContextFilter(facets);
   }
 
+  applySuggestion(target: string, suggestion: string) {
+    this.queryText = this.queryText.replaceAll(target, suggestion);
+    this.suggestions = undefined;
+    this.searchStringChanged(this.queryText);
+  }
+
   ngOnInit(defaultListeners = true) {
     this.initialize();
     this.contextMenuService.setContextSort({

frontend/app/src/app/modules/data/list/search-page.html

@@ -69,7 +69,23 @@
 </ion-header>
 
 <ion-content class="content">
+  <div class="suggestions">
+    @if (suggestions?.terms; as terms) {
+      <span>{{ 'search.SUGGESTIONS' | translate }}: </span>
+      @for (suggestion of terms | keyvalue; track suggestion) {
+        @for (term of suggestion.value; track term) {
+          @if ($index == 0) {
+            <b (click)="applySuggestion(suggestion.key, term)" class="suggestion">{{ term }}</b>
+          } @else {
+            <span (click)="applySuggestion(suggestion.key, term)" class="suggestion">{{ term }}</span>
+          }
+        }
+      }
+    }
+  </div>
+
   <div
+    class="hint"
     [class.no-results]="!showDefaultData && !items && !loading"
     [style.display]="!showDefaultData && !items && !loading ? 'block' : 'none'"
   >

frontend/app/src/app/modules/data/list/search-page.scss

@@ -46,7 +46,7 @@ ion-content {
   --background: var(--ion-background-color);
 }
 
-.content > div {
+.content > .hint {
   height: 100%;
 
   ion-label.centered-message-container {
@@ -60,3 +60,19 @@ ion-content {
 ion-header {
   background: var(--ion-color-primary);
 }
+
+.suggestions {
+  padding: var(--spacing-md);
+  padding-block-end: 0;
+}
+
+.suggestion {
+  cursor: pointer;
+}
+
+.suggestion + .suggestion::before {
+  cursor: text;
+  content: ',';
+  padding-inline-end: 0.25ch;
+  font-weight: normal;
+}

frontend/app/src/app/modules/profile/id-cards.provider.ts

@@ -23,9 +23,9 @@ export class IdCardsProvider {
       this.encryptedStorageProvider.get<SCIdCard[]>('id-cards') as Promise<SCIdCard[]>,
     ).pipe(filter(it => it !== undefined));
 
-    return auth.isAuthenticated$.pipe(
+    return auth.isLoggedIn$.pipe(
-      mergeMap(isAuthenticated =>
+      mergeMap(isLoggedIn =>
-        isAuthenticated
+        isLoggedIn
           ? feature
             ? storedIdCards.pipe(
                 concatWith(

frontend/app/src/app/modules/profile/id-cards.spec.ts

@@ -7,7 +7,7 @@ import {SCAuthorizationProviderType} from '@openstapps/core';
 import {EncryptedStorageProvider} from '../storage/encrypted-storage.provider';
 
 class FakeAuth {
-  isAuthenticated$ = new BehaviorSubject(false);
+  isLoggedIn$ = new BehaviorSubject(false);
 
   // eslint-disable-next-line @typescript-eslint/no-empty-function
   getValidToken() {}
@@ -42,7 +42,7 @@ describe('IdCards', () => {
   });
 
   it('should emit network result when logged in', async () => {
-    fakeAuth.isAuthenticated$.next(true);
+    fakeAuth.isLoggedIn$.next(true);
     httpClient.get = jasmine.createSpy().and.returnValue(of(['abc']));
     fakeAuth.getValidToken = jasmine.createSpy().and.resolveTo({accessToken: 'fake-token'});
     const provider = new IdCardsProvider(authHelper, configProvider, httpClient, encryptedStorageProvider);
@@ -63,7 +63,7 @@ describe('IdCards', () => {
     expect(await firstValueFrom(observable)).toEqual([]);
     httpClient.get = jasmine.createSpy().and.returnValue(of(['abc']));
     fakeAuth.getValidToken = jasmine.createSpy().and.resolveTo({accessToken: 'fake-token'});
-    fakeAuth.isAuthenticated$.next(true);
+    fakeAuth.isLoggedIn$.next(true);
     // this is counter-intuitive, but because we unsubscribed above the first value
     // will now contain the network result.
     expect(await firstValueFrom(observable)).toEqual(['abc' as never]);

frontend/app/src/app/modules/profile/page/profile-page-section.component.ts

@@ -6,74 +6,56 @@
  *
  * This program is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * FITNESS FOR A PARTICULAr purpose. see the gnu general public license for
  * more details.
  *
- * You should have received a copy of the GNU General Public License along with
+ * you should have received a copy of the gnu general public license along with
- * this program. If not, see <https://www.gnu.org/licenses/>.
+ * this program. if not, see <https://www.gnu.org/licenses/>.
  */
-import {Component, DestroyRef, inject, Input, OnInit} from '@angular/core';
+import {Component, inject, input} from '@angular/core';
 import {SCSection} from '../../../../config/profile-page-sections';
 import {AuthHelperService} from '../../auth/auth-helper.service';
-import {Observable} from 'rxjs';
+import {mergeMap, of} from 'rxjs';
-import {SCAuthorizationProviderType} from '@openstapps/core';
 import Swiper from 'swiper';
-import {takeUntilDestroyed} from '@angular/core/rxjs-interop';
+import {toObservable, toSignal} from '@angular/core/rxjs-interop';
 
 @Component({
   selector: 'stapps-profile-page-section',
   templateUrl: 'profile-page-section.html',
   styleUrls: ['profile-page-section.scss'],
 })
-export class ProfilePageSectionComponent implements OnInit {
+export class ProfilePageSectionComponent {
-  @Input() item: SCSection;
+  item = input.required<SCSection>();
 
-  @Input() minSlideWidth = 110;
+  minSlideWidth = input(110);
 
-  isLoggedIn: boolean;
+  authHelper = inject(AuthHelperService);
+
+  loggedIn = toSignal(
+    toObservable(this.item).pipe(
+      mergeMap(item =>
+        item.authProvider ? this.authHelper.getProvider(item.authProvider).isLoggedIn$ : of(false),
+      ),
+    ),
+  );
 
   isEnd = false;
 
   isBeginning = true;
 
-  slidesPerView: number;
+  slidesPerView?: number;
 
   slidesFillScreen = false;
 
-  data: {
-    [key in SCAuthorizationProviderType]: {loggedIn$: Observable<boolean>};
-  } = {
-    default: {
-      loggedIn$: this.authHelper.getProvider('default').isAuthenticated$,
-    },
-    paia: {
-      loggedIn$: this.authHelper.getProvider('paia').isAuthenticated$,
-    },
-  };
-
-  destroy$ = inject(DestroyRef);
-
-  constructor(private authHelper: AuthHelperService) {}
-
-  ngOnInit() {
-    if (this.item.authProvider) {
-      this.data[this.item.authProvider].loggedIn$
-        .pipe(takeUntilDestroyed(this.destroy$))
-        .subscribe(loggedIn => {
-          this.isLoggedIn = loggedIn;
-        });
-    }
-  }
-
   activeIndexChange(swiper: Swiper) {
     this.isBeginning = swiper.isBeginning;
     this.isEnd = swiper.isEnd;
-    this.slidesFillScreen = this.slidesPerView >= swiper.slides.length;
+    this.slidesFillScreen = this.slidesPerView! >= swiper.slides.length;
   }
 
   resizeSwiper(resizeEvent: ResizeObserverEntry, swiper: Swiper) {
     const slidesPerView =
-      Math.floor((resizeEvent.contentRect.width - this.minSlideWidth / 2) / this.minSlideWidth) + 0.5;
+      Math.floor((resizeEvent.contentRect.width - this.minSlideWidth() / 2) / this.minSlideWidth()) + 0.5;
 
     if (slidesPerView > 1 && slidesPerView !== this.slidesPerView) {
       this.slidesPerView = slidesPerView;
@@ -84,16 +66,13 @@ export class ProfilePageSectionComponent implements OnInit {
   }
 
   async toggleLogIn() {
-    if (!this.item.authProvider) return;
+    const providerType = this.item().authProvider;
-    await (this.isLoggedIn ? this.signOut(this.item.authProvider) : this.signIn(this.item.authProvider));
+    if (!providerType) return;
-  }
+    if (this.loggedIn()) {
-
-  async signIn(providerType: SCAuthorizationProviderType) {
-    await this.authHelper.getProvider(providerType).signIn();
-  }
-
-  async signOut(providerType: SCAuthorizationProviderType) {
       await this.authHelper.getProvider(providerType).signOut();
       await this.authHelper.endBrowserSession(providerType);
+    } else {
+      await this.authHelper.getProvider(providerType).signIn();
+    }
   }
 }

frontend/app/src/app/modules/profile/page/profile-page-section.html

@@ -13,24 +13,24 @@
 ~ this program. If not, see <https://www.gnu.org/licenses/>.
 -->
 
-<stapps-section [title]="'name' | translateSimple: item">
+<stapps-section [title]="'name' | translateSimple: item()">
-  @if (item.authProvider) {
+  @if (item().authProvider) {
     <ion-button slot="button-end" fill="clear" color="dark" (click)="toggleLogIn()">
-      @if (isLoggedIn) {
+      @if (loggedIn()) {
         <ion-icon slot="end" name="logout"></ion-icon>
       } @else {
         <ion-icon slot="end" name="login"></ion-icon>
       }
-      <ion-label>{{ 'profile.buttons.default.log_' + (isLoggedIn ? 'out' : 'in') | translate }}</ion-label>
+      <ion-label>{{ 'profile.buttons.default.log_' + (loggedIn() ? 'out' : 'in') | translate }}</ion-label>
     </ion-button>
   }
 
   <simple-swiper>
-    @for (link of item.links; track link) {
+    @for (link of item().links; track link) {
       <ion-item
         lines="none"
         [routerLink]="link.link"
-        [disabled]="link.needsAuth && !isLoggedIn"
+        [disabled]="link.needsAuth && !loggedIn()"
         [detail]="false"
       >
         <div>

frontend/app/src/assets/i18n/de.json

@@ -425,7 +425,8 @@
       "placeholder": "Veranstaltungen, Personen, Orte und mehr"
     },
     "instruction": "Finde alle Informationen rund ums Studium und den Campus",
-    "nothing_found": "Keine Ergebnisse"
+    "nothing_found": "Keine Ergebnisse",
+    "SUGGESTIONS": "Meintest du"
   },
   "hebisSearch": {
     "title": "Bibliothekssuche",

frontend/app/src/assets/i18n/en.json

@@ -425,7 +425,8 @@
       "placeholder": "Events, places, persons and more"
     },
     "instruction": "Find all information related to your studies and campus",
-    "nothing_found": "No results"
+    "nothing_found": "No results",
+    "SUGGESTIONS": "Did you mean"
   },
   "hebisSearch": {
     "title": "Library Search",

frontend/app/src/environments/environment.ts

@@ -18,7 +18,7 @@
 // The list of which env maps to which file can be found in `.angular-cli.json`.
 
 export const environment = {
-  backend_url: 'https://mobile.server.uni-frankfurt.de',
+  backend_url: 'http://localhost:3000',
   app_host: 'mobile.app.uni-frankfurt.de',
   custom_url_scheme: 'de.anyschool.app',
   backend_version: '999.0.0',

packages/api-cli/README.md

@@ -23,7 +23,7 @@ node ./lib/cli.js e2e http://localhost:3000
 Example to clone the full database
 
 ```shell
-node app.js copy "*" https://mobile.app.uni-frankfurt.de http://localhost:3000 100
+node app.js copy "*" -a "999.0.0" https://mobile.server.uni-frankfurt.de http://localhost:3000 100
 ```
 
 ### Program arguments

packages/core/package.json

@@ -97,6 +97,8 @@
             "date",
             "validatable",
             "filterable",
+            "suggestable",
+            "completable",
             "inheritTags",
             "minLength",
             "pattern",

packages/core/src/protocol/search/result.ts

@@ -24,6 +24,11 @@ export interface SCSearchResult {
    */
   data: SCThings[];
 
+  /**
+   * Suggestions for query corrections
+   */
+  suggestions?: SCSearchSuggestions;
+
   /**
    * Facets (aggregations over all matching data)
    */
@@ -40,6 +45,18 @@ export interface SCSearchResult {
   stats: SCSearchResultSearchEngineStats;
 }
 
+/**
+ * Seach suggestions
+ *
+ * Not to be confused with search-as-you-type suggestions
+ */
+export interface SCSearchSuggestions {
+  /**
+   * Suggestions for query terms that might have been misspelled
+   */
+  terms?: Record<string, string[]>;
+}
+
 /**
  * Stores information about Pagination
  */

packages/core/src/things/abstract/thing.ts

@@ -63,7 +63,7 @@ export interface SCThingWithoutReferences {
   /**
    * Alternate names of the thing
    * @filterable
-   * @keyword
+   * @text
    */
   alternateNames?: string[];
 
@@ -92,6 +92,8 @@ export interface SCThingWithoutReferences {
    * @filterable
    * @minLength 1
    * @sortable ducet
+   * @completable
+   * @suggestable
    * @text
    */
   name: string;
@@ -240,6 +242,8 @@ export interface SCThingTranslatableProperties {
    * Translation of the name of the thing
    * @sortable ducet
    * @text
+   * @suggestable
+   * @completable
    */
   name?: string;
   /**

packages/es-mapping-generator/src/config/fieldmap.ts

@@ -43,6 +43,27 @@ export const fieldmap: ElasticsearchFieldmap = {
     },
     ignore: ['price'],
   },
+  suggestable: {
+    default: {
+      trigram: {
+        type: 'text',
+        analyzer: 'trigram',
+      },
+      reverse: {
+        type: 'text',
+        analyzer: 'reverse',
+      },
+    },
+    ignore: [],
+  },
+  completable: {
+    default: {
+      completion: {
+        type: 'search_as_you_type',
+      },
+    },
+    ignore: [],
+  },
 };
 
 export const filterableTagName = 'filterable';

packages/es-mapping-generator/src/config/settings.ts

@@ -19,4 +19,27 @@ export const settings: IndicesPutTemplateRequest['settings'] = {
   'max_result_window': 30_000,
   'number_of_replicas': 0,
   'number_of_shards': 1,
+  'index': {
+    analysis: {
+      analyzer: {
+        trigram: {
+          type: 'custom',
+          tokenizer: 'standard',
+          filter: ['lowercase', 'shingle'],
+        },
+        reverse: {
+          type: 'custom',
+          tokenizer: 'standard',
+          filter: ['lowercase', 'reverse'],
+        },
+      },
+      filter: {
+        shingle: {
+          type: 'shingle',
+          min_shingle_size: 2,
+          max_shingle_size: 3,
+        },
+      },
+    },
+  },
 };