From 446450934423c5e8c89563647605fdef4463237d Mon Sep 17 00:00:00 2001
From: Ralf Aron <ralf.aron@iosb-ina.fraunhofer.de>
Date: Mon, 4 Nov 2024 06:43:20 +0100
Subject: [PATCH] in progress

---
 projects/aas-core/src/lib/types.ts            |   9 +-
 .../add-endpoint-form.component.html          |  19 +-
 .../src/app/start/start-api.service.ts        |   6 +-
 .../aas-portal/src/app/start/start.store.ts   |   6 +-
 .../aas-server/src/app/aas-index/aas-index.ts |   4 +-
 .../src/app/aas-index/lowdb/lowdb-index.ts    |  13 +-
 .../src/app/aas-index/mysql/mysql-index.ts    |  63 +++--
 .../src/app/aas-index/mysql/mysql-types.ts    |   1 +
 .../src/app/aas-provider/aas-provider.ts      |  66 +++--
 .../src/app/aas-provider/scan-result.ts       |   6 +-
 .../src/app/aas-provider/worker-data.ts       |   1 +
 .../app/controller/documents-controller.ts    |   4 +-
 projects/aas-server/src/app/endpoint-scan.ts  |   3 +
 .../src/app/template/template-scan.ts         |   1 +
 .../src/app/template/template-storage.ts      |   1 +
 projects/aas-server/src/app/variable.ts       |  12 +-
 projects/aas-server/src/app/worker-app.ts     |   7 +-
 .../test/aas-index/mysql/mysql-index.spec.ts  | 229 ++++++++++++++++--
 .../test/template/template-storage.spec.ts    |   1 +
 projects/aasportal-index/schema.sql           |   3 +-
 20 files changed, 369 insertions(+), 86 deletions(-)

diff --git a/projects/aas-core/src/lib/types.ts b/projects/aas-core/src/lib/types.ts
index 3e1b2047..2a8c5ad1 100644
--- a/projects/aas-core/src/lib/types.ts
+++ b/projects/aas-core/src/lib/types.ts
@@ -45,6 +45,12 @@ export type AASAbbreviation =
     | 'SME'
     | 'SML';
 
+/** The schedule type. */
+export interface AASEndpointSchedule {
+    type: 'never' | 'once' | 'every' | 'daily' | 'weekly';
+    values?: (string | number)[];
+}
+
 /** The kind of AAS container or server. */
 export type AASEndpointType = 'FileSystem' | 'AAS_API' | 'OPC_UA' | 'WebDAV';
 
@@ -53,6 +59,7 @@ export type AASEndpoint = {
     name: string;
     url: string;
     type: AASEndpointType;
+    schedule?: AASEndpointSchedule;
     version?: string;
     headers?: Record<string, string>;
 };
@@ -99,7 +106,7 @@ export interface AASDocument extends AASDocumentId {
 }
 
 /** Represents a page of AAS documents from the total set. */
-export interface AASPage {
+export interface AASPagedResult {
     previous: AASDocumentId | null;
     next: AASDocumentId | null;
     documents: AASDocument[];
diff --git a/projects/aas-portal/src/app/start/add-endpoint-form/add-endpoint-form.component.html b/projects/aas-portal/src/app/start/add-endpoint-form/add-endpoint-form.component.html
index a42af250..96aa3e84 100644
--- a/projects/aas-portal/src/app/start/add-endpoint-form/add-endpoint-form.component.html
+++ b/projects/aas-portal/src/app/start/add-endpoint-form/add-endpoint-form.component.html
@@ -42,13 +42,30 @@ <h4 class="modal-title">
                 (input)="inputValue()">
         </div>
         @if (selectedItem().type === 'AAS_API') {
-        <button type="button" class="btn btn-primary my-2" (click)="collapse.toggle()"
+        <button type="button" class="btn btn-primary mt-3 mb-2" (click)="collapse.toggle()"
             [attr.aria-expanded]="isCollapsed() === false" aria-controls="collapseExample" translate>
             AddEndpointForm.ADVANCED_SETTINGS
         </button>
         <div #collapse="ngbCollapse" [(ngbCollapse)]="isCollapsed">
+            <div class="form-check form-check-inline">
+                <input class="form-check-input" type="radio" name="scheduleType" id="scheduleTypeNever" value="never">
+                <label class="form-check-label" for="scheduleTypeNever">Never</label>
+            </div>
+            <div class="form-check form-check-inline">
+                <input class="form-check-input" type="radio" name="scheduleType" id="scheduleTypeOnce" value="once">
+                <label class="form-check-label" for="scheduleTypeOnce">Once</label>
+            </div>
+            <div class="form-check form-check-inline">
+                <input class="form-check-input" type="radio" name="scheduleType" id="scheduleTypeEvery" value="every">
+                <label class="form-check-label" for="scheduleTypeEvery">Every</label>
+            </div>
+            <div class="form-check form-check-inline">
+                <input class="form-check-input" type="radio" name="scheduleType" id="scheduleTypeEach" value="daily">
+                <label class="form-check-label" for="scheduleTypeEach">Each</label>
+            </div>
             <div class="col-12 mt-2" style="max-height: 200px; overflow-y: auto;">
                 <table class="table table-sm table-striped table-borderless">
+                    <caption class="caption-top">Headers</caption>
                     <thead>
                         <tr>
                             <th scope="col" class="text-center" [style.width]="'32px'">#</th>
diff --git a/projects/aas-portal/src/app/start/start-api.service.ts b/projects/aas-portal/src/app/start/start-api.service.ts
index 26ecf3d6..54954426 100644
--- a/projects/aas-portal/src/app/start/start-api.service.ts
+++ b/projects/aas-portal/src/app/start/start-api.service.ts
@@ -9,7 +9,7 @@
 import { Injectable } from '@angular/core';
 import { HttpClient } from '@angular/common/http';
 import { Observable } from 'rxjs';
-import { AASCursor, AASDocument, AASEndpoint, AASPage, aas } from 'aas-core';
+import { AASCursor, AASDocument, AASEndpoint, AASPagedResult, aas } from 'aas-core';
 import { encodeBase64Url } from 'aas-lib';
 
 /** The client side AAS provider service. */
@@ -65,7 +65,7 @@ export class StartApiService {
      * @param language The language to used for the filter.
      * @returns The document page.
      */
-    public getPage(cursor: AASCursor, filter?: string, language?: string): Observable<AASPage> {
+    public getPage(cursor: AASCursor, filter?: string, language?: string): Observable<AASPagedResult> {
         let url = `/api/v1/documents?cursor=${encodeBase64Url(JSON.stringify(cursor))}`;
         if (filter) {
             url += `&filter=${encodeBase64Url(filter)}`;
@@ -74,7 +74,7 @@ export class StartApiService {
             }
         }
 
-        return this.http.get<AASPage>(url);
+        return this.http.get<AASPagedResult>(url);
     }
 
     /**
diff --git a/projects/aas-portal/src/app/start/start.store.ts b/projects/aas-portal/src/app/start/start.store.ts
index ddacbc50..2db55b42 100644
--- a/projects/aas-portal/src/app/start/start.store.ts
+++ b/projects/aas-portal/src/app/start/start.store.ts
@@ -1,7 +1,7 @@
 import { Injectable, computed, signal } from '@angular/core';
 import { Observable, catchError, concat, from, map, mergeMap, of } from 'rxjs';
 import { ViewMode } from 'aas-lib';
-import { AASDocument, AASDocumentId, AASPage, aas, equalArray } from 'aas-core';
+import { AASDocument, AASDocumentId, AASPagedResult, aas, equalArray } from 'aas-core';
 import { StartApiService } from './start-api.service';
 import { TranslateService } from '@ngx-translate/core';
 import { FavoritesService } from './favorites.service';
@@ -198,7 +198,7 @@ export class StartStore {
         return { id: document.id, endpoint: document.endpoint };
     }
 
-    private setPageAndLoadContents(page: AASPage, limit?: number, filter?: string): Observable<void> {
+    private setPageAndLoadContents(page: AASPagedResult, limit?: number, filter?: string): Observable<void> {
         return concat(
             of(this.setPage(page, limit, filter)),
             from(page.documents).pipe(
@@ -212,7 +212,7 @@ export class StartStore {
         );
     }
 
-    private setPage(page: AASPage, limit: number | undefined, filter: string | undefined): void {
+    private setPage(page: AASPagedResult, limit: number | undefined, filter: string | undefined): void {
         this._viewMode.set(ViewMode.List);
         this._activeFavorites.set('');
         this._documents.set(page.documents);
diff --git a/projects/aas-server/src/app/aas-index/aas-index.ts b/projects/aas-server/src/app/aas-index/aas-index.ts
index cda862bc..d345219a 100644
--- a/projects/aas-server/src/app/aas-index/aas-index.ts
+++ b/projects/aas-server/src/app/aas-index/aas-index.ts
@@ -10,7 +10,7 @@ import {
     AASCursor,
     AASDocument,
     AASEndpoint,
-    AASPage,
+    AASPagedResult,
     aas,
     baseType,
     getAbbreviation,
@@ -40,7 +40,7 @@ export abstract class AASIndex {
 
     public abstract removeEndpoint(endpointName: string): Promise<boolean>;
 
-    public abstract getDocuments(cursor: AASCursor, query?: string, language?: string): Promise<AASPage>;
+    public abstract getDocuments(cursor: AASCursor, query?: string, language?: string): Promise<AASPagedResult>;
 
     public abstract nextPage(
         endpointName: string,
diff --git a/projects/aas-server/src/app/aas-index/lowdb/lowdb-index.ts b/projects/aas-server/src/app/aas-index/lowdb/lowdb-index.ts
index 384c3371..02c2a5ff 100644
--- a/projects/aas-server/src/app/aas-index/lowdb/lowdb-index.ts
+++ b/projects/aas-server/src/app/aas-index/lowdb/lowdb-index.ts
@@ -13,13 +13,14 @@ import {
     AASDocument,
     AASDocumentId,
     AASEndpoint,
-    AASPage,
+    AASPagedResult,
     ApplicationError,
     BaseValueType,
     aas,
     flat,
     isIdentifiable,
 } from 'aas-core';
+
 import { AASIndex } from '../aas-index.js';
 import { LowDbQuery } from './lowdb-query.js';
 import { Variable } from '../../variable.js';
@@ -154,7 +155,7 @@ export class LowDbIndex extends AASIndex {
         return { result, paging_metadata: { cursor: encodeBase64Url(items[k].id) } };
     }
 
-    public override async getDocuments(cursor: AASCursor, query?: string, language?: string): Promise<AASPage> {
+    public override async getDocuments(cursor: AASCursor, query?: string, language?: string): Promise<AASPagedResult> {
         await this.promise;
 
         let filter: LowDbQuery | undefined;
@@ -293,7 +294,7 @@ export class LowDbIndex extends AASIndex {
         return index;
     }
 
-    private getFirstPage(limit: number, filter?: LowDbQuery): AASPage {
+    private getFirstPage(limit: number, filter?: LowDbQuery): AASPagedResult {
         const documents: AASDocument[] = [];
         if (this.db.data.documents.length === 0) {
             return { previous: null, documents, next: null };
@@ -324,7 +325,7 @@ export class LowDbIndex extends AASIndex {
         };
     }
 
-    private getNextPage(current: AASDocumentId, limit: number, filter?: LowDbQuery): AASPage {
+    private getNextPage(current: AASDocumentId, limit: number, filter?: LowDbQuery): AASPagedResult {
         const documents: AASDocument[] = [];
         if (this.db.data.documents.length === 0) {
             return { previous: null, documents, next: null };
@@ -362,7 +363,7 @@ export class LowDbIndex extends AASIndex {
         };
     }
 
-    private getPreviousPage(current: AASDocumentId, limit: number, filter?: LowDbQuery): AASPage {
+    private getPreviousPage(current: AASDocumentId, limit: number, filter?: LowDbQuery): AASPagedResult {
         const documents: AASDocument[] = [];
         if (this.db.data.documents.length === 0) {
             return { previous: null, documents, next: null };
@@ -400,7 +401,7 @@ export class LowDbIndex extends AASIndex {
         };
     }
 
-    private getLastPage(limit: number, filter?: LowDbQuery): AASPage {
+    private getLastPage(limit: number, filter?: LowDbQuery): AASPagedResult {
         const documents: AASDocument[] = [];
         if (this.db.data.documents.length === 0) {
             return { previous: null, documents, next: null };
diff --git a/projects/aas-server/src/app/aas-index/mysql/mysql-index.ts b/projects/aas-server/src/app/aas-index/mysql/mysql-index.ts
index 8d4f1831..3646c612 100644
--- a/projects/aas-server/src/app/aas-index/mysql/mysql-index.ts
+++ b/projects/aas-server/src/app/aas-index/mysql/mysql-index.ts
@@ -9,7 +9,17 @@
 import { v4 } from 'uuid';
 import isEmpty from 'lodash-es/isEmpty.js';
 import mysql, { Connection, ResultSetHeader } from 'mysql2/promise';
-import { AASEndpoint, AASCursor, AASPage, AASDocument, flat, aas, AASDocumentId, isIdentifiable } from 'aas-core';
+import {
+    AASEndpoint,
+    AASCursor,
+    AASDocument,
+    flat,
+    aas,
+    AASDocumentId,
+    isIdentifiable,
+    AASPagedResult,
+} from 'aas-core';
+
 import { AASIndex } from '../aas-index.js';
 import { Variable } from '../../variable.js';
 import { urlToEndpoint } from '../../configuration.js';
@@ -48,19 +58,19 @@ export class MySqlIndex extends AASIndex {
     public override async getCount(endpoint?: string): Promise<number> {
         if (endpoint === undefined) {
             return (
-                await (await this.connection).query<DocumentCount[]>('SELECT COUNT(*) FROM `documents` AS count')
+                await (await this.connection).query<DocumentCount[]>('SELECT COUNT(*) FROM `documents` AS count;')
             )[0][0].count;
         }
 
         return (
             await (
                 await this.connection
-            ).query<DocumentCount[]>('SELECT COUNT(*) FROM `documents` WHERE endpoint = ? AS count', [endpoint])
+            ).query<DocumentCount[]>('SELECT COUNT(*) FROM `documents` WHERE endpoint = ? AS count;', [endpoint])
         )[0][0].count;
     }
 
     public override async getEndpoints(): Promise<AASEndpoint[]> {
-        return (await (await this.connection).query<MySqlEndpoint[]>('SELECT * FROM `endpoints`'))[0].map(
+        return (await (await this.connection).query<MySqlEndpoint[]>('SELECT * FROM `endpoints`;'))[0].map(
             row =>
                 ({
                     name: row.name,
@@ -75,7 +85,7 @@ export class MySqlIndex extends AASIndex {
     public override async getEndpoint(name: string): Promise<AASEndpoint> {
         const [results] = await (
             await this.connection
-        ).query<MySqlEndpoint[]>('SELECT * FROM `endpoints` WHERE name = ?', [name]);
+        ).query<MySqlEndpoint[]>('SELECT * FROM `endpoints` WHERE name = ?;', [name]);
 
         if (results.length === 0) {
             throw new Error(`An endpoint with the name "${name}" does not exist.`);
@@ -96,13 +106,17 @@ export class MySqlIndex extends AASIndex {
             endpoint.headers = JSON.parse(result.headers);
         }
 
+        if (result.schedule) {
+            endpoint.schedule = JSON.parse(result.schedule);
+        }
+
         return endpoint;
     }
 
     public override async hasEndpoint(name: string): Promise<boolean> {
         const [results] = await (
             await this.connection
-        ).query<MySqlEndpoint[]>('SELECT * FROM `endpoints` WHERE name = ?', [name]);
+        ).query<MySqlEndpoint[]>('SELECT * FROM `endpoints` WHERE name = ?;', [name]);
 
         return results.length > 0;
     }
@@ -110,13 +124,16 @@ export class MySqlIndex extends AASIndex {
     public override async addEndpoint(endpoint: AASEndpoint): Promise<void> {
         await (
             await this.connection
-        ).query<ResultSetHeader>('INSERT INTO `endpoints` (name, url, type, version, headers) VALUES (?, ?, ?, ?, ?)', [
-            endpoint.name,
-            endpoint.url,
-            endpoint.type,
-            endpoint.version,
-            endpoint.headers ? JSON.stringify(endpoint.headers) : undefined,
-        ]);
+        ).query<ResultSetHeader>(
+            'INSERT INTO `endpoints` (name, url, type, version, headers) VALUES (?, ?, ?, ?, ?);',
+            [
+                endpoint.name,
+                endpoint.url,
+                endpoint.type,
+                endpoint.version,
+                endpoint.headers ? JSON.stringify(endpoint.headers) : undefined,
+            ],
+        );
     }
 
     public override async removeEndpoint(endpointName: string): Promise<boolean> {
@@ -126,7 +143,7 @@ export class MySqlIndex extends AASIndex {
 
             const result = await (
                 await this.connection
-            ).query<ResultSetHeader>('DELETE FROM `endpoints` WHERE name = ?', [endpointName]);
+            ).query<ResultSetHeader>('DELETE FROM `endpoints` WHERE name = ?;', [endpointName]);
 
             this.removeDocuments(endpointName);
 
@@ -138,7 +155,7 @@ export class MySqlIndex extends AASIndex {
         }
     }
 
-    public override getDocuments(cursor: AASCursor, query?: string, language?: string): Promise<AASPage> {
+    public override getDocuments(cursor: AASCursor, query?: string, language?: string): Promise<AASPagedResult> {
         let q: MySqlQuery | undefined;
         if (query) {
             q = new MySqlQuery(query, language ?? 'en');
@@ -200,7 +217,7 @@ export class MySqlIndex extends AASIndex {
 
             const uuid = result[0][0].uuid;
             await connection.query<ResultSetHeader>(
-                'UPDATE `documents` SET address = ?, crc32 = ?, idShort = ?, onlineReady = ?, readonly = ?, timestamp = ?, thumbnail = ? WHERE uuid = ?',
+                'UPDATE `documents` SET address = ?, crc32 = ?, idShort = ?, onlineReady = ?, readonly = ?, timestamp = ?, thumbnail = ? WHERE uuid = ?;',
                 [
                     document.address,
                     document.crc32,
@@ -231,7 +248,7 @@ export class MySqlIndex extends AASIndex {
             await connection.beginTransaction();
             const uuid = v4();
             await connection.query<ResultSetHeader>(
-                'INSERT INTO `documents` (uuid, address, crc32, endpoint, id, idShort, assetId, onlineReady, readonly, thumbnail, timestamp) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
+                'INSERT INTO `documents` (uuid, address, crc32, endpoint, id, idShort, assetId, onlineReady, readonly, thumbnail, timestamp) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);',
                 [
                     uuid,
                     document.address,
@@ -320,17 +337,17 @@ export class MySqlIndex extends AASIndex {
     private async removeDocuments(endpointName: string): Promise<void> {
         const connection = await this.connection;
         const documents = (
-            await connection.query<MySqlDocument[]>('SELECT * FROM `documents` WHERE endpoint = ?', [endpointName])
+            await connection.query<MySqlDocument[]>('SELECT * FROM `documents` WHERE endpoint = ?;', [endpointName])
         )[0];
 
-        await connection.query<ResultSetHeader>('DELETE FROM `documents` WHERE endpoint = ?', [endpointName]);
+        await connection.query<ResultSetHeader>('DELETE FROM `documents` WHERE endpoint = ?;', [endpointName]);
 
         for (const document of documents) {
             await connection.query<ResultSetHeader>('DELETE FROM `elements` WHERE uuid = ?;', [document.uuid]);
         }
     }
 
-    private async getFirstPage(limit: number, query?: MySqlQuery): Promise<AASPage> {
+    private async getFirstPage(limit: number, query?: MySqlQuery): Promise<AASPagedResult> {
         const connection = await this.connection;
         let sql: string;
         const values: unknown[] = [];
@@ -361,7 +378,7 @@ export class MySqlIndex extends AASIndex {
         };
     }
 
-    private async getNextPage(current: AASDocumentId, limit: number, query?: MySqlQuery): Promise<AASPage> {
+    private async getNextPage(current: AASDocumentId, limit: number, query?: MySqlQuery): Promise<AASPagedResult> {
         const connection = await this.connection;
         let sql: string;
         const values: unknown[] = [current.endpoint + current.id];
@@ -393,7 +410,7 @@ export class MySqlIndex extends AASIndex {
         };
     }
 
-    private async getPreviousPage(current: AASDocumentId, limit: number, query?: MySqlQuery): Promise<AASPage> {
+    private async getPreviousPage(current: AASDocumentId, limit: number, query?: MySqlQuery): Promise<AASPagedResult> {
         const connection = await this.connection;
         let sql: string;
         const values: unknown[] = [current.endpoint + current.id];
@@ -425,7 +442,7 @@ export class MySqlIndex extends AASIndex {
         };
     }
 
-    private async getLastPage(limit: number, query?: MySqlQuery): Promise<AASPage> {
+    private async getLastPage(limit: number, query?: MySqlQuery): Promise<AASPagedResult> {
         const connection = await this.connection;
         let sql: string;
         const values: unknown[] = [];
diff --git a/projects/aas-server/src/app/aas-index/mysql/mysql-types.ts b/projects/aas-server/src/app/aas-index/mysql/mysql-types.ts
index 2d560da5..7641a627 100644
--- a/projects/aas-server/src/app/aas-index/mysql/mysql-types.ts
+++ b/projects/aas-server/src/app/aas-index/mysql/mysql-types.ts
@@ -15,6 +15,7 @@ export interface MySqlEndpoint extends RowDataPacket {
     type: AASEndpointType;
     version?: string;
     headers?: string;
+    schedule?: string;
 }
 
 export interface MySqlDocument extends AASDocument, RowDataPacket {
diff --git a/projects/aas-server/src/app/aas-provider/aas-provider.ts b/projects/aas-server/src/app/aas-provider/aas-provider.ts
index 77efebaa..97da1412 100644
--- a/projects/aas-server/src/app/aas-provider/aas-provider.ts
+++ b/projects/aas-server/src/app/aas-provider/aas-provider.ts
@@ -17,11 +17,12 @@ import {
     aas,
     selectElement,
     AASCursor,
-    AASPage,
+    AASPagedResult,
     AASEndpoint,
     ApplicationError,
     getChildren,
     isReferenceElement,
+    AASEndpointSchedule,
     noop,
 } from 'aas-core';
 
@@ -35,7 +36,6 @@ import { SocketClient } from '../live/socket-client.js';
 import { EmptySubscription } from '../live/empty-subscription.js';
 import { SocketSubscription } from '../live/socket-subscription.js';
 import { AASResourceFactory } from '../packages/aas-resource-factory.js';
-import { AASResourceScanFactory } from './aas-resource-scan-factory.js';
 import { Variable } from '../variable.js';
 import { WSServer } from '../ws-server.js';
 import { ERRORS } from '../errors.js';
@@ -45,21 +45,19 @@ import { AASCache } from './aas-cache.js';
 
 @singleton()
 export class AASProvider {
-    private readonly timeout: number;
     private readonly file: string | undefined;
     private readonly cache = new AASCache();
     private wsServer!: WSServer;
     private resetRequested = false;
 
     public constructor(
-        @inject(Variable) variable: Variable,
+        @inject(Variable) private readonly variable: Variable,
         @inject('Logger') private readonly logger: Logger,
         @inject(Parallel) private readonly parallel: Parallel,
         @inject(AASResourceFactory) private readonly resourceFactory: AASResourceFactory,
         @inject('AASIndex') private readonly index: AASIndex,
         @inject(TaskHandler) private readonly taskHandler: TaskHandler,
     ) {
-        this.timeout = variable.SCAN_CONTAINER_TIMEOUT;
         this.parallel.on('message', this.parallelOnMessage);
         this.parallel.on('end', this.parallelOnEnd);
     }
@@ -88,7 +86,7 @@ export class AASProvider {
      * @param language The current language.
      * @returns A page of documents.
      */
-    public getDocumentsAsync(cursor: AASCursor, filter?: string, language?: string): Promise<AASPage> {
+    public getDocumentsAsync(cursor: AASCursor, filter?: string, language?: string): Promise<AASPagedResult> {
         const minFilterLength = 3;
         if (filter && filter.length >= minFilterLength) {
             return this.index.getDocuments(cursor, filter, language ?? 'en');
@@ -373,17 +371,6 @@ export class AASProvider {
         }
     }
 
-    /** Only used for test. */
-    public async scanAsync(factory: AASResourceScanFactory): Promise<void> {
-        noop(factory);
-        // for (const endpoint of await this.index.getEndpoints()) {
-        //     if (endpoint.type === 'FileSystem') {
-        //         const result = await factory.create(endpoint).scanAsync();
-        //         result.result.forEach(async document => await this.index.add(document));
-        //     }
-        // }
-    }
-
     /**
      * Invokes an operation synchronous.
      * @param endpointName The endpoint name.
@@ -472,18 +459,47 @@ export class AASProvider {
     private startScan = async (): Promise<void> => {
         try {
             for (const endpoint of await this.index.getEndpoints()) {
-                setTimeout(this.scanEndpoint, 0, this.taskHandler.createTaskId(), endpoint);
+                if (endpoint.schedule?.type === 'never') {
+                    continue;
+                }
+
+                setTimeout(
+                    this.scanEndpoint,
+                    this.computeTimeout(endpoint.schedule),
+                    this.taskHandler.createTaskId(),
+                    endpoint,
+                );
             }
         } catch (error) {
             this.logger.error(error);
         }
     };
 
+    private computeTimeout(schedule: AASEndpointSchedule | undefined, start?: number): number {
+        if (schedule === undefined) {
+            return this.variable.SCAN_ENDPOINT_TIMEOUT;
+        }
+
+        start = start || Date.now();
+        if (schedule.type === 'every') {
+            const values = schedule.values;
+            if (values && values.length > 0 && typeof values[0] === 'number') {
+                const timeout = Date.now() - start - values[0];
+                return timeout >= 0 ? timeout : values[0];
+            }
+        } else if (schedule.type === 'daily' || ) {
+            noop();
+        }
+
+        return this.variable.SCAN_ENDPOINT_TIMEOUT;
+    }
+
     private scanEndpoint = async (taskId: number, endpoint: AASEndpoint) => {
         const data: ScanEndpointData = {
             type: 'ScanEndpointData',
             taskId,
             endpoint,
+            start: Date.now(),
         };
 
         this.taskHandler.set(taskId, { endpointName: endpoint.name, owner: this, type: 'ScanEndpoint' });
@@ -515,9 +531,19 @@ export class AASProvider {
         }
 
         this.taskHandler.delete(result.taskId);
-        if ((await await this.index.hasEndpoint(task.endpointName)) === true) {
+        if ((await this.index.hasEndpoint(task.endpointName)) === true) {
             const endpoint = await this.index.getEndpoint(task.endpointName);
-            setTimeout(this.scanEndpoint, this.timeout, result.taskId, endpoint);
+
+            if (endpoint.schedule?.type === 'once') {
+                return;
+            }
+
+            setTimeout(
+                this.scanEndpoint,
+                this.computeTimeout(endpoint.schedule, result.start),
+                result.taskId,
+                endpoint,
+            );
         }
 
         if (result.messages) {
diff --git a/projects/aas-server/src/app/aas-provider/scan-result.ts b/projects/aas-server/src/app/aas-provider/scan-result.ts
index 11a81827..d77abd00 100644
--- a/projects/aas-server/src/app/aas-provider/scan-result.ts
+++ b/projects/aas-server/src/app/aas-provider/scan-result.ts
@@ -15,13 +15,11 @@ export enum ScanResultType {
     End,
 }
 
-/** The result of a container scan. */
+/** The result of an endpoint scan. */
 export interface ScanResult {
-    /** The result. */
     type: ScanResultType;
-    /** The task identifier. */
     taskId: number;
-    /** The message memory. */
+    start: number;
     messages?: Message[];
 }
 
diff --git a/projects/aas-server/src/app/aas-provider/worker-data.ts b/projects/aas-server/src/app/aas-provider/worker-data.ts
index 47bff72f..a2f2592b 100644
--- a/projects/aas-server/src/app/aas-provider/worker-data.ts
+++ b/projects/aas-server/src/app/aas-provider/worker-data.ts
@@ -11,6 +11,7 @@ import { AASEndpoint } from 'aas-core';
 export interface WorkerData {
     taskId: number;
     type: 'ScanEndpointData' | 'ScanTemplatesData';
+    start: number;
 }
 
 export interface ScanEndpointData extends WorkerData {
diff --git a/projects/aas-server/src/app/controller/documents-controller.ts b/projects/aas-server/src/app/controller/documents-controller.ts
index 36c9e1fb..fbb3dfb8 100644
--- a/projects/aas-server/src/app/controller/documents-controller.ts
+++ b/projects/aas-server/src/app/controller/documents-controller.ts
@@ -12,7 +12,7 @@ import { Logger } from '../logging/logger.js';
 import { AASController } from './aas-controller.js';
 import { AuthService } from '../auth/auth-service.js';
 import { Variable } from '../variable.js';
-import { AASDocument, AASPage } from 'aas-core';
+import { AASDocument, AASPagedResult } from 'aas-core';
 import { AASProvider } from '../aas-provider/aas-provider.js';
 import { decodeBase64Url } from '../convert.js';
 
@@ -42,7 +42,7 @@ export class DocumentsController extends AASController {
         @Query() cursor: string,
         @Query() filter?: string,
         @Query() language?: string,
-    ): Promise<AASPage> {
+    ): Promise<AASPagedResult> {
         try {
             this.logger.start('getDocuments');
             if (filter) {
diff --git a/projects/aas-server/src/app/endpoint-scan.ts b/projects/aas-server/src/app/endpoint-scan.ts
index 611582ca..5507f4f7 100644
--- a/projects/aas-server/src/app/endpoint-scan.ts
+++ b/projects/aas-server/src/app/endpoint-scan.ts
@@ -61,6 +61,7 @@ export class EndpointScan {
             type: ScanResultType.Update,
             endpoint: this.data.endpoint,
             document: document,
+            start: this.data.start,
         };
 
         const array = toUint8Array(value);
@@ -73,6 +74,7 @@ export class EndpointScan {
             type: ScanResultType.Remove,
             endpoint: this.data.endpoint,
             document: document,
+            start: this.data.start,
         };
 
         const array = toUint8Array(value);
@@ -85,6 +87,7 @@ export class EndpointScan {
             type: ScanResultType.Add,
             endpoint: this.data.endpoint,
             document: document,
+            start: this.data.start,
         };
 
         const array = toUint8Array(value);
diff --git a/projects/aas-server/src/app/template/template-scan.ts b/projects/aas-server/src/app/template/template-scan.ts
index 90d5829c..fd32ca61 100644
--- a/projects/aas-server/src/app/template/template-scan.ts
+++ b/projects/aas-server/src/app/template/template-scan.ts
@@ -52,6 +52,7 @@ export class TemplateScan {
             taskId: data.taskId,
             type: ScanResultType.Update,
             templates: templates,
+            start: data.start,
         };
 
         const array = toUint8Array(value);
diff --git a/projects/aas-server/src/app/template/template-storage.ts b/projects/aas-server/src/app/template/template-storage.ts
index 2ef64b83..80084086 100644
--- a/projects/aas-server/src/app/template/template-storage.ts
+++ b/projects/aas-server/src/app/template/template-storage.ts
@@ -79,6 +79,7 @@ export class TemplateStorage {
         const data: ScanTemplatesData = {
             type: 'ScanTemplatesData',
             taskId,
+            start: Date.now(),
         };
 
         this.taskHandler.set(taskId, { endpointName: 'TemplateStorage', owner: this, type: 'ScanTemplates' });
diff --git a/projects/aas-server/src/app/variable.ts b/projects/aas-server/src/app/variable.ts
index 202867e9..35c9cce6 100644
--- a/projects/aas-server/src/app/variable.ts
+++ b/projects/aas-server/src/app/variable.ts
@@ -24,8 +24,14 @@ export class Variable {
         this.WEB_ROOT = path.resolve(process.env.WEB_ROOT ?? './wwwroot');
         this.ASSETS = path.resolve(process.env.ASSETS ?? './assets');
         this.ENDPOINTS = process.env.ENDPOINTS ? JSON.parse(process.env.ENDPOINTS) : ['file:///samples?name=Samples'];
-        this.SCAN_TEMPLATES_TIMEOUT = process.env.SCAN_TEMPLATES_TIMEOUT ? Number(process.env.TIMEOUT) : 300000;
-        this.SCAN_CONTAINER_TIMEOUT = process.env.SCAN_CONTAINER_TIMEOUT ? Number(process.env.TIMEOUT) : 5000;
+        this.SCAN_TEMPLATES_TIMEOUT = process.env.SCAN_TEMPLATES_TIMEOUT
+            ? Number(process.env.SCAN_TEMPLATES_TIMEOUT)
+            : 300000;
+
+        this.SCAN_ENDPOINT_TIMEOUT = process.env.SCAN_ENDPOINT_TIMEOUT
+            ? Number(process.env.SCAN_ENDPOINT_TIMEOUT)
+            : 5000;
+
         this.HTTPS_CERT_FILE = process.env.HTTPS_CERT_FILE;
         this.HTTPS_KEY_FILE = process.env.HTTPS_KEY_FILE;
         this.HTTPS_PFX_FILE = process.env.HTTPS_PFX_FILE;
@@ -75,7 +81,7 @@ export class Variable {
     public readonly ENDPOINTS: string[];
 
     /** The time before a new endpoint scan starts.*/
-    public readonly SCAN_CONTAINER_TIMEOUT: number;
+    public readonly SCAN_ENDPOINT_TIMEOUT: number;
 
     /** The time before a new template scan starts. */
     public readonly SCAN_TEMPLATES_TIMEOUT: number;
diff --git a/projects/aas-server/src/app/worker-app.ts b/projects/aas-server/src/app/worker-app.ts
index 3d88d42f..1d8bcf93 100644
--- a/projects/aas-server/src/app/worker-app.ts
+++ b/projects/aas-server/src/app/worker-app.ts
@@ -43,14 +43,15 @@ export class WorkerApp {
             this.logger.error(error);
         } finally {
             this.logger.stop();
-            parentPort.postMessage(toUint8Array(this.createEndResult(data.taskId)));
+            parentPort.postMessage(toUint8Array(this.createEndResult(data)));
         }
     };
 
-    private createEndResult(taskId: number): ScanResult {
+    private createEndResult(data: WorkerData): ScanResult {
         return {
-            taskId: taskId,
+            taskId: data.taskId,
             type: ScanResultType.End,
+            start: data.start,
             messages: this.logger.getMessages(),
         };
     }
diff --git a/projects/aas-server/src/test/aas-index/mysql/mysql-index.spec.ts b/projects/aas-server/src/test/aas-index/mysql/mysql-index.spec.ts
index c79ccffe..7dbdfe6e 100644
--- a/projects/aas-server/src/test/aas-index/mysql/mysql-index.spec.ts
+++ b/projects/aas-server/src/test/aas-index/mysql/mysql-index.spec.ts
@@ -9,11 +9,12 @@
 import { beforeEach, describe, expect, it, jest } from '@jest/globals';
 import { Connection } from 'mysql2/promise';
 import { createSpyObj } from 'fhg-jest';
+import { AASEndpoint } from 'aas-core';
 import { MySqlIndex } from '../../../app/aas-index/mysql/mysql-index.js';
 import { Logger } from '../../../app/logging/logger.js';
 import { Variable } from '../../../app/variable.js';
 import { KeywordDirectory } from '../../../app/aas-index/keyword-directory.js';
-import { DocumentCount, MySqlEndpoint } from '../../../app/aas-index/mysql/mysql-types.js';
+import { DocumentCount, MySqlDocument, MySqlEndpoint } from '../../../app/aas-index/mysql/mysql-types.js';
 
 describe('MySqlIndex', () => {
     let index: MySqlIndex;
@@ -26,7 +27,7 @@ describe('MySqlIndex', () => {
         logger = createSpyObj<Logger>(['error', 'info']);
         variable = createSpyObj<Variable>({}, { ENDPOINTS: [] });
         keywords = createSpyObj<KeywordDirectory>(['containedKeyword', 'toString']);
-        connection = createSpyObj<Connection>(['query']);
+        connection = createSpyObj<Connection>(['query', 'beginTransaction', 'commit', 'rollback']);
         index = new MySqlIndex(logger, variable, keywords, connection);
     });
 
@@ -42,9 +43,8 @@ describe('MySqlIndex', () => {
             };
 
             connection.query.mockResolvedValue([[result], []]);
-            const count = await index.getCount();
-            expect(connection.query).toBeCalledWith('SELECT COUNT(*) FROM `documents` AS count');
-            expect(count).toEqual(42);
+            await expect(index.getCount()).resolves.toEqual(42);
+            expect(connection.query).toBeCalledWith('SELECT COUNT(*) FROM `documents` AS count;');
         });
 
         it('returns the total number of documents of the specified Endpoint', async () => {
@@ -54,17 +54,15 @@ describe('MySqlIndex', () => {
             };
 
             connection.query.mockResolvedValue([[result], []]);
-            const count = await index.getCount('Samples');
-            expect(connection.query).toBeCalledWith('SELECT COUNT(*) FROM `documents` WHERE endpoint = ? AS count', [
+            await expect(index.getCount('Samples')).resolves.toEqual(42);
+            expect(connection.query).toBeCalledWith('SELECT COUNT(*) FROM `documents` WHERE endpoint = ? AS count;', [
                 'Samples',
             ]);
-
-            expect(count).toEqual(42);
         });
     });
 
     describe('getEndpoints', () => {
-        it('returns all registered endpoints', () => {
+        it('returns all registered endpoints', async () => {
             const result: MySqlEndpoint[] = [
                 {
                     constructor: { name: 'RowDataPacket' },
@@ -80,13 +78,216 @@ describe('MySqlIndex', () => {
                 },
             ];
 
-            connection.query.mockResolvedValue([[result], []]);
-            const actual = index.getEndpoints();
-            expect(connection.query).toBeCalledWith('SELECT * FROM `endpoints`');
-            expect(actual).toEqual([
+            connection.query.mockResolvedValue([result, []]);
+            await expect(index.getEndpoints()).resolves.toEqual([
                 { name: 'Endpoint 1', url: 'http://endpoint1.com', type: 'AAS_API' },
                 { name: 'Endpoint 2', url: 'http://endpoint2.com', type: 'AAS_API' },
             ]);
+
+            expect(connection.query).toBeCalledWith('SELECT * FROM `endpoints`;');
+        });
+    });
+
+    describe('getEndpoint', () => {
+        it('returns the endpoint with the specified name', async () => {
+            const result: MySqlEndpoint = {
+                constructor: { name: 'RowDataPacket' },
+                name: 'Endpoint 1',
+                url: 'http://endpoint1.com',
+                type: 'AAS_API',
+            };
+
+            connection.query.mockResolvedValue([[result], []]);
+            const actual = await index.getEndpoint('Endpoint 1');
+            expect(connection.query).toBeCalledWith('SELECT * FROM `endpoints` WHERE name = ?;', ['Endpoint 1']);
+            expect(actual).toEqual({ name: 'Endpoint 1', url: 'http://endpoint1.com', type: 'AAS_API' });
+        });
+
+        it('throws an error if endpoint does not exist', async () => {
+            connection.query.mockResolvedValue([[], []]);
+            await expect(index.getEndpoint('Unknown')).rejects.toThrowError();
+            expect(connection.query).toBeCalledWith('SELECT * FROM `endpoints` WHERE name = ?;', ['Unknown']);
+        });
+    });
+
+    describe('hasEndpoint', () => {
+        it('indicates that Endpoint 1 exists', async () => {
+            const result: MySqlEndpoint = {
+                constructor: { name: 'RowDataPacket' },
+                name: 'Endpoint 1',
+                url: 'http://endpoint1.com',
+                type: 'AAS_API',
+            };
+
+            connection.query.mockResolvedValue([[result], []]);
+            await expect(index.hasEndpoint('Endpoint 1')).resolves.toEqual(true);
+            expect(connection.query).toBeCalledWith('SELECT * FROM `endpoints` WHERE name = ?;', ['Endpoint 1']);
+        });
+
+        it('indicates that Unknown does not exist', async () => {
+            connection.query.mockResolvedValue([[], []]);
+            await expect(index.hasEndpoint('Endpoint 1')).resolves.toEqual(false);
+            expect(connection.query).toBeCalledWith('SELECT * FROM `endpoints` WHERE name = ?;', ['Endpoint 1']);
+        });
+    });
+
+    describe('addEndpoint', () => {
+        it('adds a new Endpoint', async () => {
+            const endpoint: AASEndpoint = {
+                name: 'Endpoint 1',
+                url: 'http://endpoint1.com',
+                type: 'AAS_API',
+            };
+
+            await expect(index.addEndpoint(endpoint)).resolves.toEqual(void 0);
+            expect(connection.query).toHaveBeenLastCalledWith(
+                'INSERT INTO `endpoints` (name, url, type, version, headers) VALUES (?, ?, ?, ?, ?);',
+                [endpoint.name, endpoint.url, endpoint.type, undefined, undefined],
+            );
+        });
+    });
+
+    describe('removeEndpoint', () => {
+        it('removes the specified endpoint', async () => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const impl: any = (sql: string): Promise<any> => {
+                if (sql === 'DELETE FROM `endpoints` WHERE name = ?;') {
+                    return Promise.resolve([
+                        {
+                            constructor: { name: 'ResultSetHeader' },
+                            affectedRows: 1,
+                            fieldCount: 0,
+                            info: '',
+                            insertId: 0,
+                            serverStatus: 0,
+                            warningStatus: 0,
+                            changedRows: 0,
+                        },
+                    ]);
+                }
+
+                if (sql === 'SELECT * FROM `documents` WHERE endpoint = ?;') {
+                    return Promise.resolve([[{ uuid: 'uuid1' }]]);
+                }
+
+                if (sql === 'DELETE FROM `documents` WHERE endpoint = ?;') {
+                    return Promise.resolve();
+                }
+
+                if (sql === 'DELETE FROM `elements` WHERE uuid = ?;') {
+                    return Promise.resolve();
+                }
+
+                return Promise.reject(new Error(`Unexpected sql: ${sql}`));
+            };
+
+            connection.query.mockImplementation(impl);
+            await expect(index.removeEndpoint('Endpoint 1')).resolves.toEqual(true);
+            expect(connection.query).toHaveBeenCalledTimes(4);
+        });
+    });
+
+    describe('getDocuments', () => {
+        it.todo('gets the first');
+    });
+
+    describe('nextPage', () => {
+        it('selects the first page', async () => {
+            const results: MySqlDocument[] = [];
+            connection.query.mockResolvedValue([results, []]);
+            await expect(index.nextPage('Endpoint 1', undefined, 10)).resolves.toEqual({
+                paging_metadata: { cursor: undefined },
+                result: [],
+            });
+
+            expect(connection.query).toHaveBeenLastCalledWith(
+                'SELECT * FROM `documents` WHERE endpoint = ? ORDER BY id ASC LIMIT ?;',
+                ['Endpoint 1', 11],
+            );
+        });
+    });
+
+    describe('update', () => {
+        it.todo('update');
+    });
+
+    describe('add', () => {
+        it.todo('add');
+    });
+
+    describe('find', () => {
+        it.todo('find');
+    });
+
+    describe('remove', () => {
+        it('removes a document from the index', async () => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const impl: any = (sql: string): Promise<any> => {
+                if (sql === 'SELECT uuid FROM `documents` WHERE endpoint = ? AND id = ?;') {
+                    const results: MySqlDocument[] = [
+                        {
+                            constructor: { name: 'RowDataPacket' },
+                            uuid: '1',
+                            address: '',
+                            crc32: 0,
+                            idShort: 'Shell 1',
+                            readonly: false,
+                            timestamp: 0,
+                            id: 'http://document1/aas',
+                            endpoint: 'Endpoint 1',
+                        },
+                        {
+                            constructor: { name: 'RowDataPacket' },
+                            uuid: '2',
+                            address: '',
+                            crc32: 0,
+                            idShort: 'Shell 2',
+                            readonly: false,
+                            timestamp: 0,
+                            id: 'http://document2/aas',
+                            endpoint: 'Endpoint 1',
+                        },
+                    ];
+
+                    return Promise.resolve([results]);
+                }
+
+                if (sql === 'DELETE FROM `elements` WHERE uuid = ?;') {
+                    return Promise.resolve();
+                }
+
+                if (sql === 'DELETE FROM `documents` WHERE uuid = ?;') {
+                    return Promise.resolve();
+                }
+
+                return Promise.reject(new Error(`Unexpected sql: ${sql}`));
+            };
+
+            connection.query.mockImplementation(impl);
+            await expect(index.remove('Endpoint 1', 'http://document/aas')).resolves.toEqual(true);
+            expect(connection.beginTransaction).toHaveBeenCalled();
+            expect(connection.commit).toHaveBeenCalled();
+        });
+    });
+
+    describe('clear', () => {
+        it('clears the index', async () => {
+            connection.query.mockResolvedValue([[], []]);
+            await expect(index.clear()).resolves.toEqual(void 0);
+            expect(connection.beginTransaction).toHaveBeenCalled();
+            expect(connection.query).toHaveBeenNthCalledWith(1, 'DELETE FROM `elements`;');
+            expect(connection.query).toHaveBeenNthCalledWith(2, 'DELETE FROM `documents`;');
+            expect(connection.query).toHaveBeenNthCalledWith(3, 'DELETE FROM `endpoints`;');
+            expect(connection.commit).toHaveBeenCalled();
+        });
+    });
+
+    describe('reset', () => {
+        it('resets the index', async () => {
+            connection.query.mockResolvedValue([[], []]);
+            await expect(index.reset()).resolves.toEqual(void 0);
+            expect(connection.beginTransaction).toHaveBeenCalled();
+            expect(connection.commit).toHaveBeenCalled();
         });
     });
 });
diff --git a/projects/aas-server/src/test/template/template-storage.spec.ts b/projects/aas-server/src/test/template/template-storage.spec.ts
index 03c33bb0..635c5f18 100644
--- a/projects/aas-server/src/test/template/template-storage.spec.ts
+++ b/projects/aas-server/src/test/template/template-storage.spec.ts
@@ -39,6 +39,7 @@ describe('TemplateStorage', function () {
                 const result: ScanTemplatesResult = {
                     taskId: 1,
                     type: ScanResultType.Update,
+                    start: 0,
                     templates: [
                         {
                             idShort: 'aSubmodel',
diff --git a/projects/aasportal-index/schema.sql b/projects/aasportal-index/schema.sql
index e4ccffd9..5bf4d17f 100644
--- a/projects/aasportal-index/schema.sql
+++ b/projects/aasportal-index/schema.sql
@@ -5,7 +5,8 @@ CREATE TABLE endpoints (
     url VARCHAR(255) UNIQUE NOT NULL,
     type VARCHAR(32) NOT NULL,
     version VARCHAR(8),
-    headers VARCHAR(255)
+    headers VARCHAR(255),
+    schedule VARCHAR(255),
 );
 
 CREATE TABLE documents (