Skip to main content

Exemples de code

Java​

Envoi d'OTP​

import java.net.HttpURLConnection;
import java.net.URL;
import java.io.OutputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import com.google.gson.Gson;
import com.google.gson.JsonObject;

public class OTPService {
    private static final String API_KEY = "VOTRE_CLE_API";
    private static final String BASE_URL = "https://votre-domaine.com/api";
    
    public String sendOTP(String phoneNumber, String userIP) throws Exception {
        URL url = new URL(BASE_URL + "/send-otp");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        
        conn.setRequestMethod("POST");
        conn.setRequestProperty("Content-Type", "application/json");
        conn.setRequestProperty("api-key", API_KEY);
        conn.setDoOutput(true);
        
        JsonObject requestBody = new JsonObject();
        requestBody.addProperty("phoneNumber", phoneNumber);
        requestBody.addProperty("ipAdress", userIP);
        requestBody.addProperty("channel", "sms");
        requestBody.addProperty("lang", "ar");
        
        try (OutputStream os = conn.getOutputStream()) {
            byte[] input = requestBody.toString().getBytes("utf-8");
            os.write(input, 0, input.length);
        }
        
        int responseCode = conn.getResponseCode();
        BufferedReader br = new BufferedReader(
            new InputStreamReader(conn.getInputStream(), "utf-8"));
        StringBuilder response = new StringBuilder();
        String responseLine;
        while ((responseLine = br.readLine()) != null) {
            response.append(responseLine.trim());
        }
        
        Gson gson = new Gson();
        JsonObject jsonResponse = gson.fromJson(response.toString(), JsonObject.class);
        return jsonResponse.get("verifToken").getAsString();
    }
}

Vérification d'OTP​

public boolean verifyOTP(String verifToken, String otpCode) throws Exception {
    URL url = new URL(BASE_URL + "/verify-otp");
    HttpURLConnection conn = (HttpURLConnection) url.openConnection();
    
    conn.setRequestMethod("POST");
    conn.setRequestProperty("Content-Type", "application/json");
    conn.setRequestProperty("api-key", API_KEY);
    conn.setDoOutput(true);
    
    JsonObject requestBody = new JsonObject();
    requestBody.addProperty("verifToken", verifToken);
    requestBody.addProperty("otp", otpCode);
    
    try (OutputStream os = conn.getOutputStream()) {
        byte[] input = requestBody.toString().getBytes("utf-8");
        os.write(input, 0, input.length);
    }
    
    BufferedReader br = new BufferedReader(
        new InputStreamReader(conn.getInputStream(), "utf-8"));
    StringBuilder response = new StringBuilder();
    String responseLine;
    while ((responseLine = br.readLine()) != null) {
        response.append(responseLine.trim());
    }
    
    Gson gson = new Gson();
    JsonObject jsonResponse = gson.fromJson(response.toString(), JsonObject.class);
    return jsonResponse.get("success").getAsBoolean();
}

PHP​

Envoi d'OTP​

<?php
function sendOTP($phoneNumber, $userIP) {
    $url = "https://votre-domaine.com/api/send-otp";
    $data = [
        "phoneNumber" => $phoneNumber,
        "ipAdress" => $userIP,
        "channel" => "sms",
        "lang" => "ar"
    ];
    
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        "Content-Type: application/json",
        "api-key: VOTRE_CLE_API"
    ]);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode !== 200) {
        throw new Exception("Erreur lors de l'envoi de l'OTP");
    }
    
    $result = json_decode($response, true);
    return $result["verifToken"];
}
?>

Vérification d'OTP​

<?php
function verifyOTP($verifToken, $otpCode) {
    $url = "https://votre-domaine.com/api/verify-otp";
    $data = [
        "verifToken" => $verifToken,
        "otp" => $otpCode
    ];
    
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        "Content-Type: application/json",
        "api-key: VOTRE_CLE_API"
    ]);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode !== 200) {
        throw new Exception("Erreur lors de la vérification de l'OTP");
    }
    
    $result = json_decode($response, true);
    return $result["success"];
}
?>

Node.js​

Envoi d'OTP​

const axios = require('axios');

async function sendOTP(phoneNumber, userIP) {
  try {
    const response = await axios.post(
      'https://votre-domaine.com/api/send-otp',
      {
        phoneNumber: phoneNumber,
        ipAdress: userIP,
        channel: 'sms',
        lang: 'ar'
      },
      {
        headers: {
          'Content-Type': 'application/json',
          'api-key': process.env.IBTIKAR_API_KEY
        }
      }
    );
    
    return response.data.verifToken;
  } catch (error) {
    throw new Error(error.response?.data?.message || 'Erreur lors de l\'envoi de l\'OTP');
  }
}

Vérification d'OTP​

async function verifyOTP(verifToken, otpCode) {
  try {
    const response = await axios.post(
      'https://votre-domaine.com/api/verify-otp',
      {
        verifToken: verifToken,
        otp: otpCode
      },
      {
        headers: {
          'Content-Type': 'application/json',
          'api-key': process.env.IBTIKAR_API_KEY
        }
      }
    );
    
    return response.data.success;
  } catch (error) {
    throw new Error(error.response?.data?.message || 'Erreur lors de la vérification de l\'OTP');
  }
}

module.exports = { sendOTP, verifyOTP };

Python​

Envoi d'OTP​

import requests
import os

def send_otp(phone_number, user_ip):
    url = "https://votre-domaine.com/api/send-otp"
    headers = {
        "Content-Type": "application/json",
        "api-key": os.getenv("IBTIKAR_API_KEY", "VOTRE_CLE_API")
    }
    data = {
        "phoneNumber": phone_number,
        "ipAdress": user_ip,
        "channel": "sms",
        "lang": "ar"
    }
    
    try:
        response = requests.post(url, json=data, headers=headers)
        response.raise_for_status()
        result = response.json()
        return result["verifToken"]
    except requests.exceptions.RequestException as e:
        raise Exception(f"Erreur lors de l'envoi de l'OTP: {str(e)}")

Vérification d'OTP​

def verify_otp(verif_token, otp_code):
    url = "https://votre-domaine.com/api/verify-otp"
    headers = {
        "Content-Type": "application/json",
        "api-key": os.getenv("IBTIKAR_API_KEY", "VOTRE_CLE_API")
    }
    data = {
        "verifToken": verif_token,
        "otp": otp_code
    }
    
    try:
        response = requests.post(url, json=data, headers=headers)
        response.raise_for_status()
        result = response.json()
        return result["success"]
    except requests.exceptions.RequestException as e:
        raise Exception(f"Erreur lors de la vérification de l'OTP: {str(e)}")

Angular​

Service OTP​

import { Injectable } from '@angular/core';
import { HttpClient, HttpHeaders } from '@angular/common/http';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';

@Injectable({
  providedIn: 'root'
})
export class OTPService {
  private apiUrl = 'https://votre-domaine.com/api';
  private apiKey = 'VOTRE_CLE_API';

  constructor(private http: HttpClient) {}

  sendOTP(phoneNumber: string, userIP: string): Observable<string> {
    const headers = new HttpHeaders({
      'Content-Type': 'application/json',
      'api-key': this.apiKey
    });

    const body = {
      phoneNumber: phoneNumber,
      ipAdress: userIP,
      channel: 'sms',
      lang: 'ar'
    };

    return this.http.post<{success: boolean, verifToken: string}>(
      `${this.apiUrl}/send-otp`,
      body,
      { headers }
    ).pipe(
      map(response => response.verifToken)
    );
  }

  verifyOTP(verifToken: string, otp: string): Observable<boolean> {
    const headers = new HttpHeaders({
      'Content-Type': 'application/json',
      'api-key': this.apiKey
    });

    const body = {
      verifToken: verifToken,
      otp: otp
    };

    return this.http.post<{success: boolean}>(
      `${this.apiUrl}/verify-otp`,
      body,
      { headers }
    ).pipe(
      map(response => response.success)
    );
  }
}

Composant Angular​

import { Component } from '@angular/core';
import { OTPService } from './otp.service';

@Component({
  selector: 'app-otp-verification',
  template: `
    <div>
      <h2>Vérification OTP</h2>
      
      <div *ngIf="!verifToken">
        <input
          type="tel"
          placeholder="Numéro de téléphone (+222...)"
          [(ngModel)]="phoneNumber"
        />
        <button (click)="sendOTP()" [disabled]="loading">
          {{ loading ? 'Envoi...' : 'Envoyer le code' }}
        </button>
      </div>
      
      <div *ngIf="verifToken">
        <input
          type="text"
          placeholder="Code OTP (6 chiffres)"
          [(ngModel)]="otpCode"
          maxlength="6"
        />
        <button (click)="verifyOTP()" [disabled]="loading">
          {{ loading ? 'Vérification...' : 'Vérifier' }}
        </button>
      </div>
      
      <p *ngIf="error" style="color: red;">{{ error }}</p>
    </div>
  `
})
export class OTPVerificationComponent {
  phoneNumber = '';
  otpCode = '';
  verifToken: string | null = null;
  loading = false;
  error: string | null = null;

  constructor(private otpService: OTPService) {}

  async sendOTP() {
    this.loading = true;
    this.error = null;

    try {
      // Récupérer l'IP de l'utilisateur
      const ipResponse = await fetch('https://api.ipify.org?format=json');
      const ipData = await ipResponse.json();
      const userIP = ipData.ip;

      this.otpService.sendOTP(this.phoneNumber, userIP).subscribe({
        next: (token) => {
          this.verifToken = token;
          alert('Code OTP envoyé avec succès!');
          this.loading = false;
        },
        error: (err) => {
          this.error = err.message || 'Erreur lors de l\'envoi de l\'OTP';
          this.loading = false;
        }
      });
    } catch (err: any) {
      this.error = err.message;
      this.loading = false;
    }
  }

  verifyOTP() {
    if (!this.verifToken) return;

    this.loading = true;
    this.error = null;

    this.otpService.verifyOTP(this.verifToken, this.otpCode).subscribe({
      next: (success) => {
        if (success) {
          alert('OTP vérifié avec succès!');
          // Rediriger ou continuer le processus d'authentification
        }
        this.loading = false;
      },
      error: (err) => {
        this.error = err.message || 'Erreur lors de la vérification de l\'OTP';
        this.loading = false;
      }
    });
  }
}