# FileInterface – FileSystemWatcher + CronScheduler



## HTTP-Webclient Login

Der Webclient ist standardmaessig per HTTP Basic Authentication geschuetzt.

```text
Benutzer: admin
Kennwort:  admin
```

Die Zugangsdaten koennen in `FileinterfaceCronScheduler/App.config` geaendert werden:

```xml
<add key="Scheduler.WebUser" value="admin" />
<add key="Scheduler.WebPassword" value="admin" />
```

Wichtig: Fuer den produktiven Betrieb sollte das Standardkennwort geaendert werden.

Eigenständiges Visual-Studio-/C#-Projekt für ereignisbasierte **und** zeitgesteuerte Datei-Verarbeitung über iTAC IMSAPI CustomFunctions.

## Architektur

Beide Mechanismen laufen gleichzeitig und unabhängig voneinander:

```text
HTTP Webclient
   |
   +-- FileSystemWatcher-Konfiguration --> beliebig viele FileSystemWatcher
   |
   +-- Cron-Konfiguration ---------------> beliebig viele Cronjobs
                                                |
                  +-----------------------------+
                  |
            gemeinsame IMSAPI Session
                  |
            customFunction(...)
```

## Enthalten

- `FileinterfaceCronScheduler.sln`
- .NET Framework 4.8 / x86
- Windows-Dienst und Konsolenmodus
- enthaltene `IMSApiDotNet.dll` Version 10.0.0-3
- IMSAPI Initialisierung und `regLogin(...)`
- beliebig viele FileSystemWatcher
- beliebig viele Cronjobs
- zentrale HTTP-Administration
- beliebig viele `inArgs` pro Watcher/Cronjob
- eigene CustomFunction pro Watcher/Cronjob
- Datei nach Erfolg optional verschieben
- Laufzeit-Log und Status im Browser

## HTTP Webclient

Standard:

```text
http://127.0.0.1:8095/
```

Für Zugriff aus dem Netzwerk in `App.config`:

```xml
<add key="Scheduler.WebPrefix" value="http://+:8095/" />
```

Danach `scripts\allow-webinterface-network.bat` als Administrator ausführen. Für Netzwerkzugriff sollten `Scheduler.WebUser` und `Scheduler.WebPassword` gesetzt werden.

Der Webclient besitzt zwei Bereiche:

### FileSystemWatcher

Pro Watcher konfigurierbar:

- Aktiv / Inaktiv
- Quellverzeichnis
- Dateifilter, z. B. `*.xml`
- Unterverzeichnisse
- Events `Created`, `Changed`, `Renamed`
- Debounce in Millisekunden
- File-Ready Wiederholungen / Wartezeit
- CustomFunction
- beliebig viele `inArgs`
- leere Zeilen entfernen
- Zeilentrenner
- Datei nach Erfolg verschieben Ja/Nein
- Zielverzeichnis
- bestehende Zieldatei überschreiben Ja/Nein
- vorhandene Dateien manuell verarbeiten
- Watcher ohne Dienstneustart neu laden

Änderungen werden beim Speichern sofort persistent geschrieben und die FileSystemWatcher werden automatisch neu aufgebaut.

### CronScheduler

Pro Cronjob konfigurierbar:

- Aktiv / Inaktiv
- Cron-Ausdruck mit 5 Feldern
- optional CustomFunction ohne Datei aufrufen
- Quellverzeichnis / Filter / Unterverzeichnisse
- CustomFunction
- beliebig viele `inArgs`
- Datei nach Erfolg verschieben Ja/Nein
- manuell `Jetzt ausführen`

Beispiele:

```text
*/5 * * * *
0 */2 * * *
15 2 * * *
0 6 * * 1-5
```

## Platzhalter

Für Watcher und Cronjobs:

```text
{{CONTENT}}
{{RAW_CONTENT}}
{{FILE_NAME}}
{{FILE_PATH}}
{{FILE_DIR}}
{{FILE_EXT}}
{{JOB_NAME}}
{{NOW}}
```

Nur beim FileSystemWatcher zusätzlich:

```text
{{EVENT}}
```

`{{EVENT}}` enthält z. B. `Created`, `Changed`, `Renamed` oder `ManualScan`.

## Persistente Konfiguration

Die Jobs sind getrennt gespeichert:

```text
cronjobs.json
watcherjobs.json
```

Pfade können in `App.config` geändert werden:

```xml
<add key="Scheduler.ConfigFile" value="cronjobs.json" />
<add key="Watcher.ConfigFile" value="watcherjobs.json" />
```

## IMSAPI

`IMSApiDotNet.dll` liegt bereits unter:

```text
FileinterfaceCronScheduler\lib\IMSApiDotNet.dll
```

Beim Programmstart:

1. `IMSApiDotNet.setProperty(...)`
2. `IMSApiDotNet.loadLibrary()`
3. `imsapiInit()`
4. `regLogin(...)`
5. Start FileSystemWatcher + CronScheduler + HTTP-Webclient

Die Aufrufe verwenden anschließend dieselbe Session:

```csharp
imsapi.customFunction(
    sessionContext,
    customFunctionName,
    inArgs,
    out outArgs,
    out customErrorString
);
```

## IMS-Konfiguration

In `FileinterfaceCronScheduler\App.config`:

```xml
<add key="IMS.AppID" value="FileInterfaceCronScheduler" />
<add key="IMS.ServerUrl" value="http://YOUR-IMS-SERVER:PORT" />
<add key="IMS.StationNumber" value="YOUR_STATION" />
<add key="IMS.ClientNumber" value="1" />
<add key="IMS.RegistrationType" value="S" />
<add key="IMS.PropertyDirectory" value="." />
<add key="IMS.SerializeCalls" value="false" />
```

`IMS.SerializeCalls=false` erlaubt unabhängigen Watchern und Cronjobs parallele CustomFunction-Aufrufe. Wenn die eingesetzte IMSAPI-Umgebung das nicht verträgt, kann auf `true` gestellt werden.

## Visual Studio

1. `FileinterfaceCronScheduler.sln` öffnen.
2. `App.config` konfigurieren.
3. Build `Debug` oder `Release`; das Projekt kompiliert als x86.
4. Starten.
5. Browser auf `http://127.0.0.1:8095/` öffnen.

## Windows-Dienst

Unter `scripts`:

- `install-service.bat`
- `uninstall-service.bat`
- `allow-webinterface-network.bat`

Vor der Dienstinstallation zuerst Release bauen.