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 + autres pays
    async getBalance() {
        return this._get('balance');
    }

    // Paiement Wave (Sénégal)
    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,
        });
    }

    // Paiement autres pays (CI, TG, BF, BJ)
    async intlPayment(country, operator, amount, phone, opts = {}) {
        return this._post('create_intl_payment', {
            country, operator, amount, customer_number: phone,
            customer_name: opts.name, description: opts.description,
            callback_success: opts.success, callback_cancel: opts.cancel,
        });
    }

    // Retrait automatique (wave | orange | intl | bank)
    async withdraw(params) {
        return this._post('withdraw_funds', params);
    }
}

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

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

    // Paiement autres pays
    const intl = await pay.intlPayment('CI', 'orange_money', 5000, '0700000000', {
        name: 'Amadou Fall', success: 'https://monapp.com/success', cancel: 'https://monapp.com/cancel',
    });
    console.log('Lien de paiement:', intl.data.payment_url);

    // Retrait autres pays
    const wd = await pay.withdraw({ amount: 10000, method: 'intl', country: 'CI', operator: 'orange_money', account: '0700000000' });
    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 intl_payment(self, country, operator, amount, phone="", **opts):
        return self._post("create_intl_payment", {
            "country": country, "operator": operator, "amount": amount,
            "customer_number": phone,
            "customer_name": opts.get("name", ""),
            "description": opts.get("description", ""),
            "callback_success": opts.get("success_url", ""),
            "callback_cancel": opts.get("cancel_url", ""),
        })

    def withdraw(self, **params) -> dict:
        return self._post("withdraw_funds", params)


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

    # Soldes
    bal = api.get_balance()
    print(f"Wave: {bal['data']['sold_wave']} | Orange: {bal['data']['sold_om']} | Autres pays: {bal['data']['sold_intl']}")

    # Paiement autres pays
    p = api.intl_payment("CI", "orange_money", 5000, "0700000000", name="Amadou Fall")
    print("URL:", p["data"]["payment_url"])

    # Retrait autres pays
    r = api.withdraw(amount=10000, method="intl", country="CI", operator="orange_money", account="0700000000")
    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,
  });

  // Paiement autres pays (CI, TG, BF, BJ)
  Future<Map<String, dynamic>> intlPayment({
    required String country,
    required String operator,
    required double amount,
    String phone       = '',
    String name        = '',
    String successUrl  = '',
    String cancelUrl   = '',
  }) => _post('create_intl_payment', {
    'country':          country,
    'operator':         operator,
    'amount':           amount,
    'customer_number':  phone,
    'customer_name':    name,
    'callback_success': successUrl,
    'callback_cancel':  cancelUrl,
  });

  Future<Map<String, dynamic>> withdraw(Map<String, dynamic> params) =>
      _post('withdraw_funds', params);
}

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

  // Soldes
  final bal = await api.getBalance();
  print('Autres pays: ${bal['data']['sold_intl']} XOF');

  // Paiement autres pays
  final intl = await api.intlPayment(
    country: 'CI', operator: 'orange_money', amount: 5000,
    phone: '0700000000', name: 'Amadou Fall',
  );
  print('URL: ${intl['data']['payment_url']}');

  // Retrait autres pays
  final wd = await api.withdraw({
    'amount': 10000, 'method': 'intl',
    'country': 'CI', 'operator': 'orange_money', 'account': '0700000000',
  });
  print('Net: ${wd['data']['net_amount']} XOF — ${wd['data']['status']}');
}