Vendre de l'électricité SOCODE

curl -X POST "$UMEME_BASE_URL/ventes" \
  -H "Authorization: Bearer $UMEME_CLE" \
  -H "Content-Type: application/json" \
  -d '{
    "uuid": "94a223fe-fb34-47f2-aaa5-b80c4bf8a8eb",
    "compte": "SOCODE",
    "reference": "09900000000",
    "montant": 5
  }'

// Node.js 18 et plus : fetch est intégré.
const baseUrl = process.env.UMEME_BASE_URL;

const corps = {
  uuid: "94a223fe-fb34-47f2-aaa5-b80c4bf8a8eb",
  compte: "SOCODE",
  reference: "09900000000",
  montant: 5,
};

const reponse = await fetch(`${baseUrl}/ventes`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.UMEME_CLE}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify(corps),
});
const donnees = await reponse.json();

// npm install axios
import axios from "axios";

const umeme = axios.create({
  baseURL: process.env.UMEME_BASE_URL,
  headers: { Authorization: `Bearer ${process.env.UMEME_CLE}` },
  timeout: 30000,
});

const corps = {
  uuid: "94a223fe-fb34-47f2-aaa5-b80c4bf8a8eb",
  compte: "SOCODE",
  reference: "09900000000",
  montant: 5,
};

const { data } = await umeme.post("/ventes", corps);

import os

import requests

BASE_URL = os.environ["UMEME_BASE_URL"]
ENTETES = {"Authorization": f"Bearer {os.environ['UMEME_CLE']}"}

corps = {
    "uuid": "94a223fe-fb34-47f2-aaa5-b80c4bf8a8eb",
    "compte": "SOCODE",
    "reference": "09900000000",
    "montant": 5,
}

reponse = requests.post(
    f"{BASE_URL}/ventes",
    headers=ENTETES,
    json=corps,
    timeout=30,
)
donnees = reponse.json()

// composer require guzzlehttp/guzzle
$client = new GuzzleHttp\Client([
    'base_uri' => getenv('UMEME_BASE_URL') . '/',
    'headers' => ['Authorization' => 'Bearer ' . getenv('UMEME_CLE')],
    'timeout' => 30,
]);

$corps = [
    'uuid' => '94a223fe-fb34-47f2-aaa5-b80c4bf8a8eb',
    'compte' => 'SOCODE',
    'reference' => '09900000000',
    'montant' => 5,
];

$reponse = $client->post('ventes', [
    'json' => $corps,
]);
$donnees = json_decode($reponse->getBody(), true);

// Java 15 et plus : java.net.http et blocs de texte.
var baseUrl = System.getenv("UMEME_BASE_URL");
var client = HttpClient.newHttpClient();

var corps = """
    {
      "uuid": "94a223fe-fb34-47f2-aaa5-b80c4bf8a8eb",
      "compte": "SOCODE",
      "reference": "09900000000",
      "montant": 5
    }
    """;

var requete = HttpRequest.newBuilder(URI.create(baseUrl + "/ventes"))
    .header("Authorization", "Bearer " + System.getenv("UMEME_CLE"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(corps))
    .build();

var reponse = client.send(requete, HttpResponse.BodyHandlers.ofString());

selon vente.statut
  REUSSIE            → remettre le jeton et le reçu
  ECHOUEE            → prévenir le client (motifEchec.code)
  EN_COURS           → attendre le rappel
  EN_RECONCILIATION  → prévenir le client, ne pas relancer
  autre              → à examiner par vos équipes

// vente : le corps d'un rappel, ou la réponse de GET /v1/ventes/{uuid}.
export function traiter(vente, actions) {
  switch (vente.statut) {
    case "REUSSIE":
      return actions.remettreJetonEtRecu(vente.jeton, vente.urlRecu);
    case "ECHOUEE":
      return actions.prevenirClient(vente.motifEchec.code);
    case "EN_COURS":
      // Le rappel arrivera : rien à faire.
      return;
    case "EN_RECONCILIATION":
      // Umeme vérifie : prévenir le client, ne jamais relancer la vente.
      return actions.prevenirAttente(vente.uuid);
    default:
      // Un statut que ce code ne connaît pas : à examiner, sans rien conclure.
      return actions.signalerAuxEquipes(vente);
  }
}

# vente : le corps d'un rappel, ou la réponse de GET /v1/ventes/{uuid}.
def traiter(vente, actions):
    statut = vente["statut"]
    if statut == "REUSSIE":
        return actions.remettre_jeton_et_recu(vente.get("jeton"), vente["urlRecu"])
    if statut == "ECHOUEE":
        return actions.prevenir_client(vente["motifEchec"]["code"])
    if statut == "EN_COURS":
        # Le rappel arrivera : rien à faire.
        return None
    if statut == "EN_RECONCILIATION":
        # Umeme vérifie : prévenir le client, ne jamais relancer la vente.
        return actions.prevenir_attente(vente["uuid"])
    # Un statut que ce code ne connaît pas : à examiner, sans rien conclure.
    return actions.signaler_aux_equipes(vente)

<?php

// $vente : le corps d'un rappel, ou la réponse de GET /v1/ventes/{uuid}.
function traiter(array $vente, Actions $actions): void
{
    match ($vente['statut']) {
        'REUSSIE' => $actions->remettreJetonEtRecu($vente['jeton'] ?? null, $vente['urlRecu']),
        'ECHOUEE' => $actions->prevenirClient($vente['motifEchec']['code']),
        // Le rappel arrivera : rien à faire.
        'EN_COURS' => null,
        // Umeme vérifie : prévenir le client, ne jamais relancer la vente.
        'EN_RECONCILIATION' => $actions->prevenirAttente($vente['uuid']),
        // Un statut que ce code ne connaît pas : à examiner, sans rien conclure.
        default => $actions->signalerAuxEquipes($vente),
    };
}

// vente : le corps d'un rappel, ou la réponse de GET /v1/ventes/{uuid}.
static void traiter(Vente vente, Actions actions) {
    switch (vente.statut()) {
        case "REUSSIE" -> actions.remettreJetonEtRecu(vente.jeton(), vente.urlRecu());
        case "ECHOUEE" -> actions.prevenirClient(vente.motifEchec().code());
        // Le rappel arrivera : rien à faire.
        case "EN_COURS" -> { }
        // Umeme vérifie : prévenir le client, ne jamais relancer la vente.
        case "EN_RECONCILIATION" -> actions.prevenirAttente(vente.uuid());
        // Un statut que ce code ne connaît pas : à examiner, sans rien conclure.
        default -> actions.signalerAuxEquipes(vente);
    }
}

uuid ← nouvel UUID v4
enregistrer(commande, uuid, statut = A_ENVOYER)
essayer
  reponse ← POST /v1/ventes
sinon
  // délai dépassé ou erreur 5xx
  vente ← GET /v1/ventes/{uuid}
  si NON_TROUVEE → renvoyer la même vente, même uuid
  sinon → suivre vente.statut

import { randomUUID } from "node:crypto";

const BASE_URL = process.env.UMEME_BASE_URL;
const entetes = {
  Authorization: `Bearer ${process.env.UMEME_CLE}`,
  "Content-Type": "application/json",
};

// commandes : votre stockage, où l'uuid est écrit avant tout appel.
export async function vendre(commande, commandes) {
  const vente = {
    uuid: randomUUID(),
    compte: commande.compte,
    reference: commande.reference,
    montant: commande.montant,
  };
  await commandes.enregistrer(commande.id, { uuid: vente.uuid, statut: "A_ENVOYER" });

  try {
    const reponse = await fetch(`${BASE_URL}/ventes`, {
      method: "POST",
      headers: entetes,
      body: JSON.stringify(vente),
      signal: AbortSignal.timeout(30000),
    });
    if (reponse.status < 500) {
      return await reponse.json();
    }
  } catch {
    // Délai dépassé ou réseau coupé : rien n'est conclu, la vente est cherchée.
  }
  return retrouver(vente);
}

async function retrouver(vente) {
  const reponse = await fetch(`${BASE_URL}/ventes/${vente.uuid}`, { headers: entetes });
  if (reponse.status === 404) {
    // NON_TROUVEE : la vente n'est jamais arrivée, elle repart avec le même uuid.
    const renvoi = await fetch(`${BASE_URL}/ventes`, {
      method: "POST",
      headers: entetes,
      body: JSON.stringify(vente),
    });
    return renvoi.json();
  }
  return reponse.json();
}

import { randomUUID } from "node:crypto";
import axios from "axios";

const umeme = axios.create({
  baseURL: process.env.UMEME_BASE_URL,
  headers: { Authorization: `Bearer ${process.env.UMEME_CLE}` },
  timeout: 30000,
  // Les réponses 4xx sont des réponses : seul un 5xx ou un délai fait douter.
  validateStatus: (statut) => statut < 500,
});

// commandes : votre stockage, où l'uuid est écrit avant tout appel.
export async function vendre(commande, commandes) {
  const vente = {
    uuid: randomUUID(),
    compte: commande.compte,
    reference: commande.reference,
    montant: commande.montant,
  };
  await commandes.enregistrer(commande.id, { uuid: vente.uuid, statut: "A_ENVOYER" });

  try {
    const { data } = await umeme.post("/ventes", vente);
    return data;
  } catch {
    // Délai dépassé, réseau coupé ou erreur 5xx : rien n'est conclu, la vente est cherchée.
    return retrouver(vente);
  }
}

async function retrouver(vente) {
  const { status, data } = await umeme.get(`/ventes/${vente.uuid}`);
  if (status === 404) {
    // NON_TROUVEE : la vente n'est jamais arrivée, elle repart avec le même uuid.
    return (await umeme.post("/ventes", vente)).data;
  }
  return data;
}

import os
import uuid

import requests

BASE_URL = os.environ["UMEME_BASE_URL"]
ENTETES = {"Authorization": f"Bearer {os.environ['UMEME_CLE']}"}


# commandes : votre stockage, où l'uuid est écrit avant tout appel.
def vendre(commande, commandes):
    vente = {
        "uuid": str(uuid.uuid4()),
        "compte": commande["compte"],
        "reference": commande["reference"],
        "montant": commande["montant"],
    }
    commandes.enregistrer(commande["id"], uuid=vente["uuid"], statut="A_ENVOYER")

    try:
        reponse = requests.post(f"{BASE_URL}/ventes", headers=ENTETES, json=vente, timeout=30)
        if reponse.status_code < 500:
            return reponse.json()
    except requests.RequestException:
        # Délai dépassé ou réseau coupé : rien n'est conclu, la vente est cherchée.
        pass
    return retrouver(vente)


def retrouver(vente):
    reponse = requests.get(f"{BASE_URL}/ventes/{vente['uuid']}", headers=ENTETES, timeout=30)
    if reponse.status_code == 404:
        # NON_TROUVEE : la vente n'est jamais arrivée, elle repart avec le même uuid.
        return requests.post(f"{BASE_URL}/ventes", headers=ENTETES, json=vente, timeout=30).json()
    return reponse.json()

<?php

use GuzzleHttp\Client;
use GuzzleHttp\Exception\TransferException;
use Ramsey\Uuid\Uuid;

function umeme(): Client
{
    return new Client([
        'base_uri' => getenv('UMEME_BASE_URL') . '/',
        'headers' => ['Authorization' => 'Bearer ' . getenv('UMEME_CLE')],
        'timeout' => 30,
        // Les réponses 4xx sont des réponses : seul un 5xx ou un délai fait douter.
        'http_errors' => false,
    ]);
}

// $commandes : votre stockage, où l'uuid est écrit avant tout appel.
function vendre(array $commande, Commandes $commandes): array
{
    $vente = [
        'uuid' => Uuid::uuid4()->toString(),
        'compte' => $commande['compte'],
        'reference' => $commande['reference'],
        'montant' => $commande['montant'],
    ];
    $commandes->enregistrer($commande['id'], $vente['uuid'], 'A_ENVOYER');

    try {
        $reponse = umeme()->post('ventes', ['json' => $vente]);
        if ($reponse->getStatusCode() < 500) {
            return json_decode($reponse->getBody(), true);
        }
    } catch (TransferException $e) {
        // Délai dépassé ou réseau coupé : rien n'est conclu, la vente est cherchée.
    }
    return retrouver($vente);
}

function retrouver(array $vente): array
{
    $reponse = umeme()->get('ventes/' . $vente['uuid']);
    if ($reponse->getStatusCode() === 404) {
        // NON_TROUVEE : la vente n'est jamais arrivée, elle repart avec le même uuid.
        $reponse = umeme()->post('ventes', ['json' => $vente]);
    }
    return json_decode($reponse->getBody(), true);
}

static final String BASE_URL = os.environ["UMEME_BASE_URL"];
static final HttpClient CLIENT = HttpClient.newBuilder()
    .connectTimeout(Duration.ofSeconds(10))
    .build();

// commandes : votre stockage, où l'uuid est écrit avant tout appel.
static String vendre(Commande commande, Commandes commandes) throws Exception {
    var uuid = UUID.randomUUID().toString();
    commandes.enregistrer(commande.id(), uuid, "A_ENVOYER");
    var vente = """
        {"uuid": "%s", "compte": "%s", "reference": "%s", "montant": %s}
        """.formatted(uuid, commande.compte(), commande.reference(), commande.montant());

    try {
        var reponse = CLIENT.send(requete("/ventes", vente), HttpResponse.BodyHandlers.ofString());
        if (reponse.statusCode() < 500) {
            return reponse.body();
        }
    } catch (IOException e) {
        // Délai dépassé ou réseau coupé : rien n'est conclu, la vente est cherchée.
    }
    return retrouver(uuid, vente);
}

static String retrouver(String uuid, String vente) throws Exception {
    var reponse = CLIENT.send(requete("/ventes/" + uuid, null), HttpResponse.BodyHandlers.ofString());
    if (reponse.statusCode() == 404) {
        // NON_TROUVEE : la vente n'est jamais arrivée, elle repart avec le même uuid.
        reponse = CLIENT.send(requete("/ventes", vente), HttpResponse.BodyHandlers.ofString());
    }
    return reponse.body();
}

static HttpRequest requete(String chemin, String corps) {
    var requete = HttpRequest.newBuilder(URI.create(BASE_URL + chemin))
        .header("Authorization", "Bearer " + System.getenv("UMEME_CLE"))
        .timeout(Duration.ofSeconds(30));
    if (corps == null) {
        return requete.GET().build();
    }
    return requete.header("Content-Type", "application/json")
        .POST(HttpRequest.BodyPublishers.ofString(corps))
        .build();
}

toutes les 5 minutes
  pour chaque vente EN_COURS depuis plus de 15 minutes
    vente ← GET /v1/ventes/{uuid}
    si NON_TROUVEE → renvoyer la même vente, même uuid
    sinon → traiter(vente.statut)

const BASE_URL = process.env.UMEME_BASE_URL;
const entetes = { Authorization: `Bearer ${process.env.UMEME_CLE}` };

// commandes : votre stockage ; traiter : la fonction qui applique un statut.
export async function reprendre(commandes, traiter) {
  const enAttente = await commandes.enCoursDepuis(15 * 60 * 1000);
  for (const commande of enAttente) {
    const reponse = await fetch(`${BASE_URL}/ventes/${commande.uuid}`, { headers: entetes });
    if (reponse.status === 404) {
      // NON_TROUVEE : la vente n'est jamais arrivée, elle repart avec le même uuid.
      await commandes.renvoyer(commande);
      continue;
    }
    traiter(await reponse.json());
  }
}

// Toutes les 5 minutes.
export function planifier(commandes, traiter) {
  return setInterval(() => reprendre(commandes, traiter), 5 * 60 * 1000);
}

import axios from "axios";

const umeme = axios.create({
  baseURL: process.env.UMEME_BASE_URL,
  headers: { Authorization: `Bearer ${process.env.UMEME_CLE}` },
  timeout: 30000,
  validateStatus: (statut) => statut < 500,
});

// commandes : votre stockage ; traiter : la fonction qui applique un statut.
export async function reprendre(commandes, traiter) {
  const enAttente = await commandes.enCoursDepuis(15 * 60 * 1000);
  for (const commande of enAttente) {
    const { status, data } = await umeme.get(`/ventes/${commande.uuid}`);
    if (status === 404) {
      // NON_TROUVEE : la vente n'est jamais arrivée, elle repart avec le même uuid.
      await commandes.renvoyer(commande);
      continue;
    }
    traiter(data);
  }
}

// Toutes les 5 minutes.
export function planifier(commandes, traiter) {
  return setInterval(() => reprendre(commandes, traiter), 5 * 60 * 1000);
}

import os
import time

import requests

BASE_URL = os.environ["UMEME_BASE_URL"]
ENTETES = {"Authorization": f"Bearer {os.environ['UMEME_CLE']}"}


# commandes : votre stockage ; traiter : la fonction qui applique un statut.
def reprendre(commandes, traiter):
    for commande in commandes.en_cours_depuis(minutes=15):
        reponse = requests.get(f"{BASE_URL}/ventes/{commande['uuid']}", headers=ENTETES, timeout=30)
        if reponse.status_code == 404:
            # NON_TROUVEE : la vente n'est jamais arrivée, elle repart avec le même uuid.
            commandes.renvoyer(commande)
            continue
        traiter(reponse.json())


# Toutes les 5 minutes.
def planifier(commandes, traiter):
    while True:
        reprendre(commandes, traiter)
        time.sleep(5 * 60)

<?php

use GuzzleHttp\Client;

// $commandes : votre stockage ; $traiter : la fonction qui applique un statut.
// À lancer toutes les 5 minutes, par exemple depuis le planificateur de Laravel ou cron.
function reprendre(Commandes $commandes, callable $traiter): void
{
    $umeme = new Client([
        'base_uri' => getenv('UMEME_BASE_URL') . '/',
        'headers' => ['Authorization' => 'Bearer ' . getenv('UMEME_CLE')],
        'timeout' => 30,
        'http_errors' => false,
    ]);
    foreach ($commandes->enCoursDepuis(15) as $commande) {
        $reponse = $umeme->get('ventes/' . $commande['uuid']);
        if ($reponse->getStatusCode() === 404) {
            // NON_TROUVEE : la vente n'est jamais arrivée, elle repart avec le même uuid.
            $commandes->renvoyer($commande);
            continue;
        }
        $traiter(json_decode($reponse->getBody(), true));
    }
}

static final HttpClient CLIENT = HttpClient.newHttpClient();

// commandes : votre stockage ; traiter : la fonction qui applique un statut.
static void reprendre(Commandes commandes, Consumer<String> traiter) throws Exception {
    for (var commande : commandes.enCoursDepuis(Duration.ofMinutes(15))) {
        var requete = HttpRequest.newBuilder(URI.create(System.getenv("UMEME_BASE_URL") + "/ventes/" + commande.uuid()))
            .header("Authorization", "Bearer " + System.getenv("UMEME_CLE"))
            .timeout(Duration.ofSeconds(30))
            .GET()
            .build();
        var reponse = CLIENT.send(requete, HttpResponse.BodyHandlers.ofString());
        if (reponse.statusCode() == 404) {
            // NON_TROUVEE : la vente n'est jamais arrivée, elle repart avec le même uuid.
            commandes.renvoyer(commande);
            continue;
        }
        traiter.accept(reponse.body());
    }
}

// Toutes les 5 minutes.
static void planifier(Commandes commandes, Consumer<String> traiter) {
    Executors.newSingleThreadScheduledExecutor().scheduleAtFixedRate(() -> {
        try {
            reprendre(commandes, traiter);
        } catch (Exception e) {
            // Le prochain passage reprendra les mêmes ventes.
        }
    }, 0, 5, TimeUnit.MINUTES);
}