feat: Implement bidirectional synchronization utilities for Advoware and EspoCRM communications
- Added KommunikationSyncManager class to handle synchronization logic. - Implemented methods for loading data, computing diffs, and applying changes between Advoware and EspoCRM. - Introduced 3-way diffing mechanism to intelligently resolve conflicts. - Added helper methods for creating empty slots and detecting changes in communications. - Enhanced logging for better traceability during synchronization processes.
This commit is contained in:
319
bitbylaw/services/KOMMUNIKATION_SYNC_README.md
Normal file
319
bitbylaw/services/KOMMUNIKATION_SYNC_README.md
Normal file
@@ -0,0 +1,319 @@
|
||||
# Kommunikation Sync Implementation
|
||||
|
||||
## Overview
|
||||
|
||||
Bidirektionale Synchronisation von Email- und Telefon-Daten zwischen Advoware und EspoCRM.
|
||||
|
||||
## Architektur-Übersicht
|
||||
|
||||
```
|
||||
┌─────────────────────────────────────────────────────────────────┐
|
||||
│ Advoware ↔ EspoCRM Sync │
|
||||
├─────────────────────────────────────────────────────────────────┤
|
||||
│ │
|
||||
│ ADVOWARE ESPOCRM │
|
||||
│ ───────────────── ────────────────── │
|
||||
│ Beteiligte CBeteiligte │
|
||||
│ └─ kommunikation[] ├─ emailAddressData[] │
|
||||
│ ├─ id (unique int) │ └─ emailAddress │
|
||||
│ ├─ rowId (string) │ lower, primary │
|
||||
│ ├─ tlf (value) │ │
|
||||
│ ├─ bemerkung (marker!) └─ phoneNumberData[] │
|
||||
│ ├─ kommKz (1-12) └─ phoneNumber │
|
||||
│ └─ online (bool) type, primary │
|
||||
│ │
|
||||
│ MATCHING: Hash in bemerkung-Marker │
|
||||
│ [ESPOCRM:hash:kommKz] User text │
|
||||
└─────────────────────────────────────────────────────────────────┘
|
||||
```
|
||||
|
||||
## Core Features
|
||||
|
||||
### 1. Base64-basiertes Matching ✅ IMPLEMENTIERT
|
||||
- **Problem**: EspoCRM Arrays haben keine IDs
|
||||
- **Lösung**: Base64-kodierter Wert in Advoware bemerkung
|
||||
- **Format**: `[ESPOCRM:bWF4QGV4YW1wbGUuY29t:4] Geschäftlich`
|
||||
- **Vorteil**: Bidirektional! Marker enthält den tatsächlichen Wert (dekodierbar)
|
||||
|
||||
**Warum Base64 statt Hash?**
|
||||
```python
|
||||
# Hash-Problem (alt): Nicht rückrechenbar
|
||||
old_hash = hash("old@example.com") # abc12345
|
||||
# Bei Wert-Änderung in Advoware: Kein Match möglich! ❌
|
||||
|
||||
# Base64-Lösung (neu): Bidirektional
|
||||
encoded = base64("old@example.com") # b2xkQGV4YW1wbGUuY29t
|
||||
decoded = decode(encoded) # "old@example.com" ✅
|
||||
# Kann dekodieren → Match in EspoCRM finden!
|
||||
```
|
||||
|
||||
### 2. 4-Stufen Typ-Erkennung
|
||||
```python
|
||||
1. Aus Marker: [ESPOCRM:hash:3] → kommKz=3 (Mobil)
|
||||
2. Aus Top-Level: beteiligte.mobil → kommKz=3
|
||||
3. Aus Pattern: '@' in value → kommKz=4 (Email)
|
||||
4. Default: Fallback → kommKz=1 oder 4
|
||||
```
|
||||
|
||||
### 3. Empty Slot System
|
||||
- **Problem**: DELETE ist 403 Forbidden in Advoware
|
||||
- **Lösung**: Leere Slots mit `[ESPOCRM-SLOT:kommKz]`
|
||||
- **Wiederverwendung**: Neue Einträge reuse leere Slots
|
||||
|
||||
### 4. Asymmetrischer Sync
|
||||
|
||||
**Problem**: Hash-basiertes Matching funktioniert NICHT bidirektional
|
||||
- Wenn Wert in Advoware ändert: Hash ändert sich → Kein Match in EspoCRM möglich
|
||||
|
||||
**Lösung**: Verschiedene Strategien je Richtung
|
||||
|
||||
| Richtung | Methode | Grund |
|
||||
|----------|---------|-------|
|
||||
| **Advoware → EspoCRM** | FULL SYNC (kompletter Overwrite) | Kein stabiles Matching möglich |
|
||||
| **EspoCRM → Advoware** | INCREMENTAL SYNC (Hash-basiert) | EspoCRM-Wert bekannt → Hash berechenbar |
|
||||
|
||||
**Ablauf Advoware → EspoCRM (FULL SYNC)**:
|
||||
```python
|
||||
1. Sammle ALLE Kommunikationen (ohne Empty Slots)
|
||||
2. Setze/Update Marker für Rück-Sync
|
||||
3. Ersetze KOMPLETTE emailAddressData[] und phoneNumberData[]
|
||||
```
|
||||
|
||||
**Ablauf EspoCRM → Advoware (INCREMENTAL)**:
|
||||
```python
|
||||
1. Baue Hash-Maps von beiden Seiten
|
||||
2. Vergleiche: Deleted, Changed, New
|
||||
3. Apply Changes (Empty Slots, Updates, Creates)
|
||||
```
|
||||
|
||||
## Module Structure
|
||||
|
||||
```
|
||||
services/
|
||||
├── kommunikation_mapper.py # Datentyp-Mapping & Marker-Logik
|
||||
├── advoware_service.py # Advoware API-Wrapper
|
||||
└── kommunikation_sync_utils.py # Sync-Manager (bidirectional)
|
||||
```
|
||||
|
||||
## Usage Example
|
||||
|
||||
```python
|
||||
from services.advoware_service import AdvowareService
|
||||
from services.espocrm import EspoCrmService
|
||||
from services.kommunikation_sync_utils import KommunikationSyncManager
|
||||
|
||||
# Initialize
|
||||
advo = AdvowareService()
|
||||
espo = EspoCrmService()
|
||||
sync_manager = KommunikationSyncManager(advo, espo)
|
||||
|
||||
# Bidirectional Sync
|
||||
result = sync_manager.sync_bidirectional(
|
||||
beteiligte_id='espocrm-bet-id',
|
||||
betnr=12345,
|
||||
direction='both' # 'both', 'to_espocrm', 'to_advoware'
|
||||
)
|
||||
|
||||
print(result)
|
||||
# {
|
||||
# 'advoware_to_espocrm': {
|
||||
# 'emails_synced': 3,
|
||||
# 'phones_synced': 2,
|
||||
# 'errors': []
|
||||
# },
|
||||
# 'espocrm_to_advoware': {
|
||||
# 'created': 1,
|
||||
# 'updated': 2,
|
||||
# 'deleted': 0,
|
||||
# 'errors': []
|
||||
# }
|
||||
# }
|
||||
```
|
||||
|
||||
## Field Mapping
|
||||
|
||||
### kommKz Enum (Advoware)
|
||||
|
||||
| kommKz | Name | EspoCRM Target | EspoCRM Type |
|
||||
|--------|------|----------------|--------------|
|
||||
| 1 | TelGesch | phoneNumberData | Office |
|
||||
| 2 | FaxGesch | phoneNumberData | Fax |
|
||||
| 3 | Mobil | phoneNumberData | Mobile |
|
||||
| 4 | MailGesch | emailAddressData | - |
|
||||
| 5 | Internet | *(skipped)* | - |
|
||||
| 6 | TelPrivat | phoneNumberData | Home |
|
||||
| 7 | FaxPrivat | phoneNumberData | Fax |
|
||||
| 8 | MailPrivat | emailAddressData | - |
|
||||
| 9 | AutoTelefon | phoneNumberData | Mobile |
|
||||
| 10 | Sonstige | phoneNumberData | Other |
|
||||
| 11 | EPost | emailAddressData | - |
|
||||
| 12 | Bea | emailAddressData | - |
|
||||
|
||||
**Note**: Internet (kommKz=5) wird nicht synchronisiert (unklar ob Email/Phone).
|
||||
|
||||
## Sync Scenarios
|
||||
|
||||
### Scenario 1: Delete in EspoCRM
|
||||
```
|
||||
EspoCRM: max@example.com gelöscht
|
||||
Advoware: [ESPOCRM:abc:4] max@example.com
|
||||
|
||||
→ UPDATE zu Empty Slot:
|
||||
tlf: ''
|
||||
bemerkung: [ESPOCRM-SLOT:4]
|
||||
online: False
|
||||
```
|
||||
|
||||
### Scenario 2: Change in EspoCRM
|
||||
```
|
||||
EspoCRM: max@old.com → max@new.com
|
||||
Advoware: [ESPOCRM:oldhash:4] max@old.com
|
||||
|
||||
→ UPDATE with new hash:
|
||||
tlf: 'max@new.com'
|
||||
bemerkung: [ESPOCRM:newhash:4] Geschäftlich
|
||||
online: True
|
||||
```
|
||||
|
||||
### Scenario 3: New in EspoCRM
|
||||
```
|
||||
EspoCRM: Neue Email new@example.com
|
||||
|
||||
→ Suche Empty Slot (kommKz=4)
|
||||
IF found: REUSE (UPDATE)
|
||||
ELSE: CREATE new
|
||||
```
|
||||
|
||||
### Scenario 4: New in Advoware
|
||||
```
|
||||
Advoware: Neue Kommunikation (kein Marker)
|
||||
|
||||
→ Typ-Erkennung via Top-Level/Pattern
|
||||
→ Sync zu EspoCRM
|
||||
→ Marker in Advoware setzen
|
||||
```
|
||||
|
||||
## API Limitations
|
||||
|
||||
### Advoware API v1
|
||||
- ✅ **POST**: /api/v1/advonet/Beteiligte/{betnr}/Kommunikationen
|
||||
- Required: tlf, kommKz
|
||||
- Optional: bemerkung, online
|
||||
|
||||
- ✅ **PUT**: /api/v1/advonet/Beteiligte/{betnr}/Kommunikationen/{id}
|
||||
- Writable: tlf, bemerkung, online
|
||||
- **READ-ONLY**: kommKz (cannot change type!)
|
||||
|
||||
- ❌ **DELETE**: 403 Forbidden
|
||||
- Use Empty Slots instead
|
||||
|
||||
- ⚠️ **BUG**: kommKz always returns 0 in GET
|
||||
- Use Top-Level fields + Pattern detection
|
||||
|
||||
### EspoCRM
|
||||
- ✅ **emailAddressData**: Array ohne IDs
|
||||
- ✅ **phoneNumberData**: Array ohne IDs
|
||||
- ❌ **Kein CKommunikation Entity**: Arrays nur in CBeteiligte
|
||||
|
||||
## Testing
|
||||
|
||||
Run all tests:
|
||||
```bash
|
||||
cd /opt/motia-app/bitbylaw
|
||||
python3 scripts/test_kommunikation_sync_implementation.py
|
||||
```
|
||||
|
||||
**Test Coverage**:
|
||||
- ✅ Hash-Berechnung und Konsistenz
|
||||
- ✅ Marker-Parsing (Standard + Slot)
|
||||
- ✅ Marker-Erstellung
|
||||
- ✅ 4-Stufen Typ-Erkennung (alle Tiers)
|
||||
- ✅ Typ-Klassifizierung (Email vs Phone)
|
||||
- ✅ Integration Szenario
|
||||
- ✅ Top-Level Feld Priorität
|
||||
|
||||
## Change Detection
|
||||
|
||||
### Advoware Webhook
|
||||
```python
|
||||
from services.kommunikation_sync_utils import detect_kommunikation_changes
|
||||
|
||||
if detect_kommunikation_changes(old_bet, new_bet):
|
||||
# rowId changed → Sync needed
|
||||
sync_manager.sync_bidirectional(bet_id, betnr, direction='to_espocrm')
|
||||
```
|
||||
|
||||
### EspoCRM Webhook
|
||||
```python
|
||||
from services.kommunikation_sync_utils import detect_espocrm_kommunikation_changes
|
||||
|
||||
if detect_espocrm_kommunikation_changes(old_data, new_data):
|
||||
# Array changed → Sync needed
|
||||
sync_manager.sync_bidirectional(bet_id, betnr, direction='to_advoware')
|
||||
```
|
||||
|
||||
## Known Limitations
|
||||
|
||||
1. **FULL SYNC von Advoware → EspoCRM**:
|
||||
- Arrays werden komplett überschrieben (kein Merge)
|
||||
- Grund: Hash-basiertes Matching funktioniert nicht bei Wert-Änderungen in Advoware
|
||||
- Risiko minimal: EspoCRM-Arrays haben keine Relationen
|
||||
|
||||
2. **Empty Slots Accumulation**:
|
||||
- Gelöschte Einträge werden zu leeren Slots
|
||||
- Werden wiederverwendet, aber akkumulieren
|
||||
- TODO: Periodic cleanup job
|
||||
|
||||
3. **Partial Type Loss**:
|
||||
- Advoware-Kommunikationen ohne Top-Level Match verlieren Feintyp
|
||||
- Fallback: @ → Email (4), sonst Phone (1)
|
||||
|
||||
4. **kommKz READ-ONLY**:
|
||||
- Typ kann nach Erstellung nicht geändert werden
|
||||
- Workaround: DELETE + CREATE (manuell)
|
||||
|
||||
5. **Marker sichtbar**:
|
||||
- `[ESPOCRM:...]` ist in Advoware UI sichtbar
|
||||
- User kann Text dahinter hinzufügen
|
||||
|
||||
## Documentation
|
||||
|
||||
- **Vollständige Analyse**: [docs/KOMMUNIKATION_SYNC_ANALYSE.md](../docs/KOMMUNIKATION_SYNC_ANALYSE.md)
|
||||
- **API Tests**: [scripts/test_kommunikation_api.py](test_kommunikation_api.py)
|
||||
- **Implementation Tests**: [scripts/test_kommunikation_sync_implementation.py](test_kommunikation_sync_implementation.py)
|
||||
|
||||
## Implementation Status
|
||||
|
||||
✅ **COMPLETE**
|
||||
|
||||
- [x] Marker-System (Hash + kommKz)
|
||||
- [x] 4-Stufen Typ-Erkennung
|
||||
- [x] Empty Slot System
|
||||
- [x] Bidirektionale Sync-Logik
|
||||
- [x] Advoware Service Wrapper
|
||||
- [x] Change Detection
|
||||
- [x] Test Suite
|
||||
- [x] Documentation
|
||||
|
||||
## Next Steps
|
||||
|
||||
1. **Integration in Webhook System**
|
||||
- Add kommunikation change detection to beteiligte webhooks
|
||||
- Wire up sync calls
|
||||
|
||||
2. **Monitoring**
|
||||
- Add metrics for sync operations
|
||||
- Track empty slot accumulation
|
||||
|
||||
3. **Maintenance**
|
||||
- Implement periodic cleanup job for old empty slots
|
||||
- Add notification for type-change scenarios
|
||||
|
||||
4. **Testing**
|
||||
- End-to-end tests with real Advoware/EspoCRM data
|
||||
- Load testing for large kommunikation arrays
|
||||
|
||||
---
|
||||
|
||||
**Last Updated**: 2024-01-26
|
||||
**Status**: ✅ Implementation Complete - Ready for Integration
|
||||
121
bitbylaw/services/advoware_service.py
Normal file
121
bitbylaw/services/advoware_service.py
Normal file
@@ -0,0 +1,121 @@
|
||||
"""
|
||||
Advoware Service Wrapper für Kommunikation
|
||||
Erweitert AdvowareAPI mit Kommunikation-spezifischen Methoden
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import logging
|
||||
from typing import Dict, Any, Optional
|
||||
from services.advoware import AdvowareAPI
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class AdvowareService:
|
||||
"""
|
||||
Service-Layer für Advoware Kommunikation-Operations
|
||||
Verwendet AdvowareAPI für API-Calls
|
||||
"""
|
||||
|
||||
def __init__(self, context=None):
|
||||
self.api = AdvowareAPI(context)
|
||||
self.context = context
|
||||
|
||||
# ========== BETEILIGTE ==========
|
||||
|
||||
async def get_beteiligter(self, betnr: int) -> Optional[Dict]:
|
||||
"""
|
||||
Lädt Beteiligten mit Kommunikationen
|
||||
|
||||
Returns:
|
||||
Beteiligte mit 'kommunikation' array
|
||||
"""
|
||||
try:
|
||||
endpoint = f"api/v1/advonet/Beteiligte/{betnr}"
|
||||
result = await self.api.api_call(endpoint, method='GET')
|
||||
return result
|
||||
except Exception as e:
|
||||
logger.error(f"[ADVO] Fehler beim Laden von Beteiligte {betnr}: {e}", exc_info=True)
|
||||
return None
|
||||
|
||||
# ========== KOMMUNIKATION ==========
|
||||
|
||||
async def create_kommunikation(self, betnr: int, data: Dict[str, Any]) -> Optional[Dict]:
|
||||
"""
|
||||
Erstellt neue Kommunikation
|
||||
|
||||
Args:
|
||||
betnr: Beteiligten-Nummer
|
||||
data: {
|
||||
'tlf': str, # Required
|
||||
'bemerkung': str, # Optional
|
||||
'kommKz': int, # Required (1-12)
|
||||
'online': bool # Optional
|
||||
}
|
||||
|
||||
Returns:
|
||||
Neue Kommunikation mit 'id'
|
||||
"""
|
||||
try:
|
||||
endpoint = f"api/v1/advonet/Beteiligte/{betnr}/Kommunikationen"
|
||||
result = await self.api.api_call(endpoint, method='POST', json_data=data)
|
||||
|
||||
if result:
|
||||
logger.info(f"[ADVO] ✅ Created Kommunikation: betnr={betnr}, kommKz={data.get('kommKz')}")
|
||||
|
||||
return result
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"[ADVO] Fehler beim Erstellen von Kommunikation: {e}", exc_info=True)
|
||||
return None
|
||||
|
||||
async def update_kommunikation(self, betnr: int, komm_id: int, data: Dict[str, Any]) -> bool:
|
||||
"""
|
||||
Aktualisiert bestehende Kommunikation
|
||||
|
||||
Args:
|
||||
betnr: Beteiligten-Nummer
|
||||
komm_id: Kommunikation-ID
|
||||
data: {
|
||||
'tlf': str, # Optional
|
||||
'bemerkung': str, # Optional
|
||||
'online': bool # Optional
|
||||
}
|
||||
|
||||
NOTE: kommKz ist READ-ONLY und kann nicht geändert werden
|
||||
|
||||
Returns:
|
||||
True wenn erfolgreich
|
||||
"""
|
||||
try:
|
||||
endpoint = f"api/v1/advonet/Beteiligte/{betnr}/Kommunikationen/{komm_id}"
|
||||
await self.api.api_call(endpoint, method='PUT', json_data=data)
|
||||
|
||||
logger.info(f"[ADVO] ✅ Updated Kommunikation: betnr={betnr}, komm_id={komm_id}")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"[ADVO] Fehler beim Update von Kommunikation: {e}", exc_info=True)
|
||||
return False
|
||||
|
||||
def delete_kommunikation(self, betnr: int, komm_id: int) -> bool:
|
||||
"""
|
||||
Löscht Kommunikation (aktuell 403 Forbidden)
|
||||
|
||||
NOTE: DELETE ist in Advoware API deaktiviert
|
||||
Verwende stattdessen: Leere Slots mit empty_slot_marker
|
||||
|
||||
Returns:
|
||||
True wenn erfolgreich
|
||||
"""
|
||||
try:
|
||||
endpoint = f"api/v1/advonet/Beteiligte/{betnr}/Kommunikationen/{komm_id}"
|
||||
asyncio.run(self.api.api_call(endpoint, method='DELETE'))
|
||||
|
||||
logger.info(f"[ADVO] ✅ Deleted Kommunikation: betnr={betnr}, komm_id={komm_id}")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
# Expected: 403 Forbidden
|
||||
logger.warning(f"[ADVO] DELETE not allowed (expected): {e}")
|
||||
return False
|
||||
@@ -77,7 +77,7 @@ class BeteiligteSync:
|
||||
acquired = self.redis.set(lock_key, "locked", nx=True, ex=LOCK_TTL_SECONDS)
|
||||
|
||||
if not acquired:
|
||||
self._log(f"Redis lock bereits aktiv für {entity_id}", level='warning')
|
||||
self._log(f"Redis lock bereits aktiv für {entity_id}", level='warn')
|
||||
return False
|
||||
|
||||
# STEP 2: Update syncStatus (für UI visibility)
|
||||
@@ -214,7 +214,7 @@ class BeteiligteSync:
|
||||
return datetime.fromisoformat(ts)
|
||||
|
||||
except Exception as e:
|
||||
logger.warning(f"Konnte Timestamp nicht parsen: {ts} - {e}")
|
||||
logger.warn(f"Konnte Timestamp nicht parsen: {ts} - {e}")
|
||||
return None
|
||||
|
||||
return None
|
||||
|
||||
336
bitbylaw/services/kommunikation_mapper.py
Normal file
336
bitbylaw/services/kommunikation_mapper.py
Normal file
@@ -0,0 +1,336 @@
|
||||
"""
|
||||
Kommunikation Mapper: Advoware ↔ EspoCRM
|
||||
|
||||
Mapping-Strategie:
|
||||
- Marker in Advoware bemerkung: [ESPOCRM:hash:kommKz]
|
||||
- Typ-Erkennung: Marker > Top-Level > Wert > Default
|
||||
- Bidirektional mit Slot-Wiederverwendung
|
||||
"""
|
||||
|
||||
import hashlib
|
||||
import base64
|
||||
import re
|
||||
from typing import Optional, Dict, Any, List, Tuple
|
||||
|
||||
|
||||
# kommKz Enum
|
||||
KOMMKZ_TEL_GESCH = 1
|
||||
KOMMKZ_FAX_GESCH = 2
|
||||
KOMMKZ_MOBIL = 3
|
||||
KOMMKZ_MAIL_GESCH = 4
|
||||
KOMMKZ_INTERNET = 5
|
||||
KOMMKZ_TEL_PRIVAT = 6
|
||||
KOMMKZ_FAX_PRIVAT = 7
|
||||
KOMMKZ_MAIL_PRIVAT = 8
|
||||
KOMMKZ_AUTO_TELEFON = 9
|
||||
KOMMKZ_SONSTIGE = 10
|
||||
KOMMKZ_EPOST = 11
|
||||
KOMMKZ_BEA = 12
|
||||
|
||||
# EspoCRM phone type mapping
|
||||
KOMMKZ_TO_PHONE_TYPE = {
|
||||
KOMMKZ_TEL_GESCH: 'Office',
|
||||
KOMMKZ_FAX_GESCH: 'Fax',
|
||||
KOMMKZ_MOBIL: 'Mobile',
|
||||
KOMMKZ_TEL_PRIVAT: 'Home',
|
||||
KOMMKZ_FAX_PRIVAT: 'Fax',
|
||||
KOMMKZ_AUTO_TELEFON: 'Mobile',
|
||||
KOMMKZ_SONSTIGE: 'Other',
|
||||
}
|
||||
|
||||
# Reverse mapping: EspoCRM phone type to kommKz
|
||||
PHONE_TYPE_TO_KOMMKZ = {
|
||||
'Office': KOMMKZ_TEL_GESCH,
|
||||
'Fax': KOMMKZ_FAX_GESCH,
|
||||
'Mobile': KOMMKZ_MOBIL,
|
||||
'Home': KOMMKZ_TEL_PRIVAT,
|
||||
'Other': KOMMKZ_SONSTIGE,
|
||||
}
|
||||
|
||||
# Email kommKz values
|
||||
EMAIL_KOMMKZ = [KOMMKZ_MAIL_GESCH, KOMMKZ_MAIL_PRIVAT, KOMMKZ_EPOST, KOMMKZ_BEA]
|
||||
|
||||
# Phone kommKz values
|
||||
PHONE_KOMMKZ = [KOMMKZ_TEL_GESCH, KOMMKZ_FAX_GESCH, KOMMKZ_MOBIL,
|
||||
KOMMKZ_TEL_PRIVAT, KOMMKZ_FAX_PRIVAT, KOMMKZ_AUTO_TELEFON, KOMMKZ_SONSTIGE]
|
||||
|
||||
|
||||
def encode_value(value: str) -> str:
|
||||
"""Encodiert Wert mit Base64 (URL-safe) für Marker"""
|
||||
return base64.urlsafe_b64encode(value.encode('utf-8')).decode('ascii').rstrip('=')
|
||||
|
||||
|
||||
def decode_value(encoded: str) -> str:
|
||||
"""Decodiert Base64-kodierten Wert aus Marker"""
|
||||
# Add padding if needed
|
||||
padding = 4 - (len(encoded) % 4)
|
||||
if padding != 4:
|
||||
encoded += '=' * padding
|
||||
return base64.urlsafe_b64decode(encoded.encode('ascii')).decode('utf-8')
|
||||
|
||||
|
||||
def calculate_hash(value: str) -> str:
|
||||
"""Legacy: Hash-Berechnung (für Rückwärtskompatibilität mit alten Markern)"""
|
||||
return hashlib.sha256(value.encode()).hexdigest()[:8]
|
||||
|
||||
|
||||
def parse_marker(bemerkung: str) -> Optional[Dict[str, Any]]:
|
||||
"""
|
||||
Parse ESPOCRM-Marker aus bemerkung
|
||||
|
||||
Returns:
|
||||
{'synced_value': '...', 'kommKz': 4, 'is_slot': False, 'user_text': '...'}
|
||||
oder None (synced_value ist decoded, nicht base64)
|
||||
"""
|
||||
if not bemerkung:
|
||||
return None
|
||||
|
||||
# Match SLOT: [ESPOCRM-SLOT:kommKz]
|
||||
slot_pattern = r'\[ESPOCRM-SLOT:(\d+)\](.*)'
|
||||
slot_match = re.match(slot_pattern, bemerkung)
|
||||
|
||||
if slot_match:
|
||||
return {
|
||||
'synced_value': '',
|
||||
'kommKz': int(slot_match.group(1)),
|
||||
'is_slot': True,
|
||||
'user_text': slot_match.group(2).strip()
|
||||
}
|
||||
|
||||
# Match: [ESPOCRM:base64_value:kommKz]
|
||||
pattern = r'\[ESPOCRM:([^:]+):(\d+)\](.*)'
|
||||
match = re.match(pattern, bemerkung)
|
||||
|
||||
if not match:
|
||||
return None
|
||||
|
||||
encoded_value = match.group(1)
|
||||
|
||||
# Decode Base64 value
|
||||
try:
|
||||
synced_value = decode_value(encoded_value)
|
||||
except Exception as e:
|
||||
# Fallback: Könnte alter Hash-Marker sein
|
||||
synced_value = encoded_value
|
||||
|
||||
return {
|
||||
'synced_value': synced_value,
|
||||
'kommKz': int(match.group(2)),
|
||||
'is_slot': False,
|
||||
'user_text': match.group(3).strip()
|
||||
}
|
||||
|
||||
|
||||
def create_marker(value: str, kommkz: int, user_text: str = '') -> str:
|
||||
"""Erstellt ESPOCRM-Marker mit Base64-encodiertem Wert"""
|
||||
encoded = encode_value(value)
|
||||
suffix = f" {user_text}" if user_text else ""
|
||||
return f"[ESPOCRM:{encoded}:{kommkz}]{suffix}"
|
||||
|
||||
|
||||
def create_slot_marker(kommkz: int) -> str:
|
||||
"""Erstellt Slot-Marker für gelöschte Einträge"""
|
||||
return f"[ESPOCRM-SLOT:{kommkz}]"
|
||||
|
||||
|
||||
def detect_kommkz(value: str, beteiligte: Optional[Dict] = None,
|
||||
bemerkung: Optional[str] = None,
|
||||
espo_type: Optional[str] = None) -> int:
|
||||
"""
|
||||
Erkenne kommKz mit mehrstufiger Strategie
|
||||
|
||||
Priorität:
|
||||
1. Aus bemerkung-Marker (wenn vorhanden)
|
||||
2. Aus EspoCRM type (wenn von EspoCRM kommend)
|
||||
3. Aus Top-Level Feldern in beteiligte
|
||||
4. Aus Wert (Email vs. Phone)
|
||||
5. Default
|
||||
|
||||
Args:
|
||||
espo_type: EspoCRM phone type ('Office', 'Mobile', 'Fax', etc.) oder 'email'
|
||||
"""
|
||||
# 1. Aus Marker
|
||||
if bemerkung:
|
||||
marker = parse_marker(bemerkung)
|
||||
if marker:
|
||||
import logging
|
||||
logger = logging.getLogger(__name__)
|
||||
logger.info(f"[KOMMKZ] Detected from marker: kommKz={marker['kommKz']}")
|
||||
return marker['kommKz']
|
||||
|
||||
# 2. Aus EspoCRM type (für EspoCRM->Advoware Sync)
|
||||
if espo_type:
|
||||
if espo_type == 'email':
|
||||
import logging
|
||||
logger = logging.getLogger(__name__)
|
||||
logger.info(f"[KOMMKZ] Detected from espo_type 'email': kommKz={KOMMKZ_MAIL_GESCH}")
|
||||
return KOMMKZ_MAIL_GESCH
|
||||
elif espo_type in PHONE_TYPE_TO_KOMMKZ:
|
||||
kommkz = PHONE_TYPE_TO_KOMMKZ[espo_type]
|
||||
import logging
|
||||
logger = logging.getLogger(__name__)
|
||||
logger.info(f"[KOMMKZ] Detected from espo_type '{espo_type}': kommKz={kommkz}")
|
||||
return kommkz
|
||||
|
||||
# 3. Aus Top-Level Feldern (für genau EINEN Eintrag pro Typ)
|
||||
if beteiligte:
|
||||
top_level_map = {
|
||||
'telGesch': KOMMKZ_TEL_GESCH,
|
||||
'faxGesch': KOMMKZ_FAX_GESCH,
|
||||
'mobil': KOMMKZ_MOBIL,
|
||||
'emailGesch': KOMMKZ_MAIL_GESCH,
|
||||
'email': KOMMKZ_MAIL_GESCH,
|
||||
'internet': KOMMKZ_INTERNET,
|
||||
'telPrivat': KOMMKZ_TEL_PRIVAT,
|
||||
'faxPrivat': KOMMKZ_FAX_PRIVAT,
|
||||
'autotelefon': KOMMKZ_AUTO_TELEFON,
|
||||
'ePost': KOMMKZ_EPOST,
|
||||
'bea': KOMMKZ_BEA,
|
||||
}
|
||||
|
||||
for field, kommkz in top_level_map.items():
|
||||
if beteiligte.get(field) == value:
|
||||
return kommkz
|
||||
|
||||
# 3. Aus Wert (Email vs. Phone)
|
||||
if '@' in value:
|
||||
return KOMMKZ_MAIL_GESCH # Default Email
|
||||
elif value.strip():
|
||||
return KOMMKZ_TEL_GESCH # Default Phone
|
||||
|
||||
return 0
|
||||
|
||||
|
||||
def is_email_type(kommkz: int) -> bool:
|
||||
"""Prüft ob kommKz ein Email-Typ ist"""
|
||||
return kommkz in EMAIL_KOMMKZ
|
||||
|
||||
|
||||
def is_phone_type(kommkz: int) -> bool:
|
||||
"""Prüft ob kommKz ein Telefon-Typ ist"""
|
||||
return kommkz in PHONE_KOMMKZ
|
||||
|
||||
|
||||
def advoware_to_espocrm_email(advo_komm: Dict, beteiligte: Dict) -> Dict[str, Any]:
|
||||
"""
|
||||
Konvertiert Advoware Kommunikation zu EspoCRM emailAddressData
|
||||
|
||||
Args:
|
||||
advo_komm: Advoware Kommunikation
|
||||
beteiligte: Vollständiger Beteiligte (für Top-Level Felder)
|
||||
|
||||
Returns:
|
||||
EspoCRM emailAddressData Element
|
||||
"""
|
||||
value = (advo_komm.get('tlf') or '').strip()
|
||||
|
||||
return {
|
||||
'emailAddress': value,
|
||||
'lower': value.lower(),
|
||||
'primary': advo_komm.get('online', False),
|
||||
'optOut': False,
|
||||
'invalid': False
|
||||
}
|
||||
|
||||
|
||||
def advoware_to_espocrm_phone(advo_komm: Dict, beteiligte: Dict) -> Dict[str, Any]:
|
||||
"""
|
||||
Konvertiert Advoware Kommunikation zu EspoCRM phoneNumberData
|
||||
|
||||
Args:
|
||||
advo_komm: Advoware Kommunikation
|
||||
beteiligte: Vollständiger Beteiligte (für Top-Level Felder)
|
||||
|
||||
Returns:
|
||||
EspoCRM phoneNumberData Element
|
||||
"""
|
||||
value = (advo_komm.get('tlf') or '').strip()
|
||||
bemerkung = advo_komm.get('bemerkung')
|
||||
|
||||
# Erkenne kommKz
|
||||
kommkz = detect_kommkz(value, beteiligte, bemerkung)
|
||||
|
||||
# Mappe zu EspoCRM type
|
||||
phone_type = KOMMKZ_TO_PHONE_TYPE.get(kommkz, 'Other')
|
||||
|
||||
return {
|
||||
'phoneNumber': value,
|
||||
'type': phone_type,
|
||||
'primary': advo_komm.get('online', False),
|
||||
'optOut': False,
|
||||
'invalid': False
|
||||
}
|
||||
|
||||
|
||||
def find_matching_advoware(espo_value: str, advo_kommunikationen: List[Dict]) -> Optional[Dict]:
|
||||
"""
|
||||
Findet passende Advoware-Kommunikation für EspoCRM Wert
|
||||
|
||||
Matching via synced_value in bemerkung-Marker
|
||||
"""
|
||||
for k in advo_kommunikationen:
|
||||
bemerkung = k.get('bemerkung') or ''
|
||||
marker = parse_marker(bemerkung)
|
||||
|
||||
if marker and not marker['is_slot'] and marker['synced_value'] == espo_value:
|
||||
return k
|
||||
|
||||
return None
|
||||
|
||||
|
||||
def find_empty_slot(kommkz: int, advo_kommunikationen: List[Dict]) -> Optional[Dict]:
|
||||
"""
|
||||
Findet leeren Slot mit passendem kommKz
|
||||
|
||||
Leere Slots haben: tlf='' und bemerkung='[ESPOCRM-SLOT:kommKz]'
|
||||
"""
|
||||
for k in advo_kommunikationen:
|
||||
tlf = (k.get('tlf') or '').strip()
|
||||
bemerkung = k.get('bemerkung') or ''
|
||||
|
||||
if not tlf: # Leer
|
||||
marker = parse_marker(bemerkung)
|
||||
if marker and marker['is_slot'] and marker['kommKz'] == kommkz:
|
||||
return k
|
||||
|
||||
return None
|
||||
|
||||
|
||||
def should_sync_to_espocrm(advo_komm: Dict) -> bool:
|
||||
"""
|
||||
Prüft ob Advoware-Kommunikation zu EspoCRM synchronisiert werden soll
|
||||
|
||||
Nur wenn:
|
||||
- Wert vorhanden
|
||||
- Kein leerer Slot
|
||||
"""
|
||||
tlf = (advo_komm.get('tlf') or '').strip()
|
||||
if not tlf:
|
||||
return False
|
||||
|
||||
bemerkung = advo_komm.get('bemerkung') or ''
|
||||
marker = parse_marker(bemerkung)
|
||||
|
||||
# Keine leeren Slots
|
||||
if marker and marker['is_slot']:
|
||||
return False
|
||||
|
||||
return True
|
||||
|
||||
|
||||
def get_user_bemerkung(advo_komm: Dict) -> str:
|
||||
"""Extrahiert User-Bemerkung (ohne Marker)"""
|
||||
bemerkung = advo_komm.get('bemerkung') or ''
|
||||
marker = parse_marker(bemerkung)
|
||||
|
||||
if marker:
|
||||
return marker['user_text']
|
||||
|
||||
return bemerkung
|
||||
|
||||
|
||||
def set_user_bemerkung(marker: str, user_text: str) -> str:
|
||||
"""Fügt User-Bemerkung zu Marker hinzu"""
|
||||
if user_text:
|
||||
return f"{marker} {user_text}"
|
||||
return marker
|
||||
703
bitbylaw/services/kommunikation_sync_utils.py
Normal file
703
bitbylaw/services/kommunikation_sync_utils.py
Normal file
@@ -0,0 +1,703 @@
|
||||
"""
|
||||
Kommunikation Sync Utilities
|
||||
Bidirektionale Synchronisation: Advoware ↔ EspoCRM
|
||||
|
||||
Strategie:
|
||||
- Emails: emailAddressData[] ↔ Advoware Kommunikationen (kommKz: 4,8,11,12)
|
||||
- Phones: phoneNumberData[] ↔ Advoware Kommunikationen (kommKz: 1,2,3,6,7,9,10)
|
||||
- Matching: Hash-basiert via bemerkung-Marker
|
||||
- Type Detection: Marker > Top-Level > Value Pattern > Default
|
||||
"""
|
||||
|
||||
import logging
|
||||
from typing import Dict, List, Optional, Tuple, Any
|
||||
from services.kommunikation_mapper import (
|
||||
parse_marker, create_marker, create_slot_marker,
|
||||
detect_kommkz, encode_value, decode_value,
|
||||
is_email_type, is_phone_type,
|
||||
advoware_to_espocrm_email, advoware_to_espocrm_phone,
|
||||
find_matching_advoware, find_empty_slot,
|
||||
should_sync_to_espocrm, get_user_bemerkung,
|
||||
calculate_hash,
|
||||
EMAIL_KOMMKZ, PHONE_KOMMKZ
|
||||
)
|
||||
from services.advoware_service import AdvowareService
|
||||
from services.espocrm import EspoCRMAPI
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class KommunikationSyncManager:
|
||||
"""Manager für Kommunikation-Synchronisation"""
|
||||
|
||||
def __init__(self, advoware: AdvowareService, espocrm: EspoCRMAPI, context=None):
|
||||
self.advoware = advoware
|
||||
self.espocrm = espocrm
|
||||
self.context = context
|
||||
self.logger = context.logger if context else logger
|
||||
|
||||
# ========== BIDIRECTIONAL SYNC ==========
|
||||
|
||||
async def sync_bidirectional(self, beteiligte_id: str, betnr: int,
|
||||
direction: str = 'both') -> Dict[str, Any]:
|
||||
"""
|
||||
Bidirektionale Synchronisation mit intelligentem Diffing
|
||||
|
||||
Optimiert:
|
||||
- Lädt Daten nur 1x von jeder Seite
|
||||
- Echtes 3-Way Diffing (Advoware, EspoCRM, Marker)
|
||||
- Handhabt alle 6 Szenarien korrekt
|
||||
|
||||
Args:
|
||||
direction: 'both', 'to_espocrm', 'to_advoware'
|
||||
|
||||
Returns:
|
||||
Combined results mit detaillierten Änderungen
|
||||
"""
|
||||
result = {
|
||||
'advoware_to_espocrm': {'emails_synced': 0, 'phones_synced': 0, 'errors': []},
|
||||
'espocrm_to_advoware': {'created': 0, 'updated': 0, 'deleted': 0, 'errors': []},
|
||||
'summary': {'total_changes': 0}
|
||||
}
|
||||
|
||||
try:
|
||||
# ========== LADE DATEN NUR 1X ==========
|
||||
self.logger.info(f"[KOMM] Bidirectional Sync: betnr={betnr}, bet_id={beteiligte_id}")
|
||||
|
||||
# Advoware Daten
|
||||
advo_result = await self.advoware.get_beteiligter(betnr)
|
||||
if isinstance(advo_result, list):
|
||||
advo_bet = advo_result[0] if advo_result else None
|
||||
else:
|
||||
advo_bet = advo_result
|
||||
|
||||
if not advo_bet:
|
||||
result['advoware_to_espocrm']['errors'].append("Advoware Beteiligte nicht gefunden")
|
||||
result['espocrm_to_advoware']['errors'].append("Advoware Beteiligte nicht gefunden")
|
||||
return result
|
||||
|
||||
# EspoCRM Daten
|
||||
espo_bet = await self.espocrm.get_entity('CBeteiligte', beteiligte_id)
|
||||
if not espo_bet:
|
||||
result['advoware_to_espocrm']['errors'].append("EspoCRM Beteiligte nicht gefunden")
|
||||
result['espocrm_to_advoware']['errors'].append("EspoCRM Beteiligte nicht gefunden")
|
||||
return result
|
||||
|
||||
advo_kommunikationen = advo_bet.get('kommunikation', [])
|
||||
espo_emails = espo_bet.get('emailAddressData', [])
|
||||
espo_phones = espo_bet.get('phoneNumberData', [])
|
||||
|
||||
self.logger.info(f"[KOMM] Geladen: {len(advo_kommunikationen)} Advoware, {len(espo_emails)} EspoCRM emails, {len(espo_phones)} EspoCRM phones")
|
||||
|
||||
# Check ob initialer Sync
|
||||
stored_komm_hash = espo_bet.get('kommunikationHash')
|
||||
is_initial_sync = not stored_komm_hash
|
||||
|
||||
# ========== 3-WAY DIFFING MIT HASH-BASIERTER KONFLIKT-ERKENNUNG ==========
|
||||
diff = self._compute_diff(advo_kommunikationen, espo_emails, espo_phones, advo_bet, espo_bet)
|
||||
|
||||
espo_wins = diff.get('espo_wins', False)
|
||||
|
||||
self.logger.info(f"[KOMM] ===== DIFF RESULTS =====")
|
||||
self.logger.info(f"[KOMM] Diff: {len(diff['advo_changed'])} Advoware changed, {len(diff['espo_changed'])} EspoCRM changed, "
|
||||
f"{len(diff['advo_new'])} Advoware new, {len(diff['espo_new'])} EspoCRM new, "
|
||||
f"{len(diff['advo_deleted'])} Advoware deleted, {len(diff['espo_deleted'])} EspoCRM deleted")
|
||||
self.logger.info(f"[KOMM] ===== CONFLICT STATUS: espo_wins={espo_wins} =====")
|
||||
|
||||
# ========== APPLY CHANGES ==========
|
||||
|
||||
# 1. Advoware → EspoCRM (Var4: Neu in Advoware, Var6: Geändert in Advoware)
|
||||
# WICHTIG: Bei Konflikt (espo_wins=true) KEINE Advoware-Änderungen übernehmen!
|
||||
if direction in ['both', 'to_espocrm'] and not espo_wins:
|
||||
self.logger.info(f"[KOMM] ✅ Applying Advoware→EspoCRM changes...")
|
||||
espo_result = await self._apply_advoware_to_espocrm(
|
||||
beteiligte_id, diff, advo_bet
|
||||
)
|
||||
result['advoware_to_espocrm'] = espo_result
|
||||
elif direction in ['both', 'to_espocrm'] and espo_wins:
|
||||
self.logger.info(f"[KOMM] ⚠️ CONFLICT: EspoCRM wins - skipping Advoware→EspoCRM sync")
|
||||
else:
|
||||
self.logger.info(f"[KOMM] ℹ️ Skipping Advoware→EspoCRM (direction={direction})")
|
||||
|
||||
# 2. EspoCRM → Advoware (Var1: Neu in EspoCRM, Var2: Gelöscht in EspoCRM, Var5: Geändert in EspoCRM)
|
||||
if direction in ['both', 'to_advoware']:
|
||||
advo_result = await self._apply_espocrm_to_advoware(
|
||||
betnr, diff, advo_bet
|
||||
)
|
||||
result['espocrm_to_advoware'] = advo_result
|
||||
|
||||
total_changes = (
|
||||
result['advoware_to_espocrm']['emails_synced'] +
|
||||
result['advoware_to_espocrm']['phones_synced'] +
|
||||
result['espocrm_to_advoware']['created'] +
|
||||
result['espocrm_to_advoware']['updated'] +
|
||||
result['espocrm_to_advoware']['deleted']
|
||||
)
|
||||
result['summary']['total_changes'] = total_changes
|
||||
|
||||
# Speichere neuen Kommunikations-Hash in EspoCRM (für nächsten Sync)
|
||||
# WICHTIG: Auch beim initialen Sync oder wenn keine Änderungen
|
||||
if total_changes > 0 or is_initial_sync:
|
||||
# Re-berechne Hash nach allen Änderungen
|
||||
advo_result_final = await self.advoware.get_beteiligter(betnr)
|
||||
if isinstance(advo_result_final, list):
|
||||
advo_bet_final = advo_result_final[0]
|
||||
else:
|
||||
advo_bet_final = advo_result_final
|
||||
|
||||
import hashlib
|
||||
final_kommunikationen = advo_bet_final.get('kommunikation', [])
|
||||
komm_rowids = sorted([k.get('rowId', '') for k in final_kommunikationen if k.get('rowId')])
|
||||
new_komm_hash = hashlib.md5(''.join(komm_rowids).encode()).hexdigest()[:16]
|
||||
|
||||
await self.espocrm.update_entity('CBeteiligte', beteiligte_id, {
|
||||
'kommunikationHash': new_komm_hash
|
||||
})
|
||||
self.logger.info(f"[KOMM] ✅ Updated kommunikationHash: {new_komm_hash}")
|
||||
|
||||
self.logger.info(f"[KOMM] ✅ Bidirectional Sync complete: {total_changes} total changes")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"[KOMM] Fehler bei Bidirectional Sync: {e}", exc_info=True)
|
||||
result['advoware_to_espocrm']['errors'].append(str(e))
|
||||
result['espocrm_to_advoware']['errors'].append(str(e))
|
||||
|
||||
return result
|
||||
|
||||
# ========== 3-WAY DIFFING ==========
|
||||
|
||||
def _compute_diff(self, advo_kommunikationen: List[Dict], espo_emails: List[Dict],
|
||||
espo_phones: List[Dict], advo_bet: Dict, espo_bet: Dict) -> Dict[str, List]:
|
||||
"""
|
||||
Berechnet Diff zwischen Advoware und EspoCRM mit Kommunikations-Hash-basierter Konflikt-Erkennung
|
||||
|
||||
Da die Beteiligte-rowId sich NICHT bei Kommunikations-Änderungen ändert,
|
||||
nutzen wir einen Hash aus allen Kommunikations-rowIds + EspoCRM modifiedAt.
|
||||
|
||||
Returns:
|
||||
{
|
||||
'advo_changed': [(komm, old_value, new_value)], # Var6: In Advoware geändert
|
||||
'advo_new': [komm], # Var4: Neu in Advoware (ohne Marker)
|
||||
'advo_deleted': [(value, item)], # Var3: In Advoware gelöscht (via Hash)
|
||||
'espo_changed': [(value, advo_komm)], # Var5: In EspoCRM geändert
|
||||
'espo_new': [(value, item)], # Var1: Neu in EspoCRM (via Hash)
|
||||
'espo_deleted': [advo_komm], # Var2: In EspoCRM gelöscht
|
||||
'no_change': [(value, komm, item)] # Keine Änderung
|
||||
}
|
||||
"""
|
||||
diff = {
|
||||
'advo_changed': [],
|
||||
'advo_new': [],
|
||||
'advo_deleted': [], # NEU: Var3
|
||||
'espo_changed': [],
|
||||
'espo_new': [],
|
||||
'espo_deleted': [],
|
||||
'no_change': [],
|
||||
'espo_wins': False # Default
|
||||
}
|
||||
|
||||
# Hole Sync-Metadaten für Konflikt-Erkennung
|
||||
espo_modified = espo_bet.get('modifiedAt')
|
||||
last_sync = espo_bet.get('advowareLastSync')
|
||||
|
||||
# Berechne Hash aus Kommunikations-rowIds
|
||||
import hashlib
|
||||
komm_rowids = sorted([k.get('rowId', '') for k in advo_kommunikationen if k.get('rowId')])
|
||||
current_advo_hash = hashlib.md5(''.join(komm_rowids).encode()).hexdigest()[:16]
|
||||
stored_komm_hash = espo_bet.get('kommunikationHash')
|
||||
|
||||
# Parse Timestamps
|
||||
from services.beteiligte_sync_utils import BeteiligteSync
|
||||
espo_modified_ts = BeteiligteSync.parse_timestamp(espo_modified)
|
||||
last_sync_ts = BeteiligteSync.parse_timestamp(last_sync)
|
||||
|
||||
# Bestimme wer geändert hat
|
||||
espo_changed_since_sync = espo_modified_ts and last_sync_ts and espo_modified_ts > last_sync_ts
|
||||
advo_changed_since_sync = stored_komm_hash and current_advo_hash != stored_komm_hash
|
||||
|
||||
# Initial Sync: Wenn kein Hash gespeichert ist, behandle als "keine Änderung in Advoware"
|
||||
is_initial_sync = not stored_komm_hash
|
||||
|
||||
self.logger.info(f"[KOMM] 🔍 Konflikt-Check:")
|
||||
self.logger.info(f"[KOMM] - EspoCRM changed: {espo_changed_since_sync} (modified={espo_modified}, lastSync={last_sync})")
|
||||
self.logger.info(f"[KOMM] - Advoware changed: {advo_changed_since_sync} (stored_hash={stored_komm_hash}, current_hash={current_advo_hash})")
|
||||
self.logger.info(f"[KOMM] - Initial sync: {is_initial_sync}")
|
||||
self.logger.info(f"[KOMM] - Kommunikation rowIds count: {len(komm_rowids)}")
|
||||
|
||||
if espo_changed_since_sync and advo_changed_since_sync:
|
||||
self.logger.warning(f"[KOMM] ⚠️ KONFLIKT: Beide Seiten geändert seit letztem Sync - EspoCRM WINS")
|
||||
espo_wins = True
|
||||
else:
|
||||
espo_wins = False
|
||||
|
||||
# Speichere espo_wins im diff für spätere Verwendung
|
||||
diff['espo_wins'] = espo_wins
|
||||
|
||||
# Baue EspoCRM Value Map
|
||||
espo_values = {}
|
||||
for email in espo_emails:
|
||||
val = email.get('emailAddress', '').strip()
|
||||
if val:
|
||||
espo_values[val] = {'value': val, 'is_email': True, 'primary': email.get('primary', False), 'type': 'email'}
|
||||
|
||||
for phone in espo_phones:
|
||||
val = phone.get('phoneNumber', '').strip()
|
||||
if val:
|
||||
espo_values[val] = {'value': val, 'is_email': False, 'primary': phone.get('primary', False), 'type': phone.get('type', 'Office')}
|
||||
|
||||
# Baue Advoware Maps
|
||||
advo_with_marker = {} # synced_value -> (komm, current_value)
|
||||
advo_without_marker = [] # Einträge ohne Marker (von Advoware angelegt)
|
||||
|
||||
for komm in advo_kommunikationen:
|
||||
if not should_sync_to_espocrm(komm):
|
||||
continue
|
||||
|
||||
tlf = (komm.get('tlf') or '').strip()
|
||||
if not tlf: # Leere Einträge ignorieren
|
||||
continue
|
||||
|
||||
bemerkung = komm.get('bemerkung') or ''
|
||||
marker = parse_marker(bemerkung)
|
||||
|
||||
if marker and not marker['is_slot']:
|
||||
# Hat Marker → Von EspoCRM synchronisiert
|
||||
synced_value = marker['synced_value']
|
||||
advo_with_marker[synced_value] = (komm, tlf)
|
||||
else:
|
||||
# Kein Marker → Von Advoware angelegt (Var4)
|
||||
advo_without_marker.append(komm)
|
||||
|
||||
# ========== ANALYSE ==========
|
||||
|
||||
# 1. Prüfe Advoware-Einträge MIT Marker
|
||||
for synced_value, (komm, current_value) in advo_with_marker.items():
|
||||
|
||||
if synced_value != current_value:
|
||||
# Var6: In Advoware geändert
|
||||
self.logger.info(f"[KOMM] ✏️ Var6: Changed in Advoware - synced='{synced_value[:30]}...', current='{current_value[:30]}...'")
|
||||
diff['advo_changed'].append((komm, synced_value, current_value))
|
||||
|
||||
elif synced_value in espo_values:
|
||||
espo_item = espo_values[synced_value]
|
||||
|
||||
# Prüfe ob primary geändert wurde (Var5 könnte auch sein)
|
||||
current_online = komm.get('online', False)
|
||||
espo_primary = espo_item['primary']
|
||||
|
||||
if current_online != espo_primary:
|
||||
# Var5: EspoCRM hat primary geändert
|
||||
self.logger.info(f"[KOMM] 🔄 Var5: Primary changed in EspoCRM - value='{synced_value}', advo_online={current_online}, espo_primary={espo_primary}")
|
||||
diff['espo_changed'].append((synced_value, komm, espo_item))
|
||||
else:
|
||||
# Keine Änderung
|
||||
self.logger.info(f"[KOMM] ✓ No change: '{synced_value[:30]}...'")
|
||||
diff['no_change'].append((synced_value, komm, espo_item))
|
||||
|
||||
else:
|
||||
# Eintrag war mal in EspoCRM (hat Marker), ist jetzt aber nicht mehr da
|
||||
# → Var2: In EspoCRM gelöscht
|
||||
self.logger.info(f"[KOMM] 🗑️ Var2: Deleted in EspoCRM - synced_value='{synced_value}', komm_id={komm.get('id')}")
|
||||
diff['espo_deleted'].append(komm)
|
||||
|
||||
# 2. Prüfe Advoware-Einträge OHNE Marker
|
||||
for komm in advo_without_marker:
|
||||
# Var4: Neu in Advoware angelegt
|
||||
tlf = (komm.get('tlf') or '').strip()
|
||||
self.logger.info(f"[KOMM] ➕ Var4: New in Advoware - value='{tlf[:30]}...', komm_id={komm.get('id')}")
|
||||
diff['advo_new'].append(komm)
|
||||
|
||||
# 3. Prüfe EspoCRM-Einträge die NICHT in Advoware sind (oder nur mit altem Marker)
|
||||
for value, espo_item in espo_values.items():
|
||||
if value not in advo_with_marker:
|
||||
# HASH-BASIERTE KONFLIKT-LOGIK: Unterscheide Var1 von Var3
|
||||
|
||||
if espo_wins or (espo_changed_since_sync and not advo_changed_since_sync):
|
||||
# Var1: Neu in EspoCRM (EspoCRM geändert, Advoware nicht)
|
||||
self.logger.info(f"[KOMM] Var1: New in EspoCRM '{value}' (espo changed, advo unchanged)")
|
||||
diff['espo_new'].append((value, espo_item))
|
||||
|
||||
elif advo_changed_since_sync and not espo_changed_since_sync:
|
||||
# Var3: In Advoware gelöscht (Advoware geändert, EspoCRM nicht)
|
||||
self.logger.info(f"[KOMM] Var3: Deleted in Advoware '{value}' (advo changed, espo unchanged)")
|
||||
diff['advo_deleted'].append((value, espo_item))
|
||||
|
||||
else:
|
||||
# Kein klarer Hinweis - Default: Behandle als Var1 (neu in EspoCRM)
|
||||
self.logger.info(f"[KOMM] Var1 (default): '{value}' - no clear indication, treating as new in EspoCRM")
|
||||
diff['espo_new'].append((value, espo_item))
|
||||
|
||||
return diff
|
||||
|
||||
# ========== APPLY CHANGES ==========
|
||||
|
||||
async def _apply_advoware_to_espocrm(self, beteiligte_id: str, diff: Dict,
|
||||
advo_bet: Dict) -> Dict[str, Any]:
|
||||
"""
|
||||
Wendet Advoware-Änderungen auf EspoCRM an (Var4, Var6)
|
||||
"""
|
||||
result = {'emails_synced': 0, 'phones_synced': 0, 'markers_updated': 0, 'errors': []}
|
||||
|
||||
try:
|
||||
# Lade aktuelle EspoCRM Daten
|
||||
espo_bet = await self.espocrm.get_entity('CBeteiligte', beteiligte_id)
|
||||
espo_emails = list(espo_bet.get('emailAddressData', []))
|
||||
espo_phones = list(espo_bet.get('phoneNumberData', []))
|
||||
|
||||
# Var6: Advoware-Änderungen → Update Marker + Sync zu EspoCRM
|
||||
for komm, old_value, new_value in diff['advo_changed']:
|
||||
self.logger.info(f"[KOMM] Var6: Advoware changed '{old_value}' → '{new_value}'")
|
||||
|
||||
# Update Marker in Advoware
|
||||
bemerkung = komm.get('bemerkung') or ''
|
||||
marker = parse_marker(bemerkung)
|
||||
user_text = marker.get('user_text', '') if marker else ''
|
||||
kommkz = marker['kommKz'] if marker else detect_kommkz(new_value, advo_bet)
|
||||
|
||||
new_marker = create_marker(new_value, kommkz, user_text)
|
||||
await self.advoware.update_kommunikation(advo_bet['betNr'], komm['id'], {
|
||||
'bemerkung': new_marker
|
||||
})
|
||||
result['markers_updated'] += 1
|
||||
|
||||
# Update in EspoCRM: Finde alten Wert und ersetze mit neuem
|
||||
if is_email_type(kommkz):
|
||||
for i, email in enumerate(espo_emails):
|
||||
if email.get('emailAddress') == old_value:
|
||||
espo_emails[i] = {
|
||||
'emailAddress': new_value,
|
||||
'lower': new_value.lower(),
|
||||
'primary': komm.get('online', False),
|
||||
'optOut': False,
|
||||
'invalid': False
|
||||
}
|
||||
result['emails_synced'] += 1
|
||||
break
|
||||
else:
|
||||
for i, phone in enumerate(espo_phones):
|
||||
if phone.get('phoneNumber') == old_value:
|
||||
type_map = {1: 'Office', 2: 'Fax', 3: 'Mobile', 6: 'Home', 7: 'Fax', 9: 'Mobile', 10: 'Other'}
|
||||
espo_phones[i] = {
|
||||
'phoneNumber': new_value,
|
||||
'type': type_map.get(kommkz, 'Other'),
|
||||
'primary': komm.get('online', False),
|
||||
'optOut': False,
|
||||
'invalid': False
|
||||
}
|
||||
result['phones_synced'] += 1
|
||||
break
|
||||
|
||||
# Var4: Neu in Advoware → Zu EspoCRM hinzufügen + Marker setzen
|
||||
for komm in diff['advo_new']:
|
||||
tlf = (komm.get('tlf') or '').strip()
|
||||
kommkz = detect_kommkz(tlf, advo_bet, komm.get('bemerkung'))
|
||||
|
||||
self.logger.info(f"[KOMM] Var4: New in Advoware '{tlf}', syncing to EspoCRM")
|
||||
|
||||
# Setze Marker in Advoware
|
||||
new_marker = create_marker(tlf, kommkz)
|
||||
await self.advoware.update_kommunikation(advo_bet['betNr'], komm['id'], {
|
||||
'bemerkung': new_marker
|
||||
})
|
||||
|
||||
# Zu EspoCRM hinzufügen
|
||||
if is_email_type(kommkz):
|
||||
espo_emails.append({
|
||||
'emailAddress': tlf,
|
||||
'lower': tlf.lower(),
|
||||
'primary': komm.get('online', False),
|
||||
'optOut': False,
|
||||
'invalid': False
|
||||
})
|
||||
result['emails_synced'] += 1
|
||||
else:
|
||||
type_map = {1: 'Office', 2: 'Fax', 3: 'Mobile', 6: 'Home', 7: 'Fax', 9: 'Mobile', 10: 'Other'}
|
||||
espo_phones.append({
|
||||
'phoneNumber': tlf,
|
||||
'type': type_map.get(kommkz, 'Other'),
|
||||
'primary': komm.get('online', False),
|
||||
'optOut': False,
|
||||
'invalid': False
|
||||
})
|
||||
result['phones_synced'] += 1
|
||||
|
||||
# Var3: In Advoware gelöscht → Aus EspoCRM entfernen
|
||||
for value, espo_item in diff.get('advo_deleted', []):
|
||||
self.logger.info(f"[KOMM] Var3: Deleted in Advoware '{value}', removing from EspoCRM")
|
||||
|
||||
if espo_item['is_email']:
|
||||
espo_emails = [e for e in espo_emails if e.get('emailAddress') != value]
|
||||
result['emails_synced'] += 1 # Zählt als "synced" (gelöscht)
|
||||
else:
|
||||
espo_phones = [p for p in espo_phones if p.get('phoneNumber') != value]
|
||||
result['phones_synced'] += 1
|
||||
|
||||
# Update EspoCRM wenn Änderungen
|
||||
if result['emails_synced'] > 0 or result['phones_synced'] > 0:
|
||||
await self.espocrm.update_entity('CBeteiligte', beteiligte_id, {
|
||||
'emailAddressData': espo_emails,
|
||||
'phoneNumberData': espo_phones
|
||||
})
|
||||
self.logger.info(f"[KOMM] ✅ Updated EspoCRM: {result['emails_synced']} emails, {result['phones_synced']} phones")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"[KOMM] Fehler bei Advoware→EspoCRM Apply: {e}", exc_info=True)
|
||||
result['errors'].append(str(e))
|
||||
|
||||
return result
|
||||
|
||||
async def _apply_espocrm_to_advoware(self, betnr: int, diff: Dict,
|
||||
advo_bet: Dict) -> Dict[str, Any]:
|
||||
"""
|
||||
Wendet EspoCRM-Änderungen auf Advoware an (Var1, Var2, Var3, Var5)
|
||||
"""
|
||||
result = {'created': 0, 'updated': 0, 'deleted': 0, 'errors': []}
|
||||
|
||||
try:
|
||||
advo_kommunikationen = advo_bet.get('kommunikation', [])
|
||||
|
||||
# Var2: In EspoCRM gelöscht → Empty Slot in Advoware
|
||||
for komm in diff['espo_deleted']:
|
||||
komm_id = komm.get('id')
|
||||
tlf = (komm.get('tlf') or '').strip()
|
||||
self.logger.info(f"[KOMM] 🗑️ Var2: Deleted in EspoCRM - komm_id={komm_id}, value='{tlf[:30]}...'")
|
||||
await self._create_empty_slot(betnr, komm)
|
||||
self.logger.info(f"[KOMM] ✅ Empty slot created for komm_id={komm_id}")
|
||||
result['deleted'] += 1
|
||||
|
||||
# Var5: In EspoCRM geändert (z.B. primary Flag)
|
||||
for value, advo_komm, espo_item in diff['espo_changed']:
|
||||
self.logger.info(f"[KOMM] ✏️ Var5: EspoCRM changed '{value[:30]}...', primary={espo_item.get('primary')}")
|
||||
|
||||
bemerkung = advo_komm.get('bemerkung') or ''
|
||||
marker = parse_marker(bemerkung)
|
||||
user_text = marker.get('user_text', '') if marker else ''
|
||||
|
||||
# Erkenne kommKz mit espo_type
|
||||
if marker:
|
||||
kommkz = marker['kommKz']
|
||||
self.logger.info(f"[KOMM] kommKz from marker: {kommkz}")
|
||||
else:
|
||||
espo_type = espo_item.get('type', 'email' if '@' in value else None)
|
||||
kommkz = detect_kommkz(value, advo_bet, espo_type=espo_type)
|
||||
self.logger.info(f"[KOMM] kommKz detected: espo_type={espo_type}, kommKz={kommkz}")
|
||||
|
||||
# Update in Advoware
|
||||
await self.advoware.update_kommunikation(betnr, advo_komm['id'], {
|
||||
'tlf': value,
|
||||
'online': espo_item['primary'],
|
||||
'bemerkung': create_marker(value, kommkz, user_text)
|
||||
})
|
||||
self.logger.info(f"[KOMM] ✅ Updated komm_id={advo_komm['id']}, kommKz={kommkz}")
|
||||
result['updated'] += 1
|
||||
|
||||
# Var1: Neu in EspoCRM → Create oder reuse Slot in Advoware
|
||||
for value, espo_item in diff['espo_new']:
|
||||
self.logger.info(f"[KOMM] ➕ Var1: New in EspoCRM '{value[:30]}...', type={espo_item.get('type')}")
|
||||
|
||||
# Erkenne kommKz mit espo_type
|
||||
espo_type = espo_item.get('type', 'email' if '@' in value else None)
|
||||
kommkz = detect_kommkz(value, advo_bet, espo_type=espo_type)
|
||||
self.logger.info(f"[KOMM] 🔍 kommKz detected: espo_type={espo_type}, kommKz={kommkz}")
|
||||
|
||||
# Suche leeren Slot
|
||||
empty_slot = find_empty_slot(kommkz, advo_kommunikationen)
|
||||
|
||||
if empty_slot:
|
||||
# Reuse Slot
|
||||
self.logger.info(f"[KOMM] ♻️ Reusing empty slot: slot_id={empty_slot['id']}, kommKz={kommkz}")
|
||||
await self.advoware.update_kommunikation(betnr, empty_slot['id'], {
|
||||
'tlf': value,
|
||||
'online': espo_item['primary'],
|
||||
'bemerkung': create_marker(value, kommkz)
|
||||
})
|
||||
self.logger.info(f"[KOMM] ✅ Slot reused successfully")
|
||||
else:
|
||||
# Create new
|
||||
self.logger.info(f"[KOMM] ➕ Creating new kommunikation: kommKz={kommkz}")
|
||||
await self.advoware.create_kommunikation(betnr, {
|
||||
'tlf': value,
|
||||
'kommKz': kommkz,
|
||||
'online': espo_item['primary'],
|
||||
'bemerkung': create_marker(value, kommkz)
|
||||
})
|
||||
self.logger.info(f"[KOMM] ✅ Created new kommunikation with kommKz={kommkz}")
|
||||
|
||||
result['created'] += 1
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"[KOMM] Fehler bei EspoCRM→Advoware Apply: {e}", exc_info=True)
|
||||
result['errors'].append(str(e))
|
||||
|
||||
return result
|
||||
|
||||
# ========== HELPER METHODS ==========
|
||||
|
||||
async def _create_empty_slot(self, betnr: int, advo_komm: Dict) -> None:
|
||||
"""Erstellt leeren Slot für gelöschten Eintrag"""
|
||||
try:
|
||||
komm_id = advo_komm['id']
|
||||
bemerkung = advo_komm.get('bemerkung') or ''
|
||||
marker = parse_marker(bemerkung)
|
||||
|
||||
if not marker:
|
||||
self.logger.warning(f"[KOMM] Kein Marker gefunden für gelöschten Eintrag: {komm_id}")
|
||||
return
|
||||
|
||||
kommkz = marker['kommKz']
|
||||
slot_marker = create_slot_marker(kommkz)
|
||||
|
||||
update_data = {
|
||||
'tlf': '',
|
||||
'bemerkung': slot_marker,
|
||||
'online': False
|
||||
}
|
||||
|
||||
await self.advoware.update_kommunikation(betnr, komm_id, update_data)
|
||||
self.logger.info(f"[KOMM] ✅ Created empty slot: komm_id={komm_id}, kommKz={kommkz}")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"[KOMM] Fehler beim Erstellen von Empty Slot: {e}", exc_info=True)
|
||||
|
||||
def _needs_update(self, advo_komm: Dict, espo_item: Dict) -> bool:
|
||||
"""Prüft ob Update nötig ist"""
|
||||
current_value = (advo_komm.get('tlf') or '').strip()
|
||||
new_value = espo_item['value'].strip()
|
||||
|
||||
current_online = advo_komm.get('online', False)
|
||||
new_online = espo_item.get('primary', False)
|
||||
|
||||
return current_value != new_value or current_online != new_online
|
||||
|
||||
async def _update_kommunikation(self, betnr: int, advo_komm: Dict, espo_item: Dict) -> None:
|
||||
"""Updated Advoware Kommunikation"""
|
||||
try:
|
||||
komm_id = advo_komm['id']
|
||||
value = espo_item['value']
|
||||
|
||||
# Erkenne kommKz (sollte aus Marker kommen)
|
||||
bemerkung = advo_komm.get('bemerkung') or ''
|
||||
marker = parse_marker(bemerkung)
|
||||
kommkz = marker['kommKz'] if marker else detect_kommkz(value, espo_type=espo_item.get('type'))
|
||||
|
||||
# Behalte User-Bemerkung
|
||||
user_text = get_user_bemerkung(advo_komm)
|
||||
new_marker = create_marker(value, kommkz, user_text)
|
||||
|
||||
update_data = {
|
||||
'tlf': value,
|
||||
'bemerkung': new_marker,
|
||||
'online': espo_item.get('primary', False)
|
||||
}
|
||||
|
||||
await self.advoware.update_kommunikation(betnr, komm_id, update_data)
|
||||
self.logger.info(f"[KOMM] ✅ Updated: komm_id={komm_id}, value={value[:30]}...")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"[KOMM] Fehler beim Update: {e}", exc_info=True)
|
||||
|
||||
async def _create_or_reuse_kommunikation(self, betnr: int, espo_item: Dict,
|
||||
advo_kommunikationen: List[Dict]) -> bool:
|
||||
"""
|
||||
Erstellt neue Kommunikation oder nutzt leeren Slot
|
||||
|
||||
Returns:
|
||||
True wenn erfolgreich erstellt/reused
|
||||
"""
|
||||
try:
|
||||
value = espo_item['value']
|
||||
|
||||
# Erkenne kommKz mit EspoCRM type
|
||||
espo_type = espo_item.get('type', 'email' if '@' in value else None)
|
||||
kommkz = detect_kommkz(value, espo_type=espo_type)
|
||||
self.logger.info(f"[KOMM] 🔍 kommKz detection: value='{value[:30]}...', espo_type={espo_type}, kommKz={kommkz}")
|
||||
|
||||
# Suche leeren Slot mit passendem kommKz
|
||||
empty_slot = find_empty_slot(kommkz, advo_kommunikationen)
|
||||
|
||||
new_marker = create_marker(value, kommkz)
|
||||
|
||||
if empty_slot:
|
||||
# ========== REUSE SLOT ==========
|
||||
komm_id = empty_slot['id']
|
||||
self.logger.info(f"[KOMM] ♻️ Reusing empty slot: komm_id={komm_id}, kommKz={kommkz}")
|
||||
update_data = {
|
||||
'tlf': value,
|
||||
'bemerkung': new_marker,
|
||||
'online': espo_item.get('primary', False)
|
||||
}
|
||||
|
||||
await self.advoware.update_kommunikation(betnr, komm_id, update_data)
|
||||
self.logger.info(f"[KOMM] ✅ Slot reused successfully: value='{value[:30]}...'")
|
||||
|
||||
else:
|
||||
# ========== CREATE NEW ==========
|
||||
self.logger.info(f"[KOMM] ➕ Creating new kommunikation entry: kommKz={kommkz}")
|
||||
create_data = {
|
||||
'tlf': value,
|
||||
'bemerkung': new_marker,
|
||||
'kommKz': kommkz,
|
||||
'online': espo_item.get('primary', False)
|
||||
}
|
||||
|
||||
await self.advoware.create_kommunikation(betnr, create_data)
|
||||
self.logger.info(f"[KOMM] ✅ Created new: value='{value[:30]}...', kommKz={kommkz}")
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"[KOMM] Fehler beim Erstellen/Reuse: {e}", exc_info=True)
|
||||
return False
|
||||
|
||||
|
||||
# ========== CHANGE DETECTION ==========
|
||||
|
||||
def detect_kommunikation_changes(old_bet: Dict, new_bet: Dict) -> bool:
|
||||
"""
|
||||
Erkennt Änderungen in Kommunikationen via rowId
|
||||
|
||||
Args:
|
||||
old_bet: Alte Beteiligte-Daten (mit kommunikation[])
|
||||
new_bet: Neue Beteiligte-Daten (mit kommunikation[])
|
||||
|
||||
Returns:
|
||||
True wenn Änderungen erkannt
|
||||
"""
|
||||
old_komm = old_bet.get('kommunikation', [])
|
||||
new_komm = new_bet.get('kommunikation', [])
|
||||
|
||||
# Check Count
|
||||
if len(old_komm) != len(new_komm):
|
||||
return True
|
||||
|
||||
# Check rowIds
|
||||
old_row_ids = {k.get('rowId') for k in old_komm}
|
||||
new_row_ids = {k.get('rowId') for k in new_komm}
|
||||
|
||||
return old_row_ids != new_row_ids
|
||||
|
||||
|
||||
def detect_espocrm_kommunikation_changes(old_data: Dict, new_data: Dict) -> bool:
|
||||
"""
|
||||
Erkennt Änderungen in EspoCRM emailAddressData/phoneNumberData
|
||||
|
||||
Returns:
|
||||
True wenn Änderungen erkannt
|
||||
"""
|
||||
old_emails = old_data.get('emailAddressData', [])
|
||||
new_emails = new_data.get('emailAddressData', [])
|
||||
|
||||
old_phones = old_data.get('phoneNumberData', [])
|
||||
new_phones = new_data.get('phoneNumberData', [])
|
||||
|
||||
# Einfacher Vergleich: Count und Values
|
||||
if len(old_emails) != len(new_emails) or len(old_phones) != len(new_phones):
|
||||
return True
|
||||
|
||||
old_email_values = {e.get('emailAddress') for e in old_emails}
|
||||
new_email_values = {e.get('emailAddress') for e in new_emails}
|
||||
|
||||
old_phone_values = {p.get('phoneNumber') for p in old_phones}
|
||||
new_phone_values = {p.get('phoneNumber') for p in new_phones}
|
||||
|
||||
return old_email_values != new_email_values or old_phone_values != new_phone_values
|
||||
Reference in New Issue
Block a user