Intégration API

SugarCRM API sous Symfony : SDK fiable pour le run métier

Jérémy Chomel Dawap
  • Publié le : 31 janvier 2025
  • Mis à jour le : 12 novembre 2026
  • Temps de lecture : 10 minutes
  1. Choisir la frontière entre le worker et le SDK
  2. Isoler le client HTTP et la session Sugar
  3. Lire, modifier et relire le compte en PHP
  4. Matrice de décision pour les réponses SugarCRM
  5. Reprendre une demande interrompue dans Messenger
  6. Guides complémentaires sur les écritures CRM
  7. Plan de test avec MockHttpClient
  8. Conclusion. Séparer la valeur et la preuve d’exécution
Portrait de Jérémy Chomel

Le worker Symfony envoie un PUT sur SugarCRM, puis perd la connexion. Le téléphone du compte peut déjà avoir changé. Si le message repart automatiquement, le deuxième appel peut déclencher un traitement aval une seconde fois ou rétablir une valeur remplacée depuis.

Le risque se situe entre l’envoi et la confirmation. Concrètement, le client HTTP doit distinguer trois issues. La valeur est déjà celle attendue, la demande a été refusée ou le résultat reste indéterminé. Le worker peut alors choisir entre clôturer, corriger la cause et relire.

Le pilier SugarCRM définit la référence du compte et les champs que l’ERP peut modifier. Dans une intégration API SugarCRM, le SDK traduit cette règle en une requête limitée à phone_office et en un résultat que Messenger peut enregistrer.

Prenons le même compte fictif NE-04712. Un identifiant Sugar a déjà été associé à cette référence ERP. À partir de cet identifiant, on va construire un client Symfony qui peut relire la valeur après une coupure et tester ce comportement avec des réponses simulées.

Choisir la frontière entre le worker et le SDK

Transmettre une intention et une valeur précédente

Le worker remet au SDK l’identifiant Sugar, le téléphone attendu avant modification, la nouvelle valeur déjà normalisée et un jeton actif. L’identifiant vient du registre de rapprochement. Le worker reste responsable de l’autorisation de changer le champ et de la version de la demande ERP. Le SDK n’effectue aucune recherche approximative par nom et ne crée aucun compte.

Si un compte a fusionné depuis la création du message, la relecture par identifiant peut échouer. La file suspend alors cette demande et le référent CRM examine la correspondance. Une recréation à partir du numéro de téléphone déplacerait le problème vers la fiche et ses relations.

Isoler le client HTTP et la session Sugar

Configurer l’origine et la version par environnement

Créez un client HTTP Symfony dédié, avec une base_uri HTTPS définie en configuration et terminée par /rest/v11/ dans cet exemple. Confirmez la version et les opérations disponibles dans l’aide REST de l’instance. Injectez ce client dans le SDK. Le code ne prend ni l’URL de destination ni la version dans le message de la file.

Sugar documente le jeton obtenu via /oauth2/token et l’en-tête OAuth-Token utilisé dans ses exemples REST. Un composant de session distinct gère le renouvellement et protège les secrets. Configurez la plateforme API avec l’administrateur Sugar afin d’éviter les conflits avec d’autres clients. L’option max_redirects à zéro protège la requête contre un déplacement inattendu de l’URL. Désactivez le retry automatique pour ce client d’écriture et vérifiez aussi ce point sur le proxy. Référence REST Sugar · Documentation Symfony HttpClient

Lire, modifier et relire le compte en PHP

Réserver le PUT au champ autorisé

Le premier GET vérifie l’identifiant et la valeur. Si le téléphone a déjà la valeur souhaitée, le SDK évite l’écriture. Si la valeur diffère de l’état précédent que la demande connaissait, le worker doit examiner ce conflit. Le PUT contient uniquement phone_office. Les exemples du fournisseur documentent cette lecture et la mise à jour par identifiant. Exemples Sugar de lecture et de mise à jour

Le client utilise une comparaison stricte. Alignez le format attendu sur celui que l’instance restitue, ou ajoutez une normalisation documentée et testée des deux côtés. Une valeur vide en entrée exige un contrat d’effacement distinct. Le code suppose que le jeton est déjà disponible.

<?php

use Symfony\Contracts\HttpClient\Exception\DecodingExceptionInterface;
use Symfony\Contracts\HttpClient\Exception\TransportExceptionInterface;
use Symfony\Contracts\HttpClient\HttpClientInterface;

final class SugarAccountPhone
{
    public function __construct(
        private readonly HttpClientInterface $client,
    ) {
    }

    public function update(
        string $accountId,
        string $before,
        string $desired,
        string $token,
    ): string {
        if (!$this->hasValidTarget($accountId, $desired)) {
            return 'demande_invalide';
        }

        [$state, $current] = $this->read($accountId, $token);
        if ($state !== 'lecture_ok') {
            return $state;
        }

        if ($current === $desired) {
            return 'deja_conforme';
        }

        if ($current !== $before) {
            return 'conflit_avant_ecriture';
        }

        try {
            $response = $this->client->request('PUT', 'Accounts/' . $accountId, $this->options($token) + [
                'json' => ['phone_office' => $desired],
            ]);
            $status = $response->getStatusCode();
            $response->cancel();

            if ($status >= 300 && $status < 500 && $status !== 408) {
                return 'ecriture_http_' . $status;
            }
        } catch (TransportExceptionInterface) {
            // L'écriture peut avoir été appliquée avant la coupure.
        }

        return $this->reconcile($accountId, $desired, $token);
    }

    public function reconcile(string $accountId, string $desired, string $token): string
    {
        if (!$this->hasValidTarget($accountId, $desired)) {
            return 'demande_invalide';
        }

        [$state, $current] = $this->read($accountId, $token);

        return $state === 'lecture_ok' && $current === $desired
            ? 'valeur_confirmee'
            : 'resultat_indetermine';
    }

    private function hasValidTarget(string $accountId, string $desired): bool
    {
        return preg_match('/^[A-Za-z0-9_-]+$/D', $accountId) === 1 && trim($desired) !== '';
    }

    private function options(string $token): array
    {
        return [
            'headers' => ['OAuth-Token' => $token, 'Accept' => 'application/json'],
            'max_redirects' => 0,
            'timeout' => 3,
            'max_duration' => 10,
        ];
    }

    private function read(string $accountId, string $token): array
    {
        try {
            $response = $this->client->request('GET', 'Accounts/' . $accountId, $this->options($token) + [
                'query' => ['fields' => 'id,phone_office'],
            ]);
            $status = $response->getStatusCode();
            if ($status !== 200) {
                $response->cancel();

                return ['lecture_http_' . $status, null];
            }

            $data = $response->toArray(false);
        } catch (TransportExceptionInterface) {
            return ['lecture_transport', null];
        } catch (DecodingExceptionInterface) {
            return ['lecture_inexploitable', null];
        }

        if (($data['id'] ?? null) !== $accountId || !is_string($data['phone_office'] ?? null)) {
            return ['lecture_inexploitable', null];
        }

        return ['lecture_ok', $data['phone_office']];
    }
}

Le délai d’inactivité et la durée maximale ci-dessus sont des valeurs d’exemple par requête. Le worker doit prévoir un budget total compatible avec une lecture, une écriture et une vérification. Le serveur peut appliquer une écriture après l’expiration du délai côté client. Après un résultat indéterminé, la prochaine action est une relecture seule. Comparez les possibilités de verrouillage ou de mise à jour conditionnelle de l’instance avant de confier le même champ à plusieurs auteurs.

Matrice de décision pour les réponses SugarCRM

Suites possibles d’une mise à jour du téléphone
ObservationRésultat du SDKAction du worker
Le premier GET lit la valeur cible.Déjà conforme.Clore l’écart de valeur sans PUT.
Le premier GET lit une troisième valeur.Conflit avant écriture.Conserver la valeur observée et faire arbitrer.
Le PUT reçoit 401 ou 403.Écriture HTTP 401 ou 403.Contrôler la session ou les droits, puis réévaluer la demande.
Le PUT expire, puis le GET lit la cible.Valeur confirmée.Clore l’écart et vérifier à part les effets attendus.
La relecture échoue ou lit une autre valeur.Résultat indéterminé.Planifier une relecture seule et suspendre la relance de l’écriture.

Un 429 est remonté au worker. Celui-ci applique la politique de quota observée sur l’instance, puis relit l’état avant de réévaluer l’écriture. Un 404 sur la fiche mérite une vérification du rapprochement et de la visibilité avec le compte technique. Ces réponses ne justifient ni une création automatique ni la relance de tout le lot.

Reprendre une demande interrompue dans Messenger

Enregistrer l’intention avant l’envoi

Avant d’appeler le SDK, le worker enregistre l’intention d’écriture et un identifiant stable de commande. Si le processus tombe entre l’envoi et la journalisation du résultat, le message redélivré retrouve l’état « à réconcilier ». Le worker appelle alors reconcile(), qui lit la fiche sans modifier la valeur. La file peut différer une nouvelle lecture si SugarCRM reste indisponible.

La trace minimale relie l’identifiant de commande, la référence ERP, l’identifiant Sugar, le champ et le dernier résultat. Conservez les valeurs utiles à la comparaison dans le stockage de reprise protégé, sans exposer les jetons ni les coordonnées dans les logs. Si le premier worker et une redélivrance démarrent ensemble, la réservation de la commande doit empêcher deux envois côté connecteur. Elle ne bloque pas les changements effectués dans Sugar.

Un téléphone conforme prouve la valeur lue, indépendamment de la cause de sa modification. Si une notification ou une intégration aval doit être déclenchée une seule fois, rapprochez son propre identifiant ou son journal. Faute de preuve de cet effet, gardez une action de suivi distincte du rapprochement de la valeur.

Guides complémentaires sur les écritures CRM

Le guide de raccordement SugarCRM précise comment choisir l’identifiant du compte et répartir les champs entre ERP et CRM. Lisez-le avant d’ajouter une recherche ou une création à ce client.

Si une relance concerne une opportunité, le guide de reprise sans écraser une correction commerciale traite le cas où un champ a changé depuis la demande d’origine.

Le guide des SDK Symfony pour CRM aide à mutualiser les traces et les tests entre connecteurs. Les règles de lecture et d’écriture restent à confirmer pour chaque éditeur.

Plan de test avec MockHttpClient

Avec MockHttpClient, faites varier la réponse du premier GET, le statut du PUT et le résultat de la relecture. Inspectez la méthode, l’URL et le JSON envoyés. Le test du scénario de coupure doit compter exactement un PUT et vérifier que le dernier appel est un GET.

  1. Vérifiez que la fiche déjà conforme et la fiche divergente ne déclenchent aucune écriture.
  2. Simulez une réponse perdue après le PUT, puis une relecture conforme et une relecture divergente. Les deux cas ont des résultats distincts.
  3. Renvoyez l’identifiant d’un autre compte dans un HTTP 200. Vérifiez que le SDK refuse cette lecture et n’envoie aucun PUT.
  4. Simulez la redélivrance du message au niveau du worker. Vérifiez que la commande en attente de rapprochement suit le chemin de lecture seule.

Les mocks valident les décisions du code. Complétez la recette sur l’instance de test pour confirmer la version REST, les droits, le format du téléphone et les effets déclenchés par l’écriture. Suspendez l’ouverture du flux si un scénario incertain déclenche un deuxième PUT sans décision de reprise.

Conclusion. Séparer la valeur et la preuve d’exécution

Le client Symfony lit d’abord la fiche, puis limite son écriture à un champ sur l’identifiant déjà rapproché. Après une coupure, la comparaison du téléphone et de l’identifiant donne un résultat contrôlable.

Le worker conserve l’intention d’écriture et traite à part le cas où l’état de la fiche reste inconnu. Les effets aval gardent leur propre preuve.

Commencez la recette avec une fiche sans écriture, une fiche modifiable et un résultat indéterminé. Le support doit pouvoir lire le journal et choisir la suite pour chacune.

Pour valider ce parcours avec votre instance, notre équipe d’intégration API SugarCRM peut cadrer la session, les permissions et les essais de reprise avec vos développeurs Symfony.

Portrait de Jérémy Chomel

Cadrer votre client Symfony pour SugarCRM

Définissez les droits, les champs autorisés et la relecture après une réponse perdue.

Articles recommandés

SugarCRM API : intégrer le CRM sans casser le run métier Intégration API SugarCRM API : intégrer le CRM sans casser le run métier Lire l'article
  • 9 septembre 2024
  • Lecture ~9 min

L’ERP doit corriger le téléphone d’un compte pendant que les ventes réattribuent une opportunité. Avec le compte fictif NE-04712, suivez la mise à jour du seul champ autorisé, la relecture après une coupure et la recherche de la fiche conservée après une fusion. Cinq situations de recette aident à choisir quand reprendre ou isoler une écriture.

SugarCRM : rejouer une mise à jour sans écraser la décision du commercial Intégration API SugarCRM : rejouer une mise à jour sans écraser la décision du commercial Lire l'article
  • 17 avril 2026
  • Lecture ~3 min

Une référence ERP reste à transmettre alors que le montant de l’opportunité a été corrigé. Le cas fictif OP-472 montre quand confirmer une référence déjà présente, quand écrire uniquement le champ autorisé et quand suspendre la reprise pour vérifier le lien entre la commande et le montant commercial.

Illustration du guide sur les adaptateurs CRM sous Symfony Intégration API SDK API CRM : unifier les connecteurs sous Symfony Lire l'article
  • 24 janvier 2025
  • Lecture ~17 min

Une opportunité gagnée part vers l’ERP et la réponse expire. Le socle Symfony doit retrouver la commande avant tout nouvel envoi, puis inscrire sa référence dans le CRM. Voyez quelles décisions partager, quels contrôles confier aux adaptateurs et comment tester la lecture d’un deal Pipedrive avec un client simulé.

Testing API : fiabilisez vos intégrations – guide 2025 Intégration API Testing API : fiabilisez vos intégrations – guide 2025 Lire l'article
  • 15 août 2024
  • Lecture ~14 min

Tester une API utilement ne consiste pas à cocher un happy path. Le vrai enjeu est de savoir si la reprise, le rejet et le support restent lisibles quand un lot part en production. Reliez le sujet à notre offre d’intégration API pour réduire le coût complet d’un écart avant l’incident. Le support garde un cadre lisible.

Tester la reprise de votre flux SugarCRM

Reproduisez une réponse perdue et vérifiez la décision du worker avant toute relance.