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
| Observation | Résultat du SDK | Action 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.
- Vérifiez que la fiche déjà conforme et la fiche divergente ne déclenchent aucune écriture.
- 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.
- Renvoyez l’identifiant d’un autre compte dans un HTTP 200. Vérifiez que le SDK refuse cette lecture et n’envoie aucun PUT.
- 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.