Viva Wallet ISV SDK

// Créer un compte connecté avec branding
$account = $isv->accounts->create(
    email: 'merchant@example.com',
    returnUrl: 'https://myapp.com/onboarding/complete',
    partnerName: 'Ma Plateforme',
    logoUrl: 'https://myapp.com/logo.png',
);

// Rediriger le marchand vers l'onboarding KYB
header('Location: ' . $account['invitation']['redirectUrl']);

// Vérifier le statut KYB
if ($isv->accounts->isVerified($account['accountId'])) {
    echo 'Le marchand peut recevoir des paiements';
}

// Récupérer l'URL d'onboarding (null si déjà vérifié)
$url = $isv->accounts->onboardingUrl($account['accountId']);

// Lister tous les comptes connectés
$accounts = $isv->accounts->list();

// Consulter un compte
$details = $isv->accounts->get($account['accountId']);

// Mettre à jour (PATCH /platforms/v1/accounts/{id} depuis v1.7.0)
$isv->accounts->update($account['accountId'], ['payouts' => ['enabled' => true]]);

// Supprimer
$isv->accounts->delete($account['accountId']);

$account = $isv->isvAccounts->create(
    email: 'merchant@example.com',
    returnUrl: 'https://myapp.com/onboarding/done',
    partnerName: 'Ma Plateforme',
    primaryColor: '#0052FF',
    logoUrl: 'https://myapp.com/logo.png',
);

$details = $isv->isvAccounts->get($account['accountId']);

// v1.6 — helpers prod-tested (toujours fonctionnels sur ISV)
$onboardingUrl = $isv->isvAccounts->getOnboardingUrl($account['accountId']);
$isVerified    = $isv->isvAccounts->isVerified($account['accountId']);
$canAcquire    = $isv->isvAccounts->isAcquiringEnabled($account['accountId']);

// ⚠ list() retourne HTTP 405 en prod — tracer accountIds côté app
// $all = $isv->isvAccounts->list(); // ApiException 405

$order = $isv->orders->create(
    connectedMerchantId: 'merchant-uuid',
    amount: 1500,                    // 15,00 EUR
    isvAmount: 100,                  // 1,00 EUR de commission
    customerDescription: 'Consultation bien-être',
    merchantReference: 'INV-2026-001',
    allowRecurring: true,            // Tokeniser la carte pour les récurrents
    preauth: false,
);

echo $order['order_code'];    // 1234567890
echo $order['checkout_url'];  // https://demo.vivapayments.com/web/checkout?ref=...

// Reconstruire l'URL à partir d'un code existant
$url = $isv->orders->checkoutUrl(1234567890);

// v1.7.0 — Consulter un ordre d'un marchand connecté (Composite Basic Auth)
$details = $isv->orders->retrieve(1234567890, 'merchant-uuid');

// v1.7.0 — Annuler un ordre ouvert d'un marchand connecté
$result = $isv->orders->cancel(1234567890, 'merchant-uuid');

// Consulter une transaction
$txn = $isv->transactions->get('txn-uuid', 'merchant-uuid');

// Lister les transactions d'une journée
$transactions = $isv->transactions->listByDate('merchant-uuid', '2026-03-18');

// v1.7.0 — Variantes de filtrage sur /api/transactions
$byClearance = $isv->transactions->listByClearanceDate('merchant-uuid', '2026-03-18');
$byOrder     = $isv->transactions->listByOrderCode('merchant-uuid', 1234567890);
$bySource    = $isv->transactions->listBySourceCode('merchant-uuid', 'Default', '2026-03-18');

// Capturer une pré-autorisation
$isv->transactions->capture(
    transactionId: 'preauth-txn-uuid',
    connectedMerchantId: 'merchant-uuid',
    amount: 1500,
    isvAmount: 100,
);

// Paiement récurrent (à partir d'une transaction initiale tokenisée)
$isv->transactions->recurring(
    initialTransactionId: 'initial-txn-uuid',
    connectedMerchantId: 'merchant-uuid',
    amount: 1500,
    isvAmount: 100,
);

// v1.7.0 — Charge MOTO (Mail Order / Telephone Order), payload camelCase tel quel
$isv->transactions->moto('merchant-uuid', [
    'amount' => 1500,
    'orderCode' => 1234567890,
    'creditcard' => [
        'number' => '4111111111111111',
        'expirationYear' => 2030,
        'expirationMonth' => 12,
        'cvc' => '111',
    ],
]);

// v1.7.0 — Augmenter une pré-autorisation existante (pré-auth incrémentale, Bearer New API)
$isv->transactions->increasePreauth(
    transactionId: 'preauth-txn-uuid',
    connectedMerchantId: 'merchant-uuid',
    amount: 500,
    idempotencyKey: 'preauth-inc-2026-001',
);

// Remboursement total
$isv->transactions->cancel('txn-uuid', 'merchant-uuid');

// Remboursement partiel (5,00 EUR)
$isv->transactions->cancel('txn-uuid', 'merchant-uuid', amount: 500);

use QrCommunication\VivaIsv\Enums\EcrEventId;

// Rechercher les terminaux d'un marchand
$terminals = $isv->terminals->search(merchantId: 'merchant-uuid');

// Vente POS ISV
$session = $isv->terminals->sale(
    terminalId: 16014231,
    amount: 1500,
    isvAmount: 100,
    terminalMerchantId: 'merchant-uuid',
    cashRegisterId: 'PratiConnect-CR1',
    merchantReference: 'INV-2026-001',
);

echo $session['session_id']; // UUID de session

// Polling jusqu'au résultat (défaut : 120s timeout, 3s intervalle)
$result = $isv->terminals->pollUntilComplete($session['session_id']);

// Interpréter le résultat avec l'enum
$eventId = EcrEventId::tryFrom($result['eventId']);
if ($eventId?->isSuccessful()) {
    echo 'Transaction réussie : ' . $result['transactionId'];
} else {
    echo 'Échec : ' . $eventId?->label();
}

// v1.7.0 — Remboursement référencé d'une vente POS (lié au parentSessionId)
$refund = $isv->terminals->refund(
    sessionId: $session['session_id'],   // session de la vente d'origine
    amount: 1500,
    terminalId: 16014231,
    terminalMerchantId: 'merchant-uuid',
    cashRegisterId: 'PratiConnect-CR1',
);

// v1.7.0 — Créer une action sur un terminal (ex. contrôle AADE-FIM)
$action = $isv->terminals->createAction([
    'terminalId' => 16014231,
    'cashRegisterId' => 'PratiConnect-CR1',
    'isvDetails' => ['terminalMerchantId' => 'merchant-uuid'],
    'request' => ['actionType' => 'aade-fim-control'],
]);

// v1.7.0 — Récupérer le résultat d'une action (HTTP 202 en cours → [])
$actionResult = $isv->terminals->getAction($action['actionId']);

// Annuler une session active
$isv->terminals->abort('session-uuid', 'PratiConnect-CR1');

// Consulter une session
$session = $isv->terminals->getSession('session-uuid');

// Lister les sessions d'une journée
$sessions = $isv->terminals->listSessions('2026-03-18');

// Envoyer des fonds à un vendeur
$transfer = $isv->transfers->send(
    targetAccountId: 'seller-account-uuid',
    amount: 1000,                    // 10,00 EUR
    transactionId: 'txn-uuid',       // Lier à une transaction existante
    description: 'Commission mars 2026',
);

echo $transfer['transferId'];

// Annuler totalement un transfert
$isv->transfers->reverse('transfer-uuid');

// Annuler partiellement (5,00 EUR)
$isv->transfers->reverse('transfer-uuid', amount: 500);

// Créer un ordre marketplace
$order = $isv->marketplace->create(
    amount: 1500,                    // 15,00 EUR total
    sellerAccountId: 'seller-uuid',
    sellerAmount: 1200,              // 12,00 EUR au vendeur
    customerDescription: 'Achat marketplace',
    merchantReference: 'MP-2026-001',
);

echo $order['order_code'];
echo $order['checkout_url'];
echo $order['platform_fee'];  // 300 = 3,00 EUR de commission plateforme

// Remboursement total avec reversal des transferts
$isv->marketplace->cancel('txn-uuid');

// Remboursement partiel sans rembourser la commission plateforme
$isv->marketplace->cancel(
    transactionId: 'txn-uuid',
    amount: 500,
    reverseTransfers: true,
    refundPlatformFee: false,
);

// Étape 1 : créer un charge token
$token = $isv->nativeCheckout->createChargeToken(
    connectedMerchantId: 'merchant-uuid',
    amount: 1500,
    paymentData: $encryptedCardData,  // Du JS SDK Viva
    paymentMethodId: 0,               // 0 = carte par défaut
);

// Étape 2 : exécuter la transaction
$txn = $isv->nativeCheckout->createTransaction(
    connectedMerchantId: 'merchant-uuid',
    chargeToken: $token['chargeToken'],
    amount: 1500,
    isvAmount: 100,
    currencyCode: 978,                // EUR
    merchantTrns: 'INV-2026-001',
    customerTrns: 'Consultation bien-être',
);

echo $txn['transactionId'];
echo $txn['statusId'];

// 1. Récupérer la verification key (handshake obligatoire)
$key = $isv->isvWebhooks->verificationToken()['Key'];
// → Persister app-side, utiliser pour signer les webhooks entrants
//   Configurer endpoint GET pour répondre {"Key": "$key"}

// 2. Créer un webhook (numeric eventTypeId, pas string)
$webhook = $isv->isvWebhooks->create(
    url: 'https://myapp.com/webhooks/viva',
    eventTypeId: 1796, // Transaction Payment Created
);

// Events ISV-level supportés :
//   1796 = Transaction Payment Created
//   1797 = Transaction Reversal Created (refund)
//   1798 = Transaction Failed
//   1799 = Transaction Price Calculated
//   8193 = Account Connected (KYB completion)
//   8194 = Account Verification Status Changed

foreach ([1796, 1797, 1798, 1799, 8193, 8194] as $eventId) {
    $isv->isvWebhooks->create($url, $eventId);
}

// ⚠ list() retourne HTTP 405 en prod — tracer registered EventTypeIds côté app

// Modifier
$isv->isvWebhooks->update(
    webhookId: $webhook['webhookId'],
    url: 'https://myapp.com/webhooks/viva-v2',
    eventTypeId: 1797,
);

// Supprimer
$isv->isvWebhooks->delete($webhook['webhookId']);

// GET — vérification initiale
$verificationKey = config('services.viva.verification_key');
return response()->json(
    $isv->webhooks->verificationResponse($verificationKey)
);
// => {"StatusCode": 0, "Key": "votre-cle"}

// POST — parsing des événements
$event = $isv->webhooks->parse(file_get_contents('php://input'));

echo $event['event_type'];     // 'transaction.payment.created'
echo $event['event_type_id'];  // 1796
$data = $event['event_data'];

// Pattern Laravel Controller
match ($event['event_type']) {
    'transaction.payment.created' => $this->handlePayment($event['event_data']),
    'transaction.refund.created'  => $this->handleRefund($event['event_data']),
    'account.connected'           => $this->handleNewAccount($event['event_data']),
    default => null,
};

// Vérifier si un eventTypeId est connu (méthode statique)
use QrCommunication\VivaIsv\Resources\Webhooks;

if (Webhooks::isKnownEvent(1796)) {
    echo 'Événement reconnu';
}

use QrCommunication\VivaIsv\Helpers\MerchantWebhookRegistrar;

// Enregistrer un seul événement banking pour un marchand connecté
$isv->isvMessages->register(
    connectedMerchantId: 'merchant-uuid',
    callbackUrl: 'https://myapp.com/api/webhooks/viva',
    eventTypeId: 768, // Command Bank Transfer Created
);

// Lister les souscriptions actives du marchand
$subscriptions = $isv->isvMessages->list('merchant-uuid');

// Supprimer un abonnement
$isv->isvMessages->delete('merchant-uuid', 768);

use QrCommunication\VivaIsv\Helpers\MerchantWebhookRegistrar;

// Enregistrer les 3 événements banking en un seul appel
$results = $isv->merchantWebhookRegistrar()->registerAll(
    connectedMerchantId: $merchantId,
    callbackUrl: 'https://app.example.com/api/webhooks/viva',
);

// Format v1.6 — chaque entrée :
// ['event_id' => 768, 'status' => 'created'|'already_exists'|'endpoint_unavailable'|'failed', 'message' => '...']

// Branching propre via les helpers statiques v1.6
if (MerchantWebhookRegistrar::allSucceeded($results)) {
    // Tout est OK (created OU already_exists)
} elseif (MerchantWebhookRegistrar::hasEndpointIssue($results)) {
    // L'API merchant-webhooks n'est pas dispo sur ce compte ISV (HTTP 404).
    // Fallback : job de reconciliation périodique via wallet API.
    Log::info('Viva merchant webhooks endpoint unavailable — using polling reconciliation');
} elseif (MerchantWebhookRegistrar::allFailed($results)) {
    // Erreur réseau / auth — retry plus tard
}

// Enregistrer uniquement un sous-ensemble d'événements
$results = $isv->merchantWebhookRegistrar()->registerAll(
    connectedMerchantId: $merchantId,
    callbackUrl: 'https://app.example.com/api/webhooks/viva',
    events: [768, 769],
);

// Consulter les IDs gérés par le helper
$bankingEvents = MerchantWebhookRegistrar::BANKING_EVENTS; // [768, 769, 2054]

// Source e-commerce sur le compte ISV propre
$source = $isv->sources->create([
    'name' => 'Boutique en ligne',
    'sourceCode' => 'ECOM01',
    'domain' => 'shop.example.com',
    'isSecure' => true,
    'pathSuccess' => 'https://shop.example.com/payment/success',
    'pathFail' => 'https://shop.example.com/payment/fail',
]);

// Source présentielle (card-present)
$source = $isv->sources->create([
    'name' => 'Boutique physique',
    'sourceCode' => 'POS01',
    'phone' => '+33123456789',
    'address' => '1 rue de la Paix, Paris',
    'walletId' => 'wallet-uuid',
]);

// Source d'un marchand connecté (Composite Basic Auth)
$source = $isv->sources->createForMerchant('merchant-uuid', [
    'name' => 'Boutique du marchand',
    'sourceCode' => '1234',
    'domain' => 'boutique.fr',
    'isSecure' => true,
    'pathSuccess' => 'https://boutique.fr/success',
    'pathFail' => 'https://boutique.fr/fail',
]);

$result = $isv->sources->ensureForMerchant('merchant-uuid', [
    'name' => 'Boutique du marchand',
    'sourceCode' => '1234',
    'domain' => 'boutique.fr',
    'isSecure' => true,
    'pathSuccess' => 'https://boutique.fr/success',
    'pathFail' => 'https://boutique.fr/fail',
]);
// créée, OU ['sourceCode' => '1234', 'status' => 'already_exists'] si elle existe déjà

// Variante compte ISV propre
$ownResult = $isv->sources->ensure([
    'name' => 'Boutique en ligne',
    'sourceCode' => 'ECOM01',
    'domain' => 'shop.example.com',
    'isSecure' => true,
    'pathSuccess' => 'https://shop.example.com/payment/success',
    'pathFail' => 'https://shop.example.com/payment/fail',
]);

// 1. Valider un paiement cash avant encaissement
$validation = $isv->resellers->validateCashPayment([
    'amount' => 1500,
    'customerPhone' => '+33123456789',
]);

// 2. Envoyer un OTP au client
$isv->resellers->sendCashPaymentOtp(['reference' => $validation['reference']]);

// 3. Encaisser le paiement cash (avec l'OTP saisi par le client)
$payment = $isv->resellers->cashPayment([
    'reference' => $validation['reference'],
    'otp' => '123456',
]);

// Même flux pour les bill payments
$billValidation = $isv->resellers->validateBillPayment(['billCode' => 'BILL-001', 'amount' => 4200]);
$isv->resellers->sendBillPaymentOtp(['reference' => $billValidation['reference']]);
$isv->resellers->billPayment(['reference' => $billValidation['reference'], 'otp' => '654321']);

// Créer un ordre scopé reseller
$order = $isv->resellers->createOrder(['amount' => 1500, 'customerTrns' => 'Commande reseller']);