UnitechPay API

const axios = require('axios');

class UnitechPay {
    constructor(apiKey) {
        this.client = axios.create({
            baseURL: 'https://api.unitech.sn/api.php',
            headers: {
                'Authorization': `Bearer ${apiKey}`,
                'Content-Type': 'application/json',
            },
            timeout: 30000,
        });
    }

    async _post(action, data) {
        const res = await this.client.post(`?action=${action}`, data);
        return res.data;
    }

    async _get(action, params = {}) {
        const res = await this.client.get(`?action=${action}`, { params });
        return res.data;
    }

    // Soldes Wave + Orange
    async getBalance() {
        return this._get('balance');
    }

    // Paiement Wave
    async wavePayment(amount, phone, description, callbacks = {}) {
        return this._post('create_wave_payment', {
            amount, customer_number: phone, description,
            callback_success: callbacks.success,
            callback_cancel:  callbacks.cancel,
        });
    }

    // QR Code Orange Money
    async orangeQR(amount, reference, description, callbacks = {}) {
        return this._post('create_orange_qr', {
            amount, reference, description,
            callback_success: callbacks.success,
            callback_cancel:  callbacks.cancel,
        });
    }

    // Retrait automatique
    async withdraw(amount, method, account) {
        return this._post('withdraw_funds', { amount, method, account });
    }
}

// Utilisation
(async () => {
    const pay = new UnitechPay('VOTRE_CLE_API');

    // Soldes
    const bal = await pay.getBalance();
    console.log(`Wave: ${bal.data.sold_wave} XOF — Orange: ${bal.data.sold_om} XOF`);

    // Paiement Wave
    const wave = await pay.wavePayment(5000, '771234567', 'Commande #123', {
        success: 'https://monapp.com/success',
        cancel:  'https://monapp.com/cancel',
    });
    console.log('URL de paiement:', wave.data.payment_url);

    // Retrait Wave
    const wd = await pay.withdraw(10000, 'wave', '771234567');
    console.log(`Retrait: ${wd.data.net_amount} XOF — ${wd.data.status}`);
})();

import requests

class UnitechPay:
    BASE_URL = "https://api.unitech.sn/api.php"

    def __init__(self, api_key: str):
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json",
        })

    def _post(self, action: str, data: dict) -> dict:
        r = self.session.post(f"{self.BASE_URL}?action={action}", json=data, timeout=30)
        r.raise_for_status()
        return r.json()

    def _get(self, action: str, params: dict = {}) -> dict:
        r = self.session.get(f"{self.BASE_URL}?action={action}", params=params, timeout=30)
        r.raise_for_status()
        return r.json()

    def get_balance(self) -> dict:
        return self._get("balance")

    def wave_payment(self, amount, phone, description="", success_url="", cancel_url=""):
        return self._post("create_wave_payment", {
            "amount": amount, "customer_number": phone,
            "description": description,
            "callback_success": success_url, "callback_cancel": cancel_url,
        })

    def orange_qr(self, amount, reference="", description="", success_url="", cancel_url=""):
        return self._post("create_orange_qr", {
            "amount": amount, "reference": reference,
            "description": description,
            "callback_success": success_url, "callback_cancel": cancel_url,
        })

    def withdraw(self, amount: float, method: str, account: str) -> dict:
        return self._post("withdraw_funds", {
            "amount": amount, "method": method, "account": account,
        })


# Utilisation
if __name__ == "__main__":
    api = UnitechPay("VOTRE_CLE_API")

    # Soldes
    bal = api.get_balance()
    print(f"Wave: {bal['data']['sold_wave']} XOF")
    print(f"Orange: {bal['data']['sold_om']} XOF")
    print(f"Total: {bal['data']['total']} XOF")

    # Paiement Wave
    w = api.wave_payment(5000, "771234567", "Test",
                         "https://monsite.com/success",
                         "https://monsite.com/cancel")
    print("URL:", w["data"]["payment_url"])

    # Retrait Orange Money
    r = api.withdraw(8000, "orange", "771234567")
    print(f"Retrait: {r['data']['net_amount']} XOF — {r['data']['status']}")

import 'package:http/http.dart' as http;
import 'dart:convert';

class UnitechPay {
  static const String _base = 'https://api.unitech.sn/api.php';
  final String _apiKey;

  UnitechPay(this._apiKey);

  Future<Map<String, dynamic>> _post(String action, Map<String, dynamic> body) async {
    final res = await http.post(
      Uri.parse('$_base?action=$action'),
      headers: {
        'Authorization': 'Bearer $_apiKey',
        'Content-Type': 'application/json',
      },
      body: json.encode(body),
    ).timeout(const Duration(seconds: 30));
    return json.decode(res.body);
  }

  Future<Map<String, dynamic>> _get(String action) async {
    final res = await http.get(
      Uri.parse('$_base?action=$action'),
      headers: {'Authorization': 'Bearer $_apiKey'},
    ).timeout(const Duration(seconds: 30));
    return json.decode(res.body);
  }

  Future<Map<String, dynamic>> getBalance() => _get('balance');

  Future<Map<String, dynamic>> wavePayment({
    required double amount,
    required String phone,
    String description = '',
    String successUrl  = '',
    String cancelUrl   = '',
  }) => _post('create_wave_payment', {
    'amount':           amount,
    'customer_number':  phone,
    'description':      description,
    'callback_success': successUrl,
    'callback_cancel':  cancelUrl,
  });

  Future<Map<String, dynamic>> orangeQR({
    required double amount,
    String reference   = '',
    String description = '',
    String successUrl  = '',
    String cancelUrl   = '',
  }) => _post('create_orange_qr', {
    'amount':           amount,
    'reference':        reference,
    'description':      description,
    'callback_success': successUrl,
    'callback_cancel':  cancelUrl,
  });

  Future<Map<String, dynamic>> withdraw({
    required double amount,
    required String method,   // 'wave' | 'orange' | 'bank'
    required String account,
  }) => _post('withdraw_funds', {
    'amount':  amount,
    'method':  method,
    'account': account,
  });
}

// Utilisation dans un widget
void _example() async {
  final api = UnitechPay('VOTRE_CLE_API');

  // Soldes
  final bal = await api.getBalance();
  print('Wave: ${bal['data']['sold_wave']} XOF');
  print('Orange: ${bal['data']['sold_om']} XOF');

  // Paiement Wave
  final wave = await api.wavePayment(
    amount:      5000,
    phone:       '771234567',
    description: 'Commande Flutter',
    successUrl:  'https://monapp.com/success',
    cancelUrl:   'https://monapp.com/cancel',
  );
  print('URL: ${wave['data']['payment_url']}');

  // Retrait automatique
  final wd = await api.withdraw(
    amount:  10000,
    method:  'wave',
    account: '771234567',
  );
  print('Net: ${wd['data']['net_amount']} XOF — ${wd['data']['status']}');
}