Magento 2 + AFAS koppelen: orderflow en voorraadbeheer geautomatiseerd

Magento 2 + AFAS koppelen: orderflow en voorraadbeheer geautomatiseerd

Orders handmatig overzetten tussen Magento 2 en AFAS kost je gemiddeld 4 tot 8 minuten per order. Bij 50 orders per dag is dat een halve fte puur voor data-overschrijven. Dat is geld dat je uitgeeft aan werk dat een machine beter doet.

Een AFAS-koppeling lost dit op. Maar er zijn meerdere manieren om die koppeling te bouwen — en de keuze heeft grote gevolgen voor betrouwbaarheid, onderhoudskosten en schaalbaarheid. Dit artikel legt uit hoe wij het aanpakken.

Wat je leert in dit artikel

• Welke datastromen je tussen Magento 2 en AFAS moet synchroniseren
• Directe koppeling vs middleware: de voor- en nadelen
• Hoe order sync, debiteurenbeheer en voorraadupdates technisch werken
• De meest gemaakte fouten bij AFAS-integraties
• Wat een koppeling realistisch kost en hoe lang het duurt

Wat synchroniseer je tussen Magento 2 en AFAS?

Een AFAS-koppeling is nooit een enkelvoudige datastroom. Er zijn altijd meerdere objecten die in beide systemen leven en gesynchroniseerd moeten worden.

Orders: van Magento naar AFAS

De meest gevraagde datastroom. Een order die in Magento 2 geplaatst wordt, moet als verkooporder in AFAS terechtkomen — inclusief orderregels, btw-bedragen, kortingen en afleveradres.

Technisch gaat dit via de AFAS GetConnector/UpdateConnector API. AFAS gebruikt een SOAP-interface (GetConnectors voor lezen, UpdateConnectors voor schrijven), maar heeft ook een REST API via de App Connector. De REST variant is moderner en makkelijker te implementeren.

// Voorbeeld: order exporteren naar AFAS via REST App Connector
$orderData = [
    'DbId' => 'FbSalesOrder',
    'Element' => [
        '@SoOr' => '', // Ordernummer automatisch genereren
        'Dbco' => $debiteurCode,
        'CuId' => 'EUR',
        'VaDu' => $order->getCreatedAt(),
        'SoLi' => $this->buildOrderLines($order),
    ]
];

$response = $this->afasClient->post('/profitrestservices/connectors/FbSalesOrder', $orderData);

Belangrijk detail: AFAS werkt met debiteuren, niet met klanten in de Magento-zin. Elke klant in Magento moet een debiteurnummer hebben in AFAS. Dat koppelen is stap één.

Debiteuren: aanmaken en synchroniseren

Nieuwe klanten in Magento 2 moeten als debiteur in AFAS aangemaakt worden. Bestaande klanten moeten gesynchroniseerd blijven als ze een adres wijzigen.

De valkuil: dubbelgangers. Als je niet goed opzoekt of een debiteur al bestaat voordat je er een aanmaakt, krijg je dubbele debiteuren in AFAS. Dat leidt tot boekhoudkundige problemen.

// Controleer eerst of debiteur al bestaat
private function findOrCreateDebtor(CustomerInterface $customer): string
{
    $zoekResult = $this->afasClient->get(
        '/profitrestservices/connectors/KnContact',
        ['filterfieldids' => 'EmAd', 'filtervalues' => $customer->getEmail()]
    );

    if (!empty($zoekResult['rows'])) {
        return $zoekResult['rows'][0]['BcCo']; // Bestaand debiteurnummer teruggeven
    }

    // Nieuwe debiteur aanmaken
    return $this->createNewDebtor($customer);
}

Voorraad: van AFAS naar Magento

Voorraadupdates lopen de andere kant op. AFAS beheert de werkelijke voorraad — inclusief reserveringen voor andere kanalen, inkooporders en magazijnmutaties. Magento moet die data ontvangen.

Dit kan op twee manieren:

Pull is eenvoudiger te implementeren en robuuster bij uitval. Push is real-time maar vereist dat AFAS een webhook of notificatie kan sturen — dat is in AFAS beperkt mogelijk via Profit scripts of een middleware laag.

// Cron job: voorraadstanden ophalen uit AFAS
public function execute(): void
{
    $artikelen = $this->afasClient->get('/profitrestservices/connectors/FbStockItem', [
        'take' => 1000,
        'skip' => 0,
    ]);

    foreach ($artikelen['rows'] as $artikel) {
        $sku = $artikel['ItCd']; // Artikelcode = SKU
        $voorraad = $artikel['QuSt']; // Quantity in stock

        $this->stockRepository->updateBySku($sku, $voorraad);
    }
}

Directe koppeling vs middleware: wat is verstandiger?

Dit is de architectuurkeuze die de meeste impact heeft op je project.

Directe koppeling

Je bouwt een Magento 2 module die direct communiceert met de AFAS API. Magento roept AFAS aan, AFAS reageert, klaar.

• Minder componenten, minder dingen die kapot kunnen gaan
• Lagere initiële bouwkosten
• Eenvoudiger te debuggen bij problemen

• Als AFAS tijdelijk niet bereikbaar is, valt de order-verwerking stil
• Magento wordt direct afhankelijk van de beschikbaarheid van AFAS
• Moeilijker te hergebruiken als je later een tweede kanaal toevoegt (bijv. een B2B-portal)
• Geen centrale logging van alle datastromen

Middleware aanpak

Tussen Magento en AFAS plaatst je een integratie-laag — vaak een Laravel applicatie of een iPaaS-platform zoals Make (Integromat) of Boomi.

Magento stuurt events naar de middleware. De middleware vertaalt, queue't en synchroniseert naar AFAS.

Magento 2 → Message Queue (RabbitMQ/MySQL) → Middleware → AFAS API
                                           ← Voorraad updates ←

• AFAS-uitval blokkeert de webshop niet
• Centrale logging van alle synchronisaties
• Herbruikbaar bij meerdere kanalen
• Retry-mechanisme bij tijdelijke fouten
• Makkelijker te testen in isolatie

• Hogere initiële bouwkosten (20-40% meer)
• Meer componenten om te beheren en monitoren
• Meer kennis vereist om bij te houden

De message queue als buffer

Of je nu direct of via middleware koppelt: gebruik altijd een message queue voor orders die naar AFAS moeten.

Magento 2 heeft ingebouwde ondersteuning voor RabbitMQ en een MySQL-fallback. Een nieuwe order triggert een event, dat event wordt gepubliceerd op een queue, een consumer verwerkt de queue en stuurt naar AFAS.

<!-- etc/queue_topology.xml -->
<topology xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:noNamespaceSchemaLocation="urn:magento:framework-message-queue:etc/topology.xsd">
    <exchange name="magento-afas" type="topic" connection="amqp">
        <binding id="afas-order-export"
                 topic="afas.order.export"
                 destinationType="queue"
                 destination="afas.order.export"/>
    </exchange>
</topology>

<!-- etc/queue_consumer.xml -->
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:noNamespaceSchemaLocation="urn:magento:framework-message-queue:etc/consumer.xsd">
    <consumer name="afasOrderExport"
              queue="afas.order.export"
              connection="amqp"
              handler="Vendor\AfasIntegration\Model\AfasOrderExportConsumer::process"/>
</config>

Voordeel: als AFAS even niet reageert, stapelen de berichten op in de queue. Zodra AFAS weer beschikbaar is, worden alle openstaande orders alsnog verwerkt — zonder handmatige interventie.

Artikelsynchronisatie: bidirectioneel of eenrichtingsverkeer?

Een vraag die vaak laat in projecten opduikt: wie is leidend voor artikeldata?

In de praktijk werkt optie 1 beter voor bedrijven met een groot assortiment dat door inkoop wordt beheerd. Optie 2 werkt beter als marketing de productdata bezit.

Wat je in beide gevallen wil vermijden: bidirectionele synchronisatie van dezelfde velden. Dat leidt gegarandeerd tot conflicten.

Meest gemaakte fouten bij AFAS-integraties

Kosten en doorlooptijd

Een AFAS-Magento koppeling is geen weekproject. Realistische verwachtingen:

Dit zijn indicaties. De werkelijke kosten hangen af van de complexiteit van je AFAS-inrichting, het aantal uitzonderingen in je orderflow en de kwaliteit van de bestaande Magento-installatie.

Hoe wij AFAS-koppelingen aanpakken

Wij bouwen altijd middleware-first, tenzij het volume het niet rechtvaardigt. De redenen zijn praktisch: wij hebben meerdere klanten met AFAS-koppelingen en weten dat directe koppelingen op de lange termijn meer onderhoud vragen.

Een koppeling die wij gebouwd hebben voor een groothandel in technische artikelen verwerkt dagelijks 200+ orders zonder handmatige tussenkomst. De middleware loggt elke transactie, stuurt alerts bij fouten en heeft een retry-queue voor tijdelijke AFAS-uitval.

AFAS Profit Connectors: wat je moet weten voordat je begint

AFAS heeft twee soorten connectors: GetConnectors (ophalen) en UpdateConnectors (schrijven). Voor elke datastroom heb je een specifieke connector nodig die in AFAS geconfigureerd moet worden door een AFAS-beheerder of -partner.

Dit is een stap die vertraging oplevert als je er niet vroeg bij nadenkt. De AFAS-omgeving van je klant heeft soms niet de juiste connectors actief, of de connector-namen wijken af van de standaard. Inventariseer dit in de discovery-fase.

// Ophalen van beschikbare connectors via de REST API
$response = $this->afasClient->get('/profitrestservices/metainfo/get/connectors');

// Voorbeeld respons: array van beschikbare connectors
// ['FbSalesOrder', 'FbDebtors', 'KnContact', 'FbStockItem', ...]

Vraag je AFAS-contactpersoon om een lijst van actieve connectors en de bijbehorende veldnamen. Documenteer die centraal — het scheelt uren debuggen.

Monitoring en alerting: niet optioneel

Een AFAS-koppeling die stilzwijgend faalt is erger dan een koppeling die niet werkt. Orders die niet in AFAS terechtkomen worden niet gepickt. Voorraad die niet bijgewerkt wordt leidt tot overkopen.

Bouw altijd een monitoring-laag:

• Log elke API-aanroep met timestamp, payload en respons
• Stuur een alert als een order 30 minuten na aanmaak nog niet gesynchroniseerd is
• Rapporteer dagelijks het aantal gesynchroniseerde en gefaalde records
• Zet een health-check endpoint op die de verbinding met AFAS test

// Dagelijkse sync-rapportage per e-mail
public function sendDailySyncReport(): void
{
    $geslaagd = $this->syncLogRepository->countByStatusAndDate('success', today());
    $mislukt = $this->syncLogRepository->countByStatusAndDate('failed', today());
    $openstaand = $this->syncLogRepository->countByStatus('pending');

    $this->mailer->send(new DailySyncReport($geslaagd, $mislukt, $openstaand));
}

Dit klinkt als overhead. In de praktijk is dit de eerste functionaliteit die klanten waarderen — omdat het hen vertrouwen geeft dat de koppeling werkt.

Omgevingen: test, staging en productie

AFAS heeft aparte omgevingen (test en productie). Gebruik ze. Bouw en test altijd eerst op de AFAS-testomgeving voordat je met productie-data gaat werken.

Synchroniseer je Magento staging-omgeving met de AFAS-testomgeving. Nooit staging naar AFAS-productie — dat leidt tot testorders in het boekhoudsysteem van je klant.

Meer weten over ERP-integraties? Lees ook ons artikel over ERP koppelen aan Magento 2. Voor middleware-oplossingen, bekijk onze Alumio integratie-pagina. Bekijk ook onze Magento diensten voor een overzicht van wat wij doen.