---
title: "ApparelMagic und TradeByte: Analyse komplexer Integrationen"
date: "2024-02-09"
excerpt: "Detaillierte Analyse einer E-Commerce-Integration zwischen Apparel Magic und Breuninger via TradeByte"
category: "System Integration"
coverImage: "/images/posts/erp-integration-breuninger/cover.jpg"
tags: ["ERP", "Apparel Magic", "TradeByte", "API Integration", "Python", "MariaDB"]
---

# Apparel Magic meets Breuninger: Eine technische Analyse der TradeByte-Integration

Die Integration von E-Commerce-Systemen mit etablierten Marktplätzen stellt Unternehmen vor besondere Herausforderungen. In diesem Artikel teile ich meine Erfahrungen aus einem komplexen Integrationsprojekt zwischen Apparel Magic als ERP-System und der Breuninger-Plattform über TradeByte.

## Projekthintergrund

Das Projekt umfasste die Integration von zwei Hauptsystemen:
- Apparel Magic als ERP-System für Produktdaten und Bestandsmanagement
- TradeByte als Middleware für die Breuninger-Plattform

Die Hauptherausforderungen lagen in:
- Bidirektionale Synchronisation von Bestellungen
- Automatisierte Kundenanlage
- Verwaltung von Lieferscheinen
- Bestandsmanagement in Echtzeit

## Technische Architektur

### Zentrale Komponenten

```python
# Core system architecture
SYSTEMS = {
    'apparelmagic': {
        'type': 'ERP',
        'api': 'REST',
        'auth': 'Token'
    },
    'tradebyte': {
        'type': 'Middleware',
        'api': 'REST + XML',
        'auth': 'Basic'
    }
}
```

### Middleware-Datenbank

Die MariaDB-Datenbank fungiert als zentraler Datenspeicher für die Integration:

```sql
CREATE TABLE a_order (
    order_id INT PRIMARY KEY AUTO_INCREMENT,
    tb_order_id VARCHAR(50),
    apparelmagic_account_number VARCHAR(50),
    apparelmagic_warehouse_id INT,
    apparelmagic_division_id INT,
    breuninger_channel_id VARCHAR(50),
    breuninger_channel_number VARCHAR(50),
    breuninger_order_date DATETIME,
    breuninger_payment_type VARCHAR(50),
    breuninger_shipment_price DECIMAL(10,2),
    delivery_note VARCHAR(255),
    done DATETIME,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
```

## API-Integrationen

### Apparel Magic API

Die REST-API von Apparel Magic wird für Kundenanlage und Bestandsmanagement verwendet:

```python
def make_request(endpoint, method='GET', data=None):
    url = f"{APPARELMAGIC_API_URL}{endpoint}"
    params = {
        "time": str(int(time.time())),
        "token": APPARELMAGIC_TOKEN
    }
    try:
        if method == 'GET':
            response = requests.get(url, params=params)
        elif method == 'POST':
            response = requests.post(url, params=params, json=data)
        else:
            raise ValueError(f"Unsupported HTTP method: {method}")

        response.raise_for_status()
        return response.json()
    except requests.RequestException as e:
        logger.error(f"Error making request to ApparelMagic API: {e}")
        raise
```

### TradeByte Integration

Die TradeByte-API verwendet eine Kombination aus REST und XML:

```python
def get_orders():
    response = make_request("orders/?channel=289")

    if not response.content:
        logger.info("No new orders to process. All existing orders have been exported.")
        return []

    try:
        root = ET.fromstring(response.content)
        orders = []
        for order in root.findall('.//ORDER'):
            order_data = {child.tag: child.text for child in order.iter() if child.tag != 'ORDER'}
            orders.append(order_data)
        return orders
    except ET.ParseError as e:
        logger.error(f"Failed to parse XML response: {e}")
        return []
```

## Bestellprozess

Der Bestellprozess folgt einem klaren Ablauf:

1. Regelmäßiger Abruf neuer Bestellungen von TradeByte
2. Automatische Kundenanlage in Apparel Magic
3. Bestellverarbeitung und Statusaktualisierung
4. Generierung und Speicherung von Lieferscheinen

### Lieferschein-Management

```python
def fetch_and_save_delivery_note(tb_order_id):
    logger.info(f"Fetching delivery note for order {tb_order_id}")
    delivery_note_content = get_delivery_note(tb_order_id)

    if delivery_note_content:
        try:
            file_path = save_delivery_note(tb_order_id, delivery_note_content)
            update_order_with_delivery_note(tb_order_id, file_path)
        except Exception as e:
            logger.error(f"Error saving delivery note for order {tb_order_id}: {e}")
```

## Herausforderungen und Lösungen

### 1. Status-Management

Eine besondere Herausforderung war das Management von Bestellstatus:

```python
def update_order_status(order_response: OrderResponse):
    logger.info(f"Updating status for order {order_response.tb_order_id}")
    xml_data = generate_xml(order_response)
    status_code, response_text = send_order_status(xml_data)

    if status_code == 200:
        logger.info(f"Successfully updated order status")
        mark_order_as_done(order_response.tb_order_id)
    else:
        logger.error(f"Failed to update status. Code: {status_code}")
```

### 2. Fehlerbehandlung und Monitoring

Robuste Fehlerbehandlung war essentiell für den Produktivbetrieb:

```python
@contextmanager
def get_db_connection():
    connection = None
    try:
        config = DB_CONFIG.copy()
        config['charset'] = 'utf8mb4'
        config['collation'] = 'utf8mb4_general_ci'

        connection = mysql.connector.connect(**config)
        logger.info("Database connection established")
        yield connection
    except Error as e:
        logger.error(f"Database error: {e}")
        raise
    finally:
        if connection and connection.is_connected():
            connection.close()
```

## Best Practices

1. **API-Kommunikation**
   - Implementierung von Retry-Mechanismen
   - Sorgfältiges Error Handling
   - Ausführliches Logging aller Kommunikation

2. **Datenmanagement**
   - Zentrale Datenhaltung in MariaDB
   - Transaktionssicherheit bei kritischen Operationen
   - Regelmäßige Datenvalidierung

3. **Prozessautomatisierung**
   - Automatisierte Kundenanlage
   - Automatische Statusaktualisierungen
   - Systematisches Lieferschein-Management

## Lessons Learned

1. **API-Design**
   - Gründliche API-Dokumentation ist essentiell
   - Verständnis der verschiedenen Authentifizierungsmethoden
   - Berücksichtigung von Rate Limits

2. **Datenvalidierung**
   - Implementierung strenger Validierungsregeln
   - Sorgfältige Handhabung von Sonderfällen
   - Automatische Datenbereinigung

3. **Prozessoptimierung**
   - Kontinuierliche Verbesserung der Automatisierung
   - Regelmäßige Performance-Überprüfungen
   - Proaktives Monitoring

## Fazit

Die erfolgreiche Integration zwischen Apparel Magic und Breuninger über TradeByte erforderte:
- Tiefes Verständnis beider Systeme
- Sorgfältige Implementierung der API-Kommunikation
- Robuste Fehlerbehandlung
- Kontinuierliches Monitoring

Die entwickelte Lösung verarbeitet erfolgreich Bestellungen und ermöglicht eine nahtlose Integration zwischen den Systemen. Besonders die automatisierte Kundenanlage und das Lieferschein-Management haben sich als effizienzsteigernd erwiesen.