Exemples de Code

Utilisez nos APIs COBOL avec Python ou Node.js

Exemples Python

Python

Analyse de code COBOL

Analysez un programme COBOL via l'API : détection d'erreurs, calcul de complexité, suggestions d'amélioration.

Fonctionnalités :

Analyse statique complète
Détection de problèmes
Calcul de complexité
Suggestions d'amélioration

#!/usr/bin/env python3
"""
Exemple d'utilisation de l'API UbnBee pour analyser du code COBOL
"""

import os
import requests
import json

# Configuration
API_KEY = os.getenv("UBNBEE_API_KEY", "votre_cle_api_ici")
API_URL = "https://api.ubnbee.ai/v1/cobol/analyze"

# Code COBOL à analyser
cobol_code = """
       IDENTIFICATION DIVISION.
       PROGRAM-ID. CUSTOMER-REPORT.
       
       ENVIRONMENT DIVISION.
       INPUT-OUTPUT SECTION.
       FILE-CONTROL.
           SELECT CUSTOMER-FILE ASSIGN TO 'CUSTOMERS.DAT'
           ORGANIZATION IS LINE SEQUENTIAL.
       
       DATA DIVISION.
       FILE SECTION.
       FD CUSTOMER-FILE.
       01 CUSTOMER-RECORD.
          05 CUSTOMER-ID       PIC 9(6).
          05 CUSTOMER-NAME     PIC X(30).
          05 CUSTOMER-BALANCE  PIC 9(7)V99.
       
       WORKING-STORAGE SECTION.
       01 WS-EOF              PIC A VALUE 'N'.
       01 WS-TOTAL-BALANCE    PIC 9(9)V99 VALUE ZERO.
       01 WS-CUSTOMER-COUNT   PIC 9(5) VALUE ZERO.
       
       PROCEDURE DIVISION.
       MAIN-PROCEDURE.
           OPEN INPUT CUSTOMER-FILE
           PERFORM UNTIL WS-EOF = 'Y'
               READ CUSTOMER-FILE
                   AT END MOVE 'Y' TO WS-EOF
                   NOT AT END
                       PERFORM PROCESS-CUSTOMER
               END-READ
           END-PERFORM
           PERFORM DISPLAY-SUMMARY
           CLOSE CUSTOMER-FILE
           STOP RUN.
       
       PROCESS-CUSTOMER.
           ADD 1 TO WS-CUSTOMER-COUNT
           ADD CUSTOMER-BALANCE TO WS-TOTAL-BALANCE
           DISPLAY 'Customer: ' CUSTOMER-NAME 
                   ' Balance: ' CUSTOMER-BALANCE.
       
       DISPLAY-SUMMARY.
           DISPLAY 'Total customers: ' WS-CUSTOMER-COUNT
           DISPLAY 'Total balance: ' WS-TOTAL-BALANCE.
"""

def analyze_cobol_code(code: str) -> dict:
    """
    Analyse du code COBOL via l'API UbnBee
    
    Args:
        code: Le code COBOL à analyser
        
    Returns:
        dict: Résultat de l'analyse
    """
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "code": code,
        "options": {
            "detect_issues": True,
            "complexity_analysis": True,
            "standards_check": "COBOL-2014"
        }
    }
    
    response = requests.post(API_URL, headers=headers, json=payload)
    response.raise_for_status()
    
    return response.json()

def main():
    """Point d'entrée principal"""
    print("🔍 Analyse du code COBOL...\n")
    
    try:
        result = analyze_cobol_code(cobol_code)
        
        # Afficher les résultats
        analysis = result.get("analysis", {})
        
        print(f"✅ Analyse réussie!")
        print(f"\n📊 Statistiques:")
        print(f"  - Program ID: {analysis.get('program_id')}")
        print(f"  - Divisions: {', '.join(analysis.get('divisions', []))}")
        print(f"  - Lignes de code: {analysis.get('lines_of_code')}")
        print(f"  - Complexité: {analysis.get('complexity_score')}")
        
        # Afficher les problèmes détectés
        issues = analysis.get("issues", [])
        if issues:
            print(f"\n⚠️  Problèmes détectés ({len(issues)}):")
            for issue in issues:
                print(f"  - Ligne {issue.get('line')}: [{issue.get('severity')}] {issue.get('message')}")
        else:
            print("\n✅ Aucun problème détecté!")
        
        # Afficher les suggestions
        suggestions = analysis.get("suggestions", [])
        if suggestions:
            print(f"\n💡 Suggestions d'amélioration:")
            for suggestion in suggestions:
                print(f"  - {suggestion}")
        
        # Tokens utilisés
        print(f"\n💰 Tokens utilisés: {result.get('tokens_used')}")
        
    except requests.exceptions.HTTPError as e:
        print(f"❌ Erreur HTTP: {e}")
        print(f"Réponse: {e.response.text}")
    except Exception as e:
        print(f"❌ Erreur: {e}")

if __name__ == "__main__":
    main()

Python

Génération de documentation

Générez automatiquement la documentation technique pour vos fichiers COBOL (Markdown, HTML, PDF).

Fonctionnalités :

Documentation automatique
Formats multiples (MD, HTML, PDF)
Traitement par lot
Diagrammes inclus

Télécharger Voir le code

#!/usr/bin/env python3
"""
Exemple de génération de documentation pour du code COBOL
"""

import os
import requests

API_KEY = os.getenv("UBNBEE_API_KEY", "votre_cle_api_ici")
API_URL = "https://api.ubnbee.ai/v1/cobol/documentation"

def generate_documentation(cobol_file: str, output_file: str, format: str = "markdown"):
    """
    Génère la documentation d'un fichier COBOL
    
    Args:
        cobol_file: Chemin vers le fichier COBOL
        output_file: Fichier de sortie pour la documentation
        format: Format de sortie (markdown, html, pdf)
    """
    # Lire le code COBOL
    with open(cobol_file, 'r') as f:
        cobol_code = f.read()
    
    # Appel API
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "code": cobol_code,
        "format": format,
        "language": "fr",
        "include_diagrams": True
    }
    
    print(f"📝 Génération de la documentation ({format})...")
    
    response = requests.post(API_URL, headers=headers, json=payload)
    response.raise_for_status()
    
    result = response.json()
    
    # Sauvegarder la documentation
    with open(output_file, 'w', encoding='utf-8') as f:
        f.write(result.get("content", ""))
    
    print(f"✅ Documentation générée: {output_file}")
    print(f"💰 Tokens utilisés: {result.get('tokens_used')}")

def main():
    """Point d'entrée principal"""
    # Exemple d'utilisation
    cobol_files = [
        "program1.cbl",
        "program2.cbl",
        "program3.cbl"
    ]
    
    for cobol_file in cobol_files:
        if os.path.exists(cobol_file):
            output_file = f"{cobol_file}.md"
            try:
                generate_documentation(cobol_file, output_file)
            except Exception as e:
                print(f"❌ Erreur pour {cobol_file}: {e}")
        else:
            print(f"⚠️  Fichier introuvable: {cobol_file}")

if __name__ == "__main__":
    main()

Exemples Node.js

Node.js

Analyse de code COBOL

Version Node.js de l'analyseur COBOL avec axios. Parfait pour intégration dans des workflows JS.

Fonctionnalités :

API asynchrone (async/await)
Gestion des erreurs
Module réutilisable
Compatible ES6+

Télécharger Voir le code

#!/usr/bin/env node
/**
 * Exemple d'utilisation de l'API UbnBee pour analyser du code COBOL
 */

const axios = require('axios');
const fs = require('fs').promises;

// Configuration
const API_KEY = process.env.UBNBEE_API_KEY || 'votre_cle_api_ici';
const API_URL = 'https://api.ubnbee.ai/v1/cobol/analyze';

// Code COBOL à analyser
const cobolCode = `
       IDENTIFICATION DIVISION.
       PROGRAM-ID. CUSTOMER-REPORT.
       
       ENVIRONMENT DIVISION.
       INPUT-OUTPUT SECTION.
       FILE-CONTROL.
           SELECT CUSTOMER-FILE ASSIGN TO 'CUSTOMERS.DAT'
           ORGANIZATION IS LINE SEQUENTIAL.
       
       DATA DIVISION.
       FILE SECTION.
       FD CUSTOMER-FILE.
       01 CUSTOMER-RECORD.
          05 CUSTOMER-ID       PIC 9(6).
          05 CUSTOMER-NAME     PIC X(30).
          05 CUSTOMER-BALANCE  PIC 9(7)V99.
       
       WORKING-STORAGE SECTION.
       01 WS-EOF              PIC A VALUE 'N'.
       01 WS-TOTAL-BALANCE    PIC 9(9)V99 VALUE ZERO.
       01 WS-CUSTOMER-COUNT   PIC 9(5) VALUE ZERO.
       
       PROCEDURE DIVISION.
       MAIN-PROCEDURE.
           OPEN INPUT CUSTOMER-FILE
           PERFORM UNTIL WS-EOF = 'Y'
               READ CUSTOMER-FILE
                   AT END MOVE 'Y' TO WS-EOF
                   NOT AT END
                       PERFORM PROCESS-CUSTOMER
               END-READ
           END-PERFORM
           PERFORM DISPLAY-SUMMARY
           CLOSE CUSTOMER-FILE
           STOP RUN.
       
       PROCESS-CUSTOMER.
           ADD 1 TO WS-CUSTOMER-COUNT
           ADD CUSTOMER-BALANCE TO WS-TOTAL-BALANCE
           DISPLAY 'Customer: ' CUSTOMER-NAME 
                   ' Balance: ' CUSTOMER-BALANCE.
       
       DISPLAY-SUMMARY.
           DISPLAY 'Total customers: ' WS-CUSTOMER-COUNT
           DISPLAY 'Total balance: ' WS-TOTAL-BALANCE.
`;

/**
 * Analyse du code COBOL via l'API UbnBee
 * @param {string} code - Le code COBOL à analyser
 * @returns {Promise<object>} Résultat de l'analyse
 */
async function analyzeCobolCode(code) {
    const response = await axios.post(
        API_URL,
        {
            code: code,
            options: {
                detect_issues: true,
                complexity_analysis: true,
                standards_check: 'COBOL-2014'
            }
        },
        {
            headers: {
                'Authorization': `Bearer ${API_KEY}`,
                'Content-Type': 'application/json'
            }
        }
    );
    
    return response.data;
}

/**
 * Point d'entrée principal
 */
async function main() {
    console.log('🔍 Analyse du code COBOL...\n');
    
    try {
        const result = await analyzeCobolCode(cobolCode);
        const analysis = result.analysis;
        
        // Afficher les résultats
        console.log('✅ Analyse réussie!');
        console.log('\n📊 Statistiques:');
        console.log(`  - Program ID: ${analysis.program_id}`);
        console.log(`  - Divisions: ${analysis.divisions.join(', ')}`);
        console.log(`  - Lignes de code: ${analysis.lines_of_code}`);
        console.log(`  - Complexité: ${analysis.complexity_score}`);
        
        // Afficher les problèmes détectés
        if (analysis.issues && analysis.issues.length > 0) {
            console.log(`\n⚠️  Problèmes détectés (${analysis.issues.length}):`);
            analysis.issues.forEach(issue => {
                console.log(`  - Ligne ${issue.line}: [${issue.severity}] ${issue.message}`);
            });
        } else {
            console.log('\n✅ Aucun problème détecté!');
        }
        
        // Afficher les suggestions
        if (analysis.suggestions && analysis.suggestions.length > 0) {
            console.log('\n💡 Suggestions d\'amélioration:');
            analysis.suggestions.forEach(suggestion => {
                console.log(`  - ${suggestion}`);
            });
        }
        
        // Tokens utilisés
        console.log(`\n💰 Tokens utilisés: ${result.tokens_used}`);
        
    } catch (error) {
        if (error.response) {
            console.error(`❌ Erreur HTTP ${error.response.status}: ${error.response.data}`);
        } else {
            console.error(`❌ Erreur: ${error.message}`);
        }
        process.exit(1);
    }
}

// Exécuter si appelé directement
if (require.main === module) {
    main().catch(console.error);
}

module.exports = { analyzeCobolCode };

Node.js

Génération de documentation

Générez la documentation pour tout un répertoire de fichiers COBOL. Idéal pour CI/CD.

Fonctionnalités :

Traitement récursif
CLI friendly
Export HTML/Markdown
Intégration GitLab/GitHub

Télécharger Voir le code

#!/usr/bin/env node
/**
 * Exemple de génération de documentation pour du code COBOL
 */

const axios = require('axios');
const fs = require('fs').promises;
const path = require('path');

const API_KEY = process.env.UBNBEE_API_KEY || 'votre_cle_api_ici';
const API_URL = 'https://api.ubnbee.ai/v1/cobol/documentation';

/**
 * Génère la documentation d'un fichier COBOL
 * @param {string} cobolFile - Chemin vers le fichier COBOL
 * @param {string} outputFile - Fichier de sortie pour la documentation
 * @param {string} format - Format de sortie (markdown, html, pdf)
 */
async function generateDocumentation(cobolFile, outputFile, format = 'markdown') {
    // Lire le code COBOL
    const cobolCode = await fs.readFile(cobolFile, 'utf8');
    
    console.log(`📝 Génération de la documentation (${format})...`);
    
    // Appel API
    const response = await axios.post(
        API_URL,
        {
            code: cobolCode,
            format: format,
            language: 'fr',
            include_diagrams: true
        },
        {
            headers: {
                'Authorization': `Bearer ${API_KEY}`,
                'Content-Type': 'application/json'
            }
        }
    );
    
    // Sauvegarder la documentation
    await fs.writeFile(outputFile, response.data.content, 'utf8');
    
    console.log(`✅ Documentation générée: ${outputFile}`);
    console.log(`💰 Tokens utilisés: ${response.data.tokens_used}`);
}

/**
 * Génère la documentation pour tous les fichiers COBOL d'un répertoire
 * @param {string} srcDir - Répertoire source contenant les fichiers COBOL
 * @param {string} docsDir - Répertoire de destination pour la documentation
 */
async function generateDocsForDirectory(srcDir, docsDir) {
    // Créer le répertoire de destination s'il n'existe pas
    await fs.mkdir(docsDir, { recursive: true });
    
    // Lire tous les fichiers
    const files = await fs.readdir(srcDir);
    const cobolFiles = files.filter(f => f.endsWith('.cbl') || f.endsWith('.cob'));
    
    console.log(`📂 Traitement de ${cobolFiles.length} fichiers COBOL...\n`);
    
    let totalTokens = 0;
    
    for (const file of cobolFiles) {
        const filepath = path.join(srcDir, file);
        const docPath = path.join(docsDir, `${file}.html`);
        
        try {
            await generateDocumentation(filepath, docPath, 'html');
            
            // Lire les tokens utilisés (simplifié pour l'exemple)
            // totalTokens += result.tokens_used;
            
        } catch (error) {
            console.error(`❌ Erreur pour ${file}: ${error.message}`);
        }
    }
    
    console.log(`\n✅ Documentation complète générée dans ${docsDir}`);
    console.log(`💰 Total tokens estimé: ${totalTokens}`);
}

/**
 * Point d'entrée principal
 */
async function main() {
    const args = process.argv.slice(2);
    
    if (args.length < 2) {
        console.log('Usage: node generate_documentation.js <src_dir> <docs_dir>');
        console.log('');
        console.log('Exemple:');
        console.log('  node generate_documentation.js ./src/cobol ./docs');
        process.exit(1);
    }
    
    const [srcDir, docsDir] = args;
    
    try {
        await generateDocsForDirectory(srcDir, docsDir);
    } catch (error) {
        console.error(`❌ Erreur: ${error.message}`);
        process.exit(1);
    }
}

// Exécuter si appelé directement
if (require.main === module) {
    main().catch(console.error);
}

module.exports = { generateDocumentation, generateDocsForDirectory };

Guide d'utilisation complet

Téléchargez le README avec les instructions complètes, prérequis, et cas d'usage avancés.

Télécharger README.md

Besoin de plus d'aide ?

Consultez notre documentation complète ou obtenez votre clé API gratuite

Documentation API Obtenir une clé API

Ubnbee AI ^©

Nos chatbots intelligents améliorent l'expérience client et automatisent les tâches essentielles. Une solution évolutive et personnalisée pour entreprises, e-commerce, restaurants et services B2B.

7 jours d'essai gratuit.

DISCUTER AVEC NOTRE IA

Exemples de Code

Exemples Python

Analyse de code COBOL

Fonctionnalités :

Génération de documentation

Fonctionnalités :

Exemples Node.js

Analyse de code COBOL

Fonctionnalités :

Génération de documentation

Fonctionnalités :

Guide d'utilisation complet

Besoin de plus d'aide ?

Ubnbee AI ^©

Suivez-nous

Partager

Exemples de Code

Exemples Python

Analyse de code COBOL

Fonctionnalités :

Génération de documentation

Fonctionnalités :

Exemples Node.js

Analyse de code COBOL

Fonctionnalités :

Génération de documentation

Fonctionnalités :

Guide d'utilisation complet

Besoin de plus d'aide ?

Ubnbee AI ©

Suivez-nous

Partager

Ubnbee AI ^©