446 lines
15 KiB
PHP
446 lines
15 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace App\Services;
|
|
|
|
use Stripe\Stripe;
|
|
use Stripe\StripeClient;
|
|
use Stripe\Exception\ApiErrorException;
|
|
use AppConfig;
|
|
use Database;
|
|
use PDO;
|
|
use Exception;
|
|
|
|
/**
|
|
* Service principal pour gérer l'intégration Stripe
|
|
* Gère Stripe Connect, Terminal et les paiements
|
|
*/
|
|
class StripeService {
|
|
private static ?self $instance = null;
|
|
private StripeClient $stripe;
|
|
private AppConfig $config;
|
|
private PDO $db;
|
|
private bool $testMode;
|
|
|
|
private function __construct() {
|
|
$this->config = AppConfig::getInstance();
|
|
$this->db = Database::getInstance();
|
|
|
|
// Déterminer le mode (test ou live)
|
|
$stripeConfig = $this->config->getStripeConfig();
|
|
$this->testMode = ($stripeConfig['mode'] ?? 'test') === 'test';
|
|
|
|
// Initialiser Stripe avec la bonne clé
|
|
$secretKey = $this->testMode
|
|
? $stripeConfig['secret_key_test']
|
|
: $stripeConfig['secret_key_live'];
|
|
|
|
if (empty($secretKey) || strpos($secretKey, 'XXXX') !== false) {
|
|
throw new Exception('Clé Stripe non configurée. Veuillez configurer vos clés dans AppConfig.php');
|
|
}
|
|
|
|
$this->stripe = new StripeClient([
|
|
'api_key' => $secretKey,
|
|
'stripe_version' => $stripeConfig['api_version']
|
|
]);
|
|
|
|
// Définir la clé API globalement aussi (pour certaines opérations)
|
|
Stripe::setApiKey($secretKey);
|
|
Stripe::setApiVersion($stripeConfig['api_version']);
|
|
}
|
|
|
|
public static function getInstance(): self {
|
|
if (self::$instance === null) {
|
|
self::$instance = new self();
|
|
}
|
|
return self::$instance;
|
|
}
|
|
|
|
/**
|
|
* Créer un compte Stripe Connect Express pour une amicale
|
|
*/
|
|
public function createConnectAccount(int $entiteId): array {
|
|
try {
|
|
// Récupérer les infos de l'entité
|
|
$stmt = $this->db->prepare(
|
|
"SELECT * FROM entites WHERE id = :id"
|
|
);
|
|
$stmt->execute(['id' => $entiteId]);
|
|
$entite = $stmt->fetch(PDO::FETCH_ASSOC);
|
|
|
|
if (!$entite) {
|
|
throw new Exception("Entité non trouvée");
|
|
}
|
|
|
|
// Vérifier si un compte existe déjà
|
|
$stmt = $this->db->prepare(
|
|
"SELECT * FROM stripe_accounts WHERE fk_entite = :fk_entite"
|
|
);
|
|
$stmt->execute(['fk_entite' => $entiteId]);
|
|
$existingAccount = $stmt->fetch(PDO::FETCH_ASSOC);
|
|
|
|
if ($existingAccount) {
|
|
return [
|
|
'success' => false,
|
|
'message' => 'Un compte Stripe existe déjà pour cette entité',
|
|
'account_id' => $existingAccount['stripe_account_id']
|
|
];
|
|
}
|
|
|
|
// Créer le compte Stripe Connect Express
|
|
$account = $this->stripe->accounts->create([
|
|
'type' => 'express',
|
|
'country' => 'FR',
|
|
'email' => $entite['email'] ?? null,
|
|
'capabilities' => [
|
|
'card_payments' => ['requested' => true],
|
|
'transfers' => ['requested' => true],
|
|
],
|
|
'business_type' => 'non_profit', // Association
|
|
'business_profile' => [
|
|
'name' => $entite['nom'],
|
|
'product_description' => 'Vente de calendriers des pompiers',
|
|
'support_email' => $entite['email'] ?? null,
|
|
'url' => $entite['site_web'] ?? null,
|
|
],
|
|
'metadata' => [
|
|
'entite_id' => $entiteId,
|
|
'entite_name' => $entite['nom']
|
|
]
|
|
]);
|
|
|
|
// Sauvegarder en base de données
|
|
$stmt = $this->db->prepare(
|
|
"INSERT INTO stripe_accounts (fk_entite, stripe_account_id, created_at)
|
|
VALUES (:fk_entite, :stripe_account_id, NOW())"
|
|
);
|
|
$stmt->execute([
|
|
'fk_entite' => $entiteId,
|
|
'stripe_account_id' => $account->id
|
|
]);
|
|
|
|
return [
|
|
'success' => true,
|
|
'account_id' => $account->id,
|
|
'message' => 'Compte Stripe créé avec succès'
|
|
];
|
|
|
|
} catch (ApiErrorException $e) {
|
|
return [
|
|
'success' => false,
|
|
'message' => 'Erreur Stripe: ' . $e->getMessage()
|
|
];
|
|
} catch (Exception $e) {
|
|
return [
|
|
'success' => false,
|
|
'message' => 'Erreur: ' . $e->getMessage()
|
|
];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Récupérer les informations d'un compte Stripe Connect
|
|
*/
|
|
public function retrieveAccount(string $accountId) {
|
|
try {
|
|
return Account::retrieve($accountId);
|
|
} catch (Exception $e) {
|
|
Logger::getInstance()->error('Erreur récupération compte Stripe', [
|
|
'account_id' => $accountId,
|
|
'error' => $e->getMessage()
|
|
]);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Générer un lien d'onboarding pour finaliser la configuration du compte
|
|
*/
|
|
public function createOnboardingLink(string $accountId, string $returnUrl, string $refreshUrl): array {
|
|
try {
|
|
$accountLink = $this->stripe->accountLinks->create([
|
|
'account' => $accountId,
|
|
'refresh_url' => $refreshUrl,
|
|
'return_url' => $returnUrl,
|
|
'type' => 'account_onboarding',
|
|
]);
|
|
|
|
return [
|
|
'success' => true,
|
|
'url' => $accountLink->url
|
|
];
|
|
|
|
} catch (ApiErrorException $e) {
|
|
return [
|
|
'success' => false,
|
|
'message' => 'Erreur Stripe: ' . $e->getMessage()
|
|
];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Créer une Location pour Terminal/Tap to Pay
|
|
*/
|
|
public function createLocation(int $entiteId): array {
|
|
try {
|
|
// Récupérer le compte Stripe et l'entité
|
|
$stmt = $this->db->prepare(
|
|
"SELECT sa.*, e.*
|
|
FROM stripe_accounts sa
|
|
JOIN entites e ON sa.fk_entite = e.id
|
|
WHERE sa.fk_entite = :fk_entite"
|
|
);
|
|
$stmt->execute(['fk_entite' => $entiteId]);
|
|
$data = $stmt->fetch(PDO::FETCH_ASSOC);
|
|
|
|
if (!$data) {
|
|
throw new Exception("Compte Stripe non trouvé pour cette entité");
|
|
}
|
|
|
|
// Créer la location
|
|
$location = $this->stripe->terminal->locations->create([
|
|
'display_name' => $data['nom'],
|
|
'address' => [
|
|
'line1' => $data['adresse'] ?? 'Adresse non renseignée',
|
|
'city' => $data['ville'] ?? 'Ville',
|
|
'postal_code' => $data['code_postal'] ?? '00000',
|
|
'country' => 'FR',
|
|
],
|
|
'metadata' => [
|
|
'entite_id' => $entiteId,
|
|
'type' => 'tap_to_pay'
|
|
]
|
|
], [
|
|
'stripe_account' => $data['stripe_account_id']
|
|
]);
|
|
|
|
// Mettre à jour en base
|
|
$stmt = $this->db->prepare(
|
|
"UPDATE stripe_accounts
|
|
SET stripe_location_id = :location_id, updated_at = NOW()
|
|
WHERE fk_entite = :fk_entite"
|
|
);
|
|
$stmt->execute([
|
|
'location_id' => $location->id,
|
|
'fk_entite' => $entiteId
|
|
]);
|
|
|
|
return [
|
|
'success' => true,
|
|
'location_id' => $location->id,
|
|
'message' => 'Location créée avec succès'
|
|
];
|
|
|
|
} catch (Exception $e) {
|
|
return [
|
|
'success' => false,
|
|
'message' => 'Erreur: ' . $e->getMessage()
|
|
];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Créer un Connection Token pour Terminal/Tap to Pay
|
|
*/
|
|
public function createConnectionToken(int $entiteId): array {
|
|
try {
|
|
// Récupérer le compte et la location
|
|
$stmt = $this->db->prepare(
|
|
"SELECT * FROM stripe_accounts WHERE fk_entite = :fk_entite"
|
|
);
|
|
$stmt->execute(['fk_entite' => $entiteId]);
|
|
$account = $stmt->fetch(PDO::FETCH_ASSOC);
|
|
|
|
if (!$account || !$account['stripe_location_id']) {
|
|
throw new Exception("Location Stripe non configurée pour cette entité");
|
|
}
|
|
|
|
// Créer le token
|
|
$connectionToken = $this->stripe->terminal->connectionTokens->create([
|
|
'location' => $account['stripe_location_id']
|
|
], [
|
|
'stripe_account' => $account['stripe_account_id']
|
|
]);
|
|
|
|
return [
|
|
'success' => true,
|
|
'secret' => $connectionToken->secret
|
|
];
|
|
|
|
} catch (Exception $e) {
|
|
return [
|
|
'success' => false,
|
|
'message' => 'Erreur: ' . $e->getMessage()
|
|
];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Créer une intention de paiement
|
|
*/
|
|
public function createPaymentIntent(array $params): array {
|
|
try {
|
|
$amount = $params['amount'] ?? 0;
|
|
$entiteId = $params['fk_entite'] ?? 0;
|
|
$userId = $params['fk_user'] ?? 0;
|
|
$metadata = $params['metadata'] ?? [];
|
|
|
|
if ($amount < 100) {
|
|
throw new Exception("Le montant minimum est de 1€");
|
|
}
|
|
|
|
// Récupérer le compte Stripe
|
|
$stmt = $this->db->prepare(
|
|
"SELECT * FROM stripe_accounts WHERE fk_entite = :fk_entite"
|
|
);
|
|
$stmt->execute(['fk_entite' => $entiteId]);
|
|
$account = $stmt->fetch(PDO::FETCH_ASSOC);
|
|
|
|
if (!$account) {
|
|
throw new Exception("Compte Stripe non trouvé");
|
|
}
|
|
|
|
// Calculer la commission (2.5% ou 50 centimes minimum)
|
|
$stripeConfig = $this->config->getStripeConfig();
|
|
$applicationFee = max(
|
|
$stripeConfig['application_fee_minimum'],
|
|
round($amount * $stripeConfig['application_fee_percent'] / 100)
|
|
);
|
|
|
|
// Créer le PaymentIntent
|
|
$paymentIntent = $this->stripe->paymentIntents->create([
|
|
'amount' => $amount,
|
|
'currency' => 'eur',
|
|
'payment_method_types' => ['card_present'],
|
|
'capture_method' => 'automatic',
|
|
'application_fee_amount' => $applicationFee,
|
|
'transfer_data' => [
|
|
'destination' => $account['stripe_account_id'],
|
|
],
|
|
'metadata' => array_merge($metadata, [
|
|
'entite_id' => $entiteId,
|
|
'user_id' => $userId,
|
|
'calendrier_annee' => date('Y'),
|
|
]),
|
|
]);
|
|
|
|
// Sauvegarder en base
|
|
$stmt = $this->db->prepare(
|
|
"INSERT INTO stripe_payment_intents
|
|
(stripe_payment_intent_id, fk_entite, fk_user, amount, currency, status, application_fee, metadata, created_at)
|
|
VALUES (:pi_id, :fk_entite, :fk_user, :amount, :currency, :status, :app_fee, :metadata, NOW())"
|
|
);
|
|
$stmt->execute([
|
|
'pi_id' => $paymentIntent->id,
|
|
'fk_entite' => $entiteId,
|
|
'fk_user' => $userId,
|
|
'amount' => $amount,
|
|
'currency' => 'eur',
|
|
'status' => $paymentIntent->status,
|
|
'app_fee' => $applicationFee,
|
|
'metadata' => json_encode($metadata)
|
|
]);
|
|
|
|
return [
|
|
'success' => true,
|
|
'client_secret' => $paymentIntent->client_secret,
|
|
'payment_intent_id' => $paymentIntent->id,
|
|
'amount' => $amount,
|
|
'application_fee' => $applicationFee
|
|
];
|
|
|
|
} catch (Exception $e) {
|
|
return [
|
|
'success' => false,
|
|
'message' => 'Erreur: ' . $e->getMessage()
|
|
];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Vérifier la compatibilité Tap to Pay d'un appareil Android
|
|
*/
|
|
public function checkAndroidTapToPayCompatibility(string $manufacturer, string $model): array {
|
|
try {
|
|
$stmt = $this->db->prepare(
|
|
"SELECT * FROM stripe_android_certified_devices
|
|
WHERE manufacturer = :manufacturer
|
|
AND model = :model
|
|
AND tap_to_pay_certified = 1
|
|
AND country = 'FR'"
|
|
);
|
|
$stmt->execute([
|
|
'manufacturer' => $manufacturer,
|
|
'model' => $model
|
|
]);
|
|
|
|
$device = $stmt->fetch(PDO::FETCH_ASSOC);
|
|
|
|
if ($device) {
|
|
return [
|
|
'success' => true,
|
|
'tap_to_pay_supported' => true,
|
|
'message' => 'Tap to Pay disponible sur cet appareil',
|
|
'min_android_version' => $device['min_android_version']
|
|
];
|
|
}
|
|
|
|
return [
|
|
'success' => true,
|
|
'tap_to_pay_supported' => false,
|
|
'message' => 'Appareil non certifié pour Tap to Pay en France',
|
|
'alternative' => 'Utilisez un iPhone XS ou plus récent avec iOS 15.4+'
|
|
];
|
|
|
|
} catch (Exception $e) {
|
|
return [
|
|
'success' => false,
|
|
'message' => 'Erreur: ' . $e->getMessage()
|
|
];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Récupérer les appareils Android certifiés
|
|
*/
|
|
public function getCertifiedAndroidDevices(): array {
|
|
try {
|
|
$stmt = $this->db->prepare(
|
|
"SELECT manufacturer, model, model_identifier, min_android_version
|
|
FROM stripe_android_certified_devices
|
|
WHERE tap_to_pay_certified = 1 AND country = 'FR'
|
|
ORDER BY manufacturer, model"
|
|
);
|
|
$stmt->execute();
|
|
|
|
return [
|
|
'success' => true,
|
|
'devices' => $stmt->fetchAll(PDO::FETCH_ASSOC)
|
|
];
|
|
|
|
} catch (Exception $e) {
|
|
return [
|
|
'success' => false,
|
|
'message' => 'Erreur: ' . $e->getMessage()
|
|
];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Obtenir le mode actuel (test ou live)
|
|
*/
|
|
public function isTestMode(): bool {
|
|
return $this->testMode;
|
|
}
|
|
|
|
/**
|
|
* Obtenir la clé publique pour le frontend
|
|
*/
|
|
public function getPublicKey(): string {
|
|
$stripeConfig = $this->config->getStripeConfig();
|
|
return $this->testMode
|
|
? $stripeConfig['public_key_test']
|
|
: $stripeConfig['public_key_live'];
|
|
}
|
|
} |