Validation du Numéro de Téléphone

Vue d’ensemble

Validez toujours les numéros de téléphone avant de soumettre des commandes de recharge internet. Cela prévient les erreurs, réduit les remboursements et améliore l’expérience utilisateur en détectant immédiatement les problèmes de format.

Étape critique : La validation prévient 90% des échecs de commande. Ne sautez jamais cette étape.

Référence API

GET /v3/internet/check-number

Documentation complète de l’endpoint

Formats de numéro de téléphone

ADSL
4G LTE

Modèle : ^0[0-9]{8}$Description : 9 chiffres commençant par 0Exemples valides :

✅ 036362608
✅ 031417237
✅ 021123456

Exemples invalides :

❌ 36362608 - Zéro de tête manquant
❌ 0363626081 - Trop long (10 chiffres)
❌ 213636362608 - Format incorrect (contient l’indicatif pays)
❌ +213636362608 - Format incorrect (contient +)

Modèle : ^213[0-9]{9}$Description : 12 chiffres commençant par 213 (indicatif pays)Exemples valides :

✅ 213472731602
✅ 213665983439
✅ 213778037340

Exemples invalides :

❌ 0665983439 - Indicatif pays manquant
❌ 665983439 - Indicatif pays manquant
❌ +213665983439 - Contient le symbole +
❌ 2136659834399 - Trop long

Validation de base

async function validateInternetNumber(type, number) {
  const response = await fetch(
    `https://api.oneclickdz.com/v3/internet/check-number?type=${type}&number=${number}`,
    {
      headers: {
        "X-Access-Token": process.env.API_KEY,
      },
    }
  );

  if (!response.ok) {
    const error = await response.json();
    throw new Error(error.error.message);
  }

  const result = await response.json();
  return result.data;
}

// Usage
try {
  await validateInternetNumber('ADSL', '036362608');
  console.log('✅ Number is valid');
} catch (error) {
  console.error('❌ Validation failed:', error.message);
}

import requests
import os

def validate_internet_number(service_type, number):
    response = requests.get(
        'https://api.oneclickdz.com/v3/internet/check-number',
        headers={'X-Access-Token': os.getenv('API_KEY')},
        params={'type': service_type, 'number': number}
    )
    
    if not response.ok:
        error = response.json()
        raise ValueError(error['error']['message'])
    
    return response.json()['data']

# Usage
try:
    validate_internet_number('ADSL', '036362608')
    print('✅ Number is valid')
except ValueError as e:
    print(f'❌ Validation failed: {e}')

<?php

function validateInternetNumber($type, $number) {
    $url = "https://api.oneclickdz.com/v3/internet/check-number";
    $url .= "?type=" . urlencode($type) . "&number=" . urlencode($number);
    
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'X-Access-Token: ' . getenv('API_KEY')
    ]);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode !== 200) {
        $error = json_decode($response, true);
        throw new Exception($error['error']['message']);
    }
    
    return json_decode($response, true)['data'];
}

// Usage
try {
    validateInternetNumber('ADSL', '036362608');
    echo "✅ Number is valid\n";
} catch (Exception $e) {
    echo "❌ Validation failed: " . $e->getMessage() . "\n";
}
?>

# Valider un numéro ADSL
curl "https://api.oneclickdz.com/v3/internet/check-number?type=ADSL&number=036362608" \
  -H "X-Access-Token: YOUR_API_KEY"

# Valider un numéro 4G
curl "https://api.oneclickdz.com/v3/internet/check-number?type=4G&number=213665983439" \
  -H "X-Access-Token: YOUR_API_KEY"

Validation de format côté client

Validez le format côté client en premier pour un retour instantané :

function validateADSLFormat(number) {
  const pattern = /^0[0-9]{8}$/;
  return pattern.test(number);
}

function validate4GFormat(number) {
  const pattern = /^213[0-9]{9}$/;
  return pattern.test(number);
}

function validateFormat(type, number) {
  if (type === 'ADSL') {
    return validateADSLFormat(number);
  } else if (type === '4G') {
    return validate4GFormat(number);
  }
  return false;
}

// Usage
const number = '036362608';
const type = 'ADSL';

if (!validateFormat(type, number)) {
  console.error('Invalid format. Please check the number.');
} else {
  // Le format est correct, validez maintenant avec l'API
  await validateInternetNumber(type, number);
}

import re

def validate_adsl_format(number):
    pattern = r'^0[0-9]{8}$'
    return bool(re.match(pattern, number))

def validate_4g_format(number):
    pattern = r'^213[0-9]{9}$'
    return bool(re.match(pattern, number))

def validate_format(service_type, number):
    if service_type == 'ADSL':
        return validate_adsl_format(number)
    elif service_type == '4G':
        return validate_4g_format(number)
    return False

# Usage
number = '036362608'
service_type = 'ADSL'

if not validate_format(service_type, number):
    print('Invalid format. Please check the number.')
else:
    # Le format est correct, validez maintenant avec l'API
    validate_internet_number(service_type, number)

<?php

function validateADSLFormat($number) {
    return preg_match('/^0[0-9]{8}$/', $number) === 1;
}

function validate4GFormat($number) {
    return preg_match('/^213[0-9]{9}$/', $number) === 1;
}

function validateFormat($type, $number) {
    if ($type === 'ADSL') {
        return validateADSLFormat($number);
    } elseif ($type === '4G') {
        return validate4GFormat($number);
    }
    return false;
}

// Usage
$number = '036362608';
$type = 'ADSL';

if (!validateFormat($type, $number)) {
    echo "Invalid format. Please check the number.\n";
} else {
    // Le format est correct, validez maintenant avec l'API
    validateInternetNumber($type, $number);
}
?>

Flux de validation complet

async function validateCompleteFlow(type, number) {
  // Étape 1 : Valider le type de service
  if (!['ADSL', '4G'].includes(type)) {
    return {
      valid: false,
      error: 'INVALID_TYPE',
      message: 'Service type must be ADSL or 4G'
    };
  }

  // Étape 2 : Vérification du format côté client
  if (!validateFormat(type, number)) {
    return {
      valid: false,
      error: 'INVALID_FORMAT',
      message: type === 'ADSL' 
        ? 'ADSL numbers must be 9 digits starting with 0 (e.g., 036362608)'
        : '4G numbers must be 12 digits starting with 213 (e.g., 213665983439)'
    };
  }

  // Étape 3 : Validation via API
  try {
    await validateInternetNumber(type, number);
    return {
      valid: true,
      type,
      number
    };
  } catch (error) {
    return {
      valid: false,
      error: 'API_VALIDATION_FAILED',
      message: error.message
    };
  }
}

// Usage
const result = await validateCompleteFlow('ADSL', '036362608');

if (!result.valid) {
  console.error(`Validation failed: ${result.message}`);
} else {
  console.log('✅ Ready to place order');
}

async def validate_complete_flow(service_type, number):
    # Étape 1 : Valider le type de service
    if service_type not in ['ADSL', '4G']:
        return {
            'valid': False,
            'error': 'INVALID_TYPE',
            'message': 'Service type must be ADSL or 4G'
        }
    
    # Étape 2 : Vérification du format côté client
    if not validate_format(service_type, number):
        message = (
            'ADSL numbers must be 9 digits starting with 0 (e.g., 036362608)'
            if service_type == 'ADSL'
            else '4G numbers must be 12 digits starting with 213 (e.g., 213665983439)'
        )
        return {
            'valid': False,
            'error': 'INVALID_FORMAT',
            'message': message
        }
    
    # Étape 3 : Validation via API
    try:
        validate_internet_number(service_type, number)
        return {
            'valid': True,
            'type': service_type,
            'number': number
        }
    except Exception as e:
        return {
            'valid': False,
            'error': 'API_VALIDATION_FAILED',
            'message': str(e)
        }

# Usage
result = await validate_complete_flow('ADSL', '036362608')

if not result['valid']:
    print(f"Validation failed: {result['message']}")
else:
    print('✅ Ready to place order')

<?php

function validateCompleteFlow($type, $number) {
    // Étape 1 : Valider le type de service
    if (!in_array($type, ['ADSL', '4G'])) {
        return [
            'valid' => false,
            'error' => 'INVALID_TYPE',
            'message' => 'Service type must be ADSL or 4G'
        ];
    }
    
    // Étape 2 : Vérification du format côté client
    if (!validateFormat($type, $number)) {
        $message = $type === 'ADSL'
            ? 'ADSL numbers must be 9 digits starting with 0 (e.g., 036362608)'
            : '4G numbers must be 12 digits starting with 213 (e.g., 213665983439)';
        
        return [
            'valid' => false,
            'error' => 'INVALID_FORMAT',
            'message' => $message
        ];
    }
    
    // Étape 3 : Validation via API
    try {
        validateInternetNumber($type, $number);
        return [
            'valid' => true,
            'type' => $type,
            'number' => $number
        ];
    } catch (Exception $e) {
        return [
            'valid' => false,
            'error' => 'API_VALIDATION_FAILED',
            'message' => $e->getMessage()
        ];
    }
}

// Usage
$result = validateCompleteFlow('ADSL', '036362608');

if (!$result['valid']) {
    echo "Validation failed: {$result['message']}\n";
} else {
    echo "✅ Ready to place order\n";
}
?>

Mise en cache de la validation

Mettez en cache brièvement les validations réussies pour réduire les appels API :

class ValidationCache {
  constructor(ttlSeconds = 300) { // 5 minutes
    this.cache = new Map();
    this.ttl = ttlSeconds * 1000;
  }

  async validate(type, number) {
    const key = `${type}:${number}`;
    const cached = this.cache.get(key);
    const now = Date.now();

    // Return cached if valid
    if (cached && (now - cached.timestamp) < this.ttl) {
      return cached.result;
    }

    // Validate with API
    try {
      const result = await validateInternetNumber(type, number);
      this.cache.set(key, {
        result: { valid: true, ...result },
        timestamp: now,
      });
      return { valid: true, ...result };
    } catch (error) {
      // Don't cache failures
      throw error;
    }
  }

  invalidate(type, number) {
    const key = `${type}:${number}`;
    this.cache.delete(key);
  }
}

// Usage
const validationCache = new ValidationCache(300); // 5 minutes

// First call - validates with API
const result1 = await validationCache.validate('ADSL', '036362608');

// Second call within 5 minutes - returns cached
const result2 = await validationCache.validate('ADSL', '036362608');

Messages d’Erreur Conviviaux

Fournissez des retours clairs selon le type d’erreur :

function getValidationErrorMessage(type, error) {
  const messages = {
    INVALID_TYPE: 'Veuillez sélectionner ADSL ou 4G comme type de service.',
    
    INVALID_FORMAT: {
      ADSL: 'Veuillez saisir un numéro ADSL valide (9 chiffres commençant par 0).\nExemple : 036362608',
      '4G': 'Veuillez saisir un numéro 4G valide (12 chiffres commençant par 213).\nExemple : 213665983439'
    },
    
    API_VALIDATION_FAILED: {
      default: 'Ce numéro n\'est pas valide pour le type de service sélectionné.',
      'ERR_PHONE': 'Ce numéro ne peut pas être utilisé pour la recharge internet.'
    }
  };
  
  if (error === 'INVALID_FORMAT') {
    return messages.INVALID_FORMAT[type];
  }
  
  if (error === 'API_VALIDATION_FAILED') {
    return messages.API_VALIDATION_FAILED.default;
  }
  
  return messages[error] || 'Impossible de valider le numéro. Veuillez réessayer.';
}

Tests de Validation

async function testValidation() {
  const testCases = [
    // Tests ADSL
    { type: 'ADSL', number: '036362608', expected: true },
    { type: 'ADSL', number: '031417237', expected: true },
    { type: 'ADSL', number: '36362608', expected: false },  // 0 manquant
    { type: 'ADSL', number: '0363626081', expected: false }, // Trop long
    
    // Tests 4G
    { type: '4G', number: '213665983439', expected: true },
    { type: '4G', number: '213472731602', expected: true },
    { type: '4G', number: '0665983439', expected: false },   // Mauvais format
    { type: '4G', number: '+213665983439', expected: false }, // Contient +
  ];

  console.log('🧪 Test de validation...\n');

  for (const test of testCases) {
    const result = await validateCompleteFlow(test.type, test.number);
    const passed = result.valid === test.expected;
    
    console.log(
      `${passed ? '✅' : '❌'} ${test.type} ${test.number}: ${result.valid ? 'VALIDE' : 'INVALIDE'}`
    );
    
    if (!passed) {
      console.log(`  Attendu : ${test.expected}, Obtenu : ${result.valid}`);
      if (!result.valid) {
        console.log(`  Erreur : ${result.message}`);
      }
    }
  }
}

Bonnes pratiques

Valider tôt

Vérifier le format côté client avant l’appel API

Messages clairs

Afficher des messages d’erreur spécifiques et utiles

Mettre en cache les résultats

Mettre en cache les numéros valides pendant 5 minutes

Retour visuel

Afficher le statut de validation en temps réel pendant la saisie

Étapes suivantes

Envoyer les recharges

Soumettre des commandes validées

Suivre le statut

Surveiller l’exécution des commandes

Référence API

Documentation complète de l’endpoint

Charger les produits

Récupérer les cartes disponibles

Vue d'ensemble

Retour à la vue d’ensemble de l’intégration

Livrer les cartes

Livrer les codes de carte en toute sécurité

​Vue d’ensemble

​Référence API

GET /v3/internet/check-number

​Formats de numéro de téléphone

​Validation de base

​Validation de format côté client

​Flux de validation complet

​Mise en cache de la validation

​Messages d’Erreur Conviviaux

​Tests de Validation

​Bonnes pratiques

Valider tôt

Messages clairs

Mettre en cache les résultats

Retour visuel

​Étapes suivantes

Envoyer les recharges

Suivre le statut

Référence API

Charger les produits

Vue d'ensemble

Livrer les cartes

Vue d’ensemble

Référence API

Formats de numéro de téléphone

Validation de base

Validation de format côté client

Flux de validation complet

Mise en cache de la validation

Messages d’Erreur Conviviaux

Tests de Validation

Bonnes pratiques

Étapes suivantes