# Many-to-Many Junction-Tabelle mit additionalColumns - Testergebnisse

**Version:** 2.0  
**Datum:** 11. März 2026  
**Status:** ✅ VOLLSTÄNDIG ERFOLGREICH mit UI-Integration

## ✅ VOLLSTÄNDIG ERFOLGREICH!

**UPDATE (März 2026):** Die Junction-Tabelle kann als eigene Entity via REST-API abgerufen werden! Seit EspoCRM 6.0.0 werden Junction-Tabellen automatisch als Entities verfügbar gemacht.

**NEU:** UI-Anzeige von Junction-Spalten via columnAttributeMap + notStorable Pattern!

## Zusammenfassung

Die Implementierung einer Many-to-Many-Beziehung mit zusätzlichen Feldern in der Junction-Tabelle wurde erfolgreich getestet und ist:
- **vollständig funktionsfähig via REST-API**
- **im UI anzeigbar via columnAttributeMap Pattern**
- **automatisch aktualisierbar via Hooks**

## ✅ Was funktioniert

### 1. Datenbank-Schema
**Status: VOLLSTÄNDIG FUNKTIONSFÄHIG**

Die Junction-Tabelle `c_a_i_collection_c_dokumente` wurde automatisch mit der zusätzlichen `sync_id`-Spalte erstellt:

```sql
CREATE TABLE `c_a_i_collection_c_dokumente` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `c_a_i_collections_id` varchar(17),
  `c_dokumente_id` varchar(17),
  `sync_id` varchar(255),  ← Unser custom Feld!
  `deleted` tinyint(1) DEFAULT 0,
  PRIMARY KEY (`id`),
  UNIQUE KEY `UNIQ_C_A_I_COLLECTIONS_ID_C_DOKUMENTE_ID` (...)
)
```

### 2. Junction-Entity via REST-API
**Status: ✅ VOLLSTÄNDIG FUNKTIONSFÄHIG**

Die Junction-Tabelle ist als eigene Entity `CAICollectionCDokumente` via REST-API verfügbar!

**Beispiel-Abruf:**
```bash
GET /api/v1/CAICollectionCDokumente?maxSize=10
```

**Response:**
```json
{
  "total": 5,
  "list": [
    {
      "id": "6",
      "deleted": false,
      "cAICollectionsId": "testcol999",
      "cDokumenteId": "testdoc999",
      "syncId": "SYNC-TEST-999",
      "cAICollectionsName": null,
      "cDokumenteName": null
    }
  ]
}
```

**✅ Die `syncId` ist direkt in der API-Response enthalten!**

### 3. Filterung und Suche
**Status: ✅ FUNKTIONIERT PERFEKT**

Alle Standard-API-Features funktionieren:

**Nach Dokument-ID filtern:**
```bash
GET /api/v1/CAICollectionCDokumente?where[0][type]=equals&where[0][attribute]=cDokumenteId&where[0][value]=doc123
```

**Nach syncId suchen:**
```bash
GET /api/v1/CAICollectionCDokumente?where[0][type]=equals&where[0][attribute]=syncId&where[0][value]=SYNC-123
```

**Felder selektieren:**
```bash
GET /api/v1/CAICollectionCDokumente?select=id,cDokumenteId,cAICollectionsId,syncId
```

### 4. Konfiguration
**Status: KORREKT IMPLEMENTIERT**

**Erforderliche Dateien:**

**1. Entity-Definition** (`entityDefs/CAICollectionCDokumente.json`):
```json
{
    "fields": {
        "id": {"type": "id", "dbType": "bigint", "autoincrement": true},
        "cAICollections": {"type": "link"},
        "cAICollectionsId": {"type": "varchar", "len": 17, "index": true},
        "cDokumente": {"type": "link"},
        "cDokumenteId": {"type": "varchar", "len": 17, "index": true},
        "syncId": {"type": "varchar", "len": 255, "isCustom": true},
        "deleted": {"type": "bool", "default": false}
    },
    "links": {
        "cAICollections": {
            "type": "belongsTo",
            "entity": "CAICollections"
        },
        "cDokumente": {
            "type": "belongsTo",
            "entity": "CDokumente"
        }
    }
}
```

**2. Scope-Definition** (`scopes/CAICollectionCDokumente.json`):
```json
{
    "entity": true,
    "type": "Base",
    "module": "Custom",
    "object": true,
    "isCustom": true,
    "tab": false,
    "acl": true,
    "disabled": false
}
```

**3. Controller** (`Controllers/CAICollectionCDokumente.php`):
```php
<?php
namespace Espo\Custom\Controllers;
use Espo\Core\Controllers\Record;

class CAICollectionCDokumente extends Record
{
    // Erbt alle CRUD-Operationen
}
```

**4. Service** (`Services/CAICollectionCDokumente.php`):
```php
<?php
namespace Espo\Custom\Services;
use Espo\Services\Record;

class CAICollectionCDokumente extends Record
{
    // Standard-Logik
}
```

**5. Many-to-Many-Beziehung in CDokumente.json:**
```json
"cAICollections": {
    "type": "hasMany",
    "entity": "CAICollections",
    "foreign": "cDokumente",
    "relationName": "cAICollectionCDokumente",
    "additionalColumns": {
        "syncId": {
            "type": "varchar",
            "len": 255
        }
    }
}
```

**6. ACL-Berechtigungen:**
Die Rolle muss Zugriff auf die Junction-Entity haben:
```json
{
  "CAICollectionCDokumente": {
    "create": "yes",
    "read": "all",
    "edit": "all",
    "delete": "all"
  }
}
```

## 💡 Verwendung

### Beispiel 1: Alle Verknüpfungen eines Dokuments abrufen

**Python:**
```python
import requests

response = requests.get(
    "https://your-crm.com/api/v1/CAICollectionCDokumente",
    headers={"X-Api-Key": "your-api-key"},
    params={
        "where[0][type]": "equals",
        "where[0][attribute]": "cDokumenteId",
        "where[0][value]": "doc123",
        "select": "cAICollectionsId,syncId"
    }
)

data = response.json()
for item in data['list']:
    print(f"Collection: {item['cAICollectionsId']}, SyncID: {item['syncId']}")
```

**cURL:**
```bash
curl "https://your-crm.com/api/v1/CAICollectionCDokumente?where[0][type]=equals&where[0][attribute]=cDokumenteId&where[0][value]=doc123" \
  -H "X-Api-Key: your-api-key"
```

### Beispiel 2: Dokument in Collection via syncId finden

```python
response = requests.get(
    "https://your-crm.com/api/v1/CAICollectionCDokumente",
    headers={"X-Api-Key": "your-api-key"},
    params={
        "where[0][type]": "equals",
        "where[0][attribute]": "syncId",
        "where[0][value]": "SYNC-external-id-123"
    }
)

if response.json()['list']:
    match = response.json()['list'][0]
    doc_id = match['cDokumenteId']
    col_id = match['cAICollectionsId']
    print(f"Found: Document {doc_id} in Collection {col_id}")
```

### Beispiel 3: Neue Verknüpfung mit syncId erstellen

**Via Standard-API (POST):**
```python
# Erstelle Verknüpfung
response = requests.post(
    "https://your-crm.com/api/v1/CAICollectionCDokumente",
    headers={"X-Api-Key": "your-api-key"},
    json={
        "cDokumenteId": "doc123",
        "cAICollectionsId": "col456",
        "syncId": "SYNC-2026-001"
    }
)
```

### Beispiel 4: syncId aktualisieren

```python
# Aktualisiere einen bestehenden Eintrag
response = requests.put(
    f"https://your-crm.com/api/v1/CAICollectionCDokumente/{junction_id}",
    headers={"X-Api-Key": "your-api-key"},
    json={
        "syncId": "SYNC-UPDATED-002"
    }
)
```

## 📊 Test-Ergebnisse

| Feature | Status | Notizen |
|---------|--------|---------|
| Junction-Tabelle Erstellung | ✅ | Automatisch mit syncId-Spalte |
| Junction-Entity via API | ✅ | Vollständig funktionsfähig |
| syncId in API-Response | ✅ | Direkt verfügbar |
| Filterung (where) | ✅ | Standard-API-Syntax |
| Sortierung (orderBy) | ✅ | Funktioniert |
| Paginierung (maxSize, offset) | ✅ | Funktioniert |
| CREATE via API | ✅ | POST mit allen Feldern |
| UPDATE via API | ✅ | PUT zum Ändern von syncId |
| DELETE via API | ✅ | Standard-DELETE |
| View-Darstellung | ❌ | Nicht empfohlen - verursacht 405 Fehler |

## ⚠️ UI-Panel Warnung

**WICHTIG:** additionalColumns sollten NICHT in Standard-Relationship-Panels angezeigt werden!

**Problem:**
- Standard relationship panels versuchen inline-editing
- Dies führt zu 405 Method Not Allowed Fehlern
- additionalColumns sind nicht kompatibel mit Standard-Panel-Architektur

**Empfehlung:**
- ✅ Nutze API-only Access Pattern
- ✅ Vollständige CRUD via `/api/v1/CAICollectionCDokumente`
- ❌ NICHT in CDokumente detail view als relationship panel anzeigen

## ✅ LÖSUNG: UI-Anzeige via columnAttributeMap + notStorable

**UPDATE (März 2026):** Es gibt eine Working-Solution für UI-Anzeige von Junction-Spalten!

**Pattern:** columnAttributeMap + notStorable Felder

### Konzept

1. **notStorable Felder** im Parent: Placeholder für Junction-Spalten
2. **columnAttributeMap** in Links: Bidirektionales Mapping
3. **Custom List Layouts**: Zeigt notStorable Felder an
4. EspoCRM synchronisiert automatisch zwischen Junction-Table und notStorable Feldern

### Implementierung: CAdvowareAkten ↔ CDokumente

**CAdvowareAkten.json:**
```json
{
  "fields": {
    "dokumenteHnr": {
      "type": "int",
      "notStorable": true,
      "utility": true
    },
    "dokumenteSyncstatus": {
      "type": "enum",
      "options": ["new", "unclean", "synced", "failed"],
      "notStorable": true,
      "utility": true
    },
    "dokumenteLastSync": {
      "type": "datetime",
      "notStorable": true,
      "utility": true
    },
    "dokumentes": {
      "type": "linkMultiple",
      "columns": {
        "hnr": "advowareAktenHnr",
        "syncstatus": "advowareAktenSyncstatus",
        "lastSync": "advowareAktenLastSync"
      },
      "view": "views/fields/link-multiple-with-columns"
    }
  },
  "links": {
    "dokumentes": {
      "type": "hasMany",
      "entity": "CDokumente",
      "foreign": "advowareAktens",
      "relationName": "cAdvowareAktenDokumente",
      "additionalColumns": {
        "hnr": {"type": "int"},
        "syncstatus": {"type": "varchar", "len": 20},
        "lastSync": {"type": "datetime"}
      },
      "columnAttributeMap": {
        "hnr": "dokumenteHnr",
        "syncstatus": "dokumenteSyncstatus",
        "lastSync": "dokumenteLastSync"
      }
    }
  }
}
```

**CDokumente.json (Foreign Side):**
```json
{
  "fields": {
    "advowareAktenHnr": {
      "type": "int",
      "notStorable": true,
      "utility": true,
      "layoutAvailabilityList": ["listForAdvowareAkten"]
    },
    "advowareAktenSyncstatus": {
      "type": "varchar",
      "notStorable": true,
      "utility": true,
      "layoutAvailabilityList": ["listForAdvowareAkten"]
    },
    "advowareAktenLastSync": {
      "type": "datetime",
      "notStorable": true,
      "utility": true,
      "layoutAvailabilityList": ["listForAdvowareAkten"]
    }
  },
  "links": {
    "advowareAktens": {
      "type": "hasMany",
      "entity": "CAdvowareAkten",
      "foreign": "dokumentes",
      "relationName": "cAdvowareAktenDokumente",
      "columnAttributeMap": {
        "hnr": "advowareAktenHnr",
        "syncstatus": "advowareAktenSyncstatus",
        "lastSync": "advowareAktenLastSync"
      }
    }
  }
}
```

**Custom List Layout (layouts/CDokumente/listForAdvowareAkten.json):**
```json
[
  {"name": "name", "width": 25},
  {"name": "advowareAktenHnr", "width": 10},
  {"name": "advowareAktenSyncstatus", "width": 12},
  {"name": "advowareAktenLastSync", "width": 15},
  {"name": "description", "width": 20}
]
```

**Bottom Panel (layouts/CAdvowareAkten/bottomPanelsDetail.json):**
```json
[
  {
    "name": "dokumentes",
    "label": "Dokumente",
    "view": "views/record/panels/relationship",
    "layout": "listForAdvowareAkten",
    "index": 1
  }
]
```

### Wie es funktioniert

1. **Lesen:** EspoCRM lädt Junction-Spalten via RDB und mapped sie zu notStorable Feldern
2. **Anzeigen:** Custom List Layout zeigt notStorable Felder an
3. **Schreiben:** Updates via Hooks mit `updateColumns()`
4. **Bidirektional:** columnAttributeMap muss auf beiden Seiten existieren

### Beispiel: Hook für Auto-Update

```php
<?php
namespace Espo\Custom\Hooks\CAdvowareAkten;

use Espo\ORM\Entity;
use Espo\Core\Hook\Hook\AfterRelate;

class DokumenteSyncStatus implements AfterRelate
{
    public function __construct(
        private \Espo\ORM\EntityManager $entityManager
    ) {}
    
    public function afterRelate(
        Entity $entity,
        string $relationName,
        Entity $foreignEntity,
        array $columnData,
        \Espo\ORM\Repository\Option\RelateOptions $options
    ): void {
        if ($relationName !== 'dokumentes') {
            return;
        }
        
        // Setze Junction-Spalten via updateColumns()
        $repository = $this->entityManager->getRDBRepository('CAdvowareAkten');
        $repository->getRelation($entity, 'dokumentes')->updateColumns(
            $foreignEntity,
            [
                'syncstatus' => 'new',
                'lastSync' => null
            ]
        );
    }
}
```

### Vorteile dieser Lösung

✅ **UI-Anzeige**: Junction-Spalten sichtbar in Relationship-Panels  
✅ **Kein 405 Fehler**: Read-only Darstellung vermeidet Inline-Edit-Probleme  
✅ **API-Kompatibel**: Funktioniert parallel zur Junction-Entity-API  
✅ **Bidirektional**: Funktioniert von beiden Seiten der Beziehung  
✅ **Hook-Integration**: Updates via Hooks möglich  

### Einschränkungen

⚠️ **notStorable = Read-only in UI**: Keine direkte Bearbeitung im Panel  
⚠️ **Updates via Hooks**: Änderungen müssen über Hooks oder API erfolgen  
⚠️ **layoutAvailabilityList**: Foreign-Side-Felder nur in Custom Layouts sichtbar  

## 🎯 Fazit

Die **Junction-Tabelle mit `additionalColumns` ist vollständig via REST-API nutzbar**! 

**Vorteile:**
- ✅ Keine Custom-Endpoints nötig
- ✅ Standard-API-Features (Filter, Sort, Pagination)
- ✅ CRUD-Operationen vollständig unterstützt
- ✅ `syncId` ist direkt in der Response
- ✅ Einfache Integration in externe Systeme
- ✅ API-only Pattern verhindert 405-Fehler

**Einschränkungen:**
- ⚠️ UI-Darstellung in Standard-Relationship-Panels verursacht 405 Fehler
- ⚠️ additionalColumns nur über Junction-Entity-API zugänglich
- ⚠️ Standard relationship endpoints (z.B. GET /api/v1/CDokumente/{id}/cAICollections) geben additionalColumns NICHT zurück

**Best Practice:**
1. ✅ Junction Entity als API-Endpoint nutzen (`/api/v1/CAICollectionCDokumente`)
2. ✅ Keine UI-Panels für Junction-Relationships mit additionalColumns
3. ✅ API-Integration für externe Systeme (Middleware, KI, etc.)
4. ✅ Bei Bedarf: Separate Management-UI für Junction Entity (ohne Relationship-Panel)

**Wichtig:**
1. Controller und Service erstellen
2. Scope-Definition anlegen
3. Entity-Definition mit korrekten Feldtypen
4. ACL-Rechte für die Junction-Entity setzen
5. Cache löschen und rebuild
6. **NICHT** als Relationship-Panel in UI anzeigen (→ 405 Fehler)

## 📁 Dateien

Die Implementierung befindet sich in:
- `/custom/Espo/Custom/Resources/metadata/entityDefs/CAICollectionCDokumente.json`
- `/custom/Espo/Custom/Resources/metadata/scopes/CAICollectionCDokumente.json`
- `/custom/Espo/Custom/Controllers/CAICollectionCDokumente.php`
- `/custom/Espo/Custom/Services/CAICollectionCDokumente.php`
- `/custom/Espo/Custom/Resources/metadata/entityDefs/CDokumente.json` (mit additionalColumns)
- `/custom/Espo/Custom/Resources/metadata/entityDefs/CAICollections.json`

Datenbank-Tabelle:
- `c_a_i_collection_c_dokumente`

---

**Erstellt:** 9. März 2026  
**Getestet mit:** EspoCRM 9.3.2 (MariaDB 12.2.2, PHP 8.2.30)  
**API-User für Tests:** marvin (API-Key: e53def10eea27b92a6cd00f40a3e09a4)  
**Entity-Name:** CAICollectionCDokumente  
**API-Endpoint:** `/api/v1/CAICollectionCDokumente`


### 1. Datenbank-Schema
**Status: VOLLSTÄNDIG FUNKTIONSFÄHIG**

Die Junction-Tabelle `c_a_i_collection_c_dokumente` wurde automatisch mit der zusätzlichen `sync_id`-Spalte erstellt:

```sql
CREATE TABLE `c_a_i_collection_c_dokumente` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `c_a_i_collections_id` varchar(17),
  `c_dokumente_id` varchar(17),
  `sync_id` varchar(255),  ← Unser custom Feld!
  `deleted` tinyint(1) DEFAULT 0,
  PRIMARY KEY (`id`),
  UNIQUE KEY `UNIQ_C_A_I_COLLECTIONS_ID_C_DOKUMENTE_ID` (...)
)
```

### 2. Konfiguration
**Status: KORREKT IMPLEMENTIERT**

Die Beziehung wurde in beiden Entity-Definitionen konfiguriert:

**CDokumente.json:**
```json
"cAICollections": {
    "type": "hasMany",
    "entity": "CAICollections",
    "foreign": "cDokumente",
    "relationName": "cAICollectionCDokumente",
    "additionalColumns": {
        "syncId": {
            "type": "varchar",
            "len": 255
        }
    }
}
```

**CAICollections.json:**
```json
"cDokumente": {
    "type": "hasMany",
    "entity": "CDokumente",
    "foreign": "cAICollections",
    "relationName": "cAICollectionCDokumente"
}
```

### 3. Datenspeicherung
**Status: FUNKTIONIERT**

Die `syncId` kann in der Datenbank gespeichert werden:
- ✅ Via direktes SQL-INSERT/UPDATE
- ✅ Via interne EspoCRM ORM-API (EntityManager)
- ✅ Daten werden korrekt persistiert

### 4. View-Darstellung
**Status: ⚠️ NICHT EMPFOHLEN (API-ONLY PATTERN)**

**Problem:** Standard EspoCRM Relationship-Panels versuchen inline-editing von Feldern. Bei additionalColumns führt dies zu **405 Method Not Allowed** Fehlern, da die Standard-Panel-UI nicht mit dem Junction-Entity-Pattern kompatibel ist.

**Versucht & Fehlgeschlagen:**
1. ❌ Direct display of syncId in relationship panel layout → 405 Fehler
2. ❌ Custom View mit actionEditLinkData → Blank views, dann weiter 405 Fehler
3. ❌ Simplified relationship layout ohne syncId → 405 Fehler blieben bestehen

**ROOT CAUSE:** Standard relationship panels senden HTTP-Requests die nicht mit Junction-Entity-Architektur übereinstimmen. additionalColumns erfordern spezielle Behandlung die nicht durch Standard-UI bereitgestellt wird.

**LÖSUNG:** API-ONLY Access Pattern
- ✅ Vollständige CRUD via `/api/v1/CAICollectionCDokumente`
- ✅ Kein UI-Panel in CDokumente → keine 405 Fehler
- ✅ Alle Funktionen über REST API verfügbar
- ✅ Perfekt für externe Systeme und Middleware

**Falls UI Display gewünscht:**
- Option: Custom Panel das direkt die Junction Entity list-view lädt (gefiltert nach documentId)
- Option: Separate Tab/Page für Junction Entity-Management
- Nicht empfohlen: Standard relationship panel mit additionalColumns

## ❌ Was NICHT funktioniert

### REST-API gibt keine additionalColumns zurück
**Status: LIMITATION DER STANDARD-API**

**Das Problem:**
Die Standard-EspoCRM REST-API gibt die `additionalColumns` **nicht** zurück, wenn Beziehungen abgerufen werden.

**Getestete Szenarien:**
1. ❌ Standard GET-Request: `GET /api/v1/CDokumente/{id}/cAICollections` → keine `syncId` in Response
2. ❌ Mit Query-Parametern (select, additionalColumns, columns, etc.) → keine `syncId`
3. ❌ POST mit columns-Parameter beim Verknüpfen → wird nicht gespeichert

**Verifiziert:**
```bash
# syncId ist in DB:
SELECT * FROM c_a_i_collection_c_dokumente;
# → sync_id = 'SYNC-20260309-220416'

# Aber API-Response enthält sie nicht:
GET /api/v1/CDokumente/{id}/cAICollections
# → {"list": [{"id": "...", "name": "...", ...}]}  # Keine syncId!
```

## 💡 Lösungen & Workarounds

### Option 1: Interne PHP-API verwenden (Empfohlen)
Verwende die interne EspoCRM-API für den Zugriff auf `additionalColumns`:

```php
$entityManager = $container->get('entityManager');
$doc = $entityManager->getEntity('CDokumente', $docId);
$repository = $entityManager->getRDBRepository('CDokumente');
$relation = $repository->getRelation($doc, 'cAICollections');

// Lade verknüpfte Collections
$collections = $relation->find();

// Hole additionalColumns
foreach ($collections as $col) {
    $relationData = $relation->getColumnAttributes($col, ['syncId']);
    $syncId = $relationData['syncId'] ?? null;
    echo "syncId: $syncId\n";
}

// Setze syncId beim Verknüpfen
$relation->relateById($collectionId, [
    'syncId' => 'your-sync-id-value'
]);
```

### Option 2: Custom API-Endpoint erstellen
Erstelle einen eigenen API-Endpoint, der die `additionalColumns` zurückgibt:

```php
// custom/Espo/Custom/Controllers/CDokumente.php
public function getActionRelatedCollectionsWithSyncId($params, $data, $request)
{
    $id = $params['id'];
    $em = $this->getEntityManager();
    $doc = $em->getEntity('CDokumente', $id);
    
    $repo = $em->getRDBRepository('CDokumente');
    $relation = $repo->getRelation($doc, 'cAICollections');
    
    $result = [];
    foreach ($relation->find() as $col) {
        $relationData = $relation->getColumnAttributes($col, ['syncId']);
        $result[] = [
            'id' => $col->getId(),
            'name' => $col->get('name'),
            'syncId' => $relationData['syncId'] ?? null
        ];
    }
    
    return ['list' => $result];
}
```

Dann abrufen via:
```bash
GET /api/v1/CDokumente/{id}/relatedCollectionsWithSyncId
```

### Option 3: Direkte Datenbank-Abfrage
Für einfache Szenarien kann man die Junction-Tabelle direkt abfragen:

```php
$pdo = $entityManager->getPDO();
$stmt = $pdo->prepare("
    SELECT c.*, j.sync_id 
    FROM c_a_i_collections c
    JOIN c_a_i_collection_c_dokumente j 
        ON c.id = j.c_a_i_collections_id
    WHERE j.c_dokumente_id = ? 
        AND j.deleted = 0 
        AND c.deleted = 0
");
$stmt->execute([$docId]);
$results = $stmt->fetchAll(PDO::FETCH_ASSOC);
```

### Option 4: Formulas für automatische Synchronisation
Nutze EspoCRM-Formulas um `syncId` zu setzen:

```
// In CDokumente.json oder als Workflow
entity\setLinkMultipleColumn('cAICollections', collectionId, 'syncId', 'your-value');
```

## 📊 Test-Ergebnisse

| Feature | Status | Notizen |
|---------|--------|---------|
| Junction-Tabelle Erstellung | ✅ | Automatisch mit syncId-Spalte |
| additionalColumns in Entity-Defs | ✅ | Korrekt konfiguriert |
| syncId in Datenbank speichern | ✅ | Via SQL oder interne API |
| syncId über REST-API setzen | ❌ | Wird ignoriert |
| syncId über REST-API abrufen | ❌ | Nicht in Response |
| syncId über interne API | ✅ | Vollständig funktionsfähig |
| View-Darstellung | ✅* | Möglich, aber manuell konfigurieren |

*) Benötigt manuelle Layout-Konfiguration

## 🎯 Fazit

Die **technische Implementierung der Many-to-Many-Beziehung mit `additionalColumns` funktioniert einwandfrei**. Die Datenbank-Struktur ist korrekt, Daten können gespeichert und abgerufen werden.

**Jedoch:** Die Standard-REST-API von EspoCRM gibt diese zusätzlichen Felder nicht zurück. Für den produktiven Einsatz sollte einer der oben beschriebenen Workarounds verwendet werden - am besten **Option 1** (interne PHP-API) oder **Option 2** (Custom-Endpoint).

## 📁 Dateien

Die Konfiguration befindet sich in:
- `/custom/Espo/Custom/Resources/metadata/entityDefs/CDokumente.json`
- `/custom/Espo/Custom/Resources/metadata/entityDefs/CAICollections.json`

Datenbank-Tabelle:
- `c_a_i_collection_c_dokumente`

## 🔧 Verwendung

### Beispiel: Dokument in Collection mit Sync-ID einfügen (PHP)

```php
$entityManager = $container->get('entityManager');

// Entities laden
$doc = $entityManager->getEntity('CDokumente', $docId);
$collection = $entityManager->getEntity('CAICollections', $collectionId);

// Verknüpfen mit syncId
$repo = $entityManager->getRDBRepository('CDokumente');
$relation = $repo->getRelation($doc, 'cAICollections');
$relation->relateById($collectionId, [
    'syncId' => 'my-unique-sync-id-123'
]);

// SyncId auslesen
$relationData = $relation->getColumnAttributes($collection, ['syncId']);
echo $relationData['syncId']; // 'my-unique-sync-id-123'
```

### Beispiel: Dokument in Collection finden via Sync-ID

```sql
SELECT c_dokumente_id, c_a_i_collections_id, sync_id
FROM c_a_i_collection_c_dokumente
WHERE sync_id = 'my-unique-sync-id-123'
  AND deleted = 0;
```

---

**Erstellt:** 9. März 2026  
**Getestet mit:** EspoCRM (MariaDB 12.2.2, PHP 8.2.30)  
**API-User für Tests:** marvin (API-Key: e53def10eea27b92a6cd00f40a3e09a4)