factpulse 2.0.28 → 2.0.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d402770aa389d1c4ee3841ac164f8ea9220011efc7c739e0b80551702c91e568
-  data.tar.gz: c3e92049ac3be74229f8b742b490295cc224fed3b58d8d11718ee455c2eb6799
+  metadata.gz: 78ca875881399d5d04602d4298a5fee55f3f7249fa347fe10e7aeb2fcb0dfd9d
+  data.tar.gz: b6ec7a089da11bc8b23e5aa4d181c027b7195f4e1c55c7ef9c5e7c06104831e4
 SHA512:
-  metadata.gz: 85c36d0a607dcf1ee0509e52cab63b5da7dbdedec9bc5cd90e3b9cdd34de31c6eda0d240f5ef9908930cf7ea6d6dc091c71b028051a908bb50fe1f518c1d6527
-  data.tar.gz: 409a317e4da5e70529c61fb5c416dc5ff91c4f16c6b12a29b756f6d1770c54ee1ce9b0222dd67818b68d56ebc43399961344a4ebdc2df070bffdbd10898f4638
+  metadata.gz: 1c0ed4f46576b6b09ce2751926b947fad1a6200cb42c4c5f725df79984530b7c507761ed9fdef006671517749fce5f3f3bb327c4b0d67f1f244fb2d3f1787f93
+  data.tar.gz: e5ab5b82a5eb675daa30dbb8e129ba468616c41126ec5ee9aa17d7d907a4c17565472a86f513dfe456113de53b5adf005106200a7775348b52e045d69c74aadc

data/CHANGELOG.md

@@ -7,7 +7,7 @@ et ce projet adhère au [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ## [Unreleased]
 
-## [2.0.28] - 2025-11-27
+## [2.0.30] - 2025-11-29
 
 ### Added
 - Version initiale du SDK ruby
@@ -24,5 +24,5 @@ et ce projet adhère au [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 - Guide d'authentification JWT
 - Configuration avancée (timeout, proxy, debug)
 
-[Unreleased]: https://github.com/factpulse/sdk-ruby/compare/v2.0.28...HEAD
-[2.0.28]: https://github.com/factpulse/sdk-ruby/releases/tag/v2.0.28
+[Unreleased]: https://github.com/factpulse/sdk-ruby/compare/v2.0.30...HEAD
+[2.0.30]: https://github.com/factpulse/sdk-ruby/releases/tag/v2.0.30

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    factpulse (2.0.28)
+    factpulse (2.0.30)
       typhoeus (~> 1.0, >= 1.0.1)
 
 GEM

data/README.md

@@ -2,16 +2,15 @@
 
 Client Ruby officiel pour l'API FactPulse - Facturation électronique française.
 
-## 🎯 Fonctionnalités
+## Fonctionnalités
 
 - **Factur-X** : Génération et validation de factures électroniques (profils MINIMUM, BASIC, EN16931, EXTENDED)
 - **Chorus Pro** : Intégration avec la plateforme de facturation publique française
 - **AFNOR PDP/PA** : Soumission de flux conformes à la norme XP Z12-013
 - **Signature électronique** : Signature PDF (PAdES-B-B, PAdES-B-T, PAdES-B-LT)
 - **Client simplifié** : Authentification JWT et polling intégrés via `helpers`
-- **Ruby 2.7+** : Compatible avec les versions modernes de Ruby
 
-## 🚀 Installation
+## Installation
 
 ```bash
 gem install factpulse
@@ -23,9 +22,7 @@ Ou dans votre Gemfile :
 gem 'factpulse'
 ```
 
-## 📖 Démarrage rapide
-
-### Méthode recommandée : Client simplifié avec helpers
+## Démarrage rapide
 
 Le module `helpers` offre une API simplifiée avec authentification et polling automatiques :
 
@@ -33,175 +30,191 @@ Le module `helpers` offre une API simplifiée avec authentification et polling a
 require 'factpulse'
 require 'factpulse/helpers'
 
-# Créer le client (authentification automatique)
-client = Factpulse::Helpers::FactPulseClient.new(
-  email: 'votre_email@example.com',
-  password: 'votre_mot_de_passe'
+include Factpulse::Helpers
+
+# Créer le client
+client = FactPulseClient.new(
+  'votre_email@example.com',
+  'votre_mot_de_passe'
 )
 
-# Données de la facture
+# Construire la facture avec les helpers
 facture_data = {
-  numero_facture: 'FAC-2025-001',
-  date_facture: '2025-01-15',
-  fournisseur: {
-    nom: 'Mon Entreprise SAS',
-    siret: '12345678901234',
-    adresse_postale: {
-      ligne_un: '123 Rue Example',
-      code_postal: '75001',
-      nom_ville: 'Paris',
-      pays_code_iso: 'FR'
-    }
-  },
-  destinataire: {
-    nom: 'Client SARL',
-    siret: '98765432109876',
-    adresse_postale: {
-      ligne_un: '456 Avenue Test',
-      code_postal: '69001',
-      nom_ville: 'Lyon',
-      pays_code_iso: 'FR'
-    }
-  },
-  montant_total: {
-    montant_ht_total: '1000.00',
-    montant_tva: '200.00',
-    montant_ttc_total: '1200.00',
-    montant_a_payer: '1200.00'
-  },
-  lignes_de_poste: [{
-    numero: 1,
-    denomination: 'Prestation de conseil',
-    quantite: '10.00',
-    unite: 'PIECE',
-    montant_unitaire_ht: '100.00'
-  }]
+  numeroFacture: 'FAC-2025-001',
+  dateFacture: '2025-01-15',
+  fournisseur: fournisseur(
+    'Mon Entreprise SAS',
+    '12345678901234',
+    '123 Rue Example',
+    '75001',
+    'Paris'
+  ),
+  destinataire: destinataire(
+    'Client SARL',
+    '98765432109876',
+    '456 Avenue Test',
+    '69001',
+    'Lyon'
+  ),
+  montantTotal: montant_total(1000.00, 200.00, 1200.00, 1200.00),
+  lignesDePoste: [
+    ligne_de_poste(1, 'Prestation de conseil', 10, 100.00, 1000.00)
+  ],
+  lignesDeTva: [
+    ligne_de_tva(1000.00, 200.00)
+  ]
 }
 
-# Lire le PDF source
-pdf_source = File.binread('facture_source.pdf')
-
-# Générer le PDF Factur-X (polling automatique)
-pdf_bytes = client.generer_facturx(
-  facture_data,
-  pdf_source,
-  profil: 'EN16931',
-  format_sortie: 'pdf',
-  sync: true  # Attend le résultat automatiquement
-)
+# Générer le PDF Factur-X
+pdf_bytes = client.generer_facturx(facture_data, 'facture_source.pdf', 'EN16931')
 
-# Sauvegarder
 File.binwrite('facture_facturx.pdf', pdf_bytes)
 ```
 
-### Méthode alternative : SDK brut
+## Helpers disponibles (module Factpulse::Helpers)
 
-Pour un contrôle total, utilisez le SDK généré directement :
+### montant(value)
+
+Convertit une valeur en string formaté pour les montants monétaires.
 
 ```ruby
-require 'factpulse'
-require 'net/http'
-require 'json'
-
-# 1. Obtenir le token JWT
-uri = URI('https://factpulse.fr/api/token/')
-http = Net::HTTP.new(uri.host, uri.port)
-http.use_ssl = true
-
-request = Net::HTTP::Post.new(uri.path, { 'Content-Type' => 'application/json' })
-request.body = {
-  username: 'votre_email@example.com',
-  password: 'votre_mot_de_passe'
-}.to_json
-
-response = http.request(request)
-token = JSON.parse(response.body)['access']
-
-# 2. Configurer le client
-Factpulse.configure do |config|
-  config.host = 'https://factpulse.fr/api/facturation'
-  config.access_token = token
-end
-
-# 3. Appeler l'API
-api = Factpulse::TraitementFactureApi.new
-response = api.generer_facture_api_v1_traitement_generer_facture_post(
-  facture_data.to_json,
-  'EN16931',
-  'pdf',
-  File.open('facture_source.pdf', 'rb')
+include Factpulse::Helpers
+
+montant(1234.5)      # "1234.50"
+montant('1234.56')   # "1234.56"
+montant(nil)         # "0.00"
+```
+
+### montant_total(ht, tva, ttc, a_payer, ...)
+
+Crée un objet MontantTotal complet.
+
+```ruby
+total = montant_total(
+  1000.00,        # ht
+  200.00,         # tva
+  1200.00,        # ttc
+  1200.00,        # a_payer
+  50.00,          # remise_ttc (optionnel)
+  'Fidélité',     # motif_remise (optionnel)
+  100.00          # acompte (optionnel)
 )
+```
+
+### ligne_de_poste(numero, denomination, quantite, montant_unitaire_ht, montant_total_ligne_ht, ...)
 
-# 4. Polling manuel pour récupérer le résultat
-task_id = response.id_tache
-# ... (implémenter le polling)
+Crée une ligne de facturation.
+
+```ruby
+ligne = ligne_de_poste(
+  1,
+  'Prestation de conseil',
+  5,
+  200.00,
+  1000.00,  # montant_total_ligne_ht requis
+  'S',      # categorie_tva: S, Z, E, AE, K
+  'HEURE',  # unite: FORFAIT, PIECE, HEURE, JOUR...
+  {
+    taux_tva: 'TVA20',        # Ou taux_tva_manuel: '20.00'
+    reference: 'REF-001'
+  }
+)
 ```
 
-## 🔧 Avantages des helpers
+### ligne_de_tva(montant_base_ht, montant_tva, ...)
 
-| Fonctionnalité | SDK brut | helpers |
-|----------------|----------|---------|
-| Authentification | Manuelle | Automatique |
-| Refresh token | Manuel | Automatique |
-| Polling tâches async | Manuel | Automatique (backoff) |
-| Retry sur 401 | Manuel | Automatique |
+Crée une ligne de ventilation TVA.
 
-## 🔑 Options d'authentification
+```ruby
+tva = ligne_de_tva(
+  1000.00,    # montant_base_ht
+  200.00,     # montant_tva
+  'S',        # categorie: S, Z, E, AE, K
+  { taux: 'TVA20' }  # Ou taux_manuel: '20.00'
+)
+```
 
-### Client UID (multi-clients)
+### adresse_postale(ligne1, code_postal, ville, ...)
 
-Si vous gérez plusieurs clients :
+Crée une adresse postale structurée.
 
 ```ruby
-client = Factpulse::Helpers::FactPulseClient.new(
-  email: 'votre_email@example.com',
-  password: 'votre_mot_de_passe',
-  client_uid: 'identifiant_client'  # UID du client cible
+adresse = adresse_postale(
+  '123 Rue de la République',
+  '75001',
+  'Paris',
+  'FR',           # pays (défaut: 'FR')
+  'Bâtiment A'    # ligne2 (optionnel)
 )
 ```
 
-### Configuration avancée
+### fournisseur(nom, siret, adresse_ligne1, code_postal, ville, options)
+
+Crée un fournisseur complet avec calcul automatique du SIREN et TVA intra.
 
 ```ruby
-client = Factpulse::Helpers::FactPulseClient.new(
-  email: 'votre_email@example.com',
-  password: 'votre_mot_de_passe',
-  api_url: 'https://factpulse.fr',  # URL personnalisée
-  polling_interval: 2.0,  # Intervalle de polling initial (secondes)
-  polling_timeout: 120.0,  # Timeout de polling (secondes)
-  max_retries: 2  # Tentatives en cas de 401
+f = fournisseur(
+  'Ma Société SAS',
+  '12345678901234',
+  '123 Rue Example',
+  '75001',
+  'Paris',
+  { iban: 'FR7630006000011234567890189' }
 )
+# SIREN et TVA intracommunautaire calculés automatiquement
 ```
 
-## 💡 Formats de montants acceptés
+### destinataire(nom, siret, adresse_ligne1, code_postal, ville, options)
 
-L'API accepte plusieurs formats pour les montants :
+Crée un destinataire (client) avec calcul automatique du SIREN.
 
 ```ruby
-# String (recommandé pour la précision)
-montant = '1234.56'
+d = destinataire(
+  'Client SARL',
+  '98765432109876',
+  '456 Avenue Test',
+  '69001',
+  'Lyon'
+)
+```
 
-# Float
-montant = 1234.56
+## Mode Zero-Trust (Chorus Pro / AFNOR)
 
-# Integer
-montant = 1234
+Pour passer vos propres credentials sans stockage côté serveur :
 
-# BigDecimal
-require 'bigdecimal'
-montant = BigDecimal('1234.56')
+```ruby
+include Factpulse::Helpers
+
+chorus_creds = ChorusProCredentials.new(
+  'votre_client_id',
+  'votre_client_secret',
+  'votre_login',
+  'votre_password',
+  true  # sandbox
+)
 
-# Helper de formatage
-montant_formate = Factpulse::Helpers::FactPulseClient.format_montant(1234.5)  # => "1234.50"
+afnor_creds = AFNORCredentials.new(
+  'https://api.pdp.fr/flow/v1',
+  'https://auth.pdp.fr/oauth/token',
+  'votre_client_id',
+  'votre_client_secret'
+)
+
+client = FactPulseClient.new(
+  'votre_email@example.com',
+  'votre_mot_de_passe',
+  nil,  # api_url
+  nil,  # client_uid
+  chorus_creds,
+  afnor_creds
+)
 ```
 
-## 📚 Ressources
+## Ressources
 
 - **Documentation API** : https://factpulse.fr/api/facturation/documentation
-- **Code source** : https://github.com/factpulse/sdk-ruby
-- **Issues** : https://github.com/factpulse/sdk-ruby/issues
 - **Support** : contact@factpulse.fr
 
-## 📄 Licence
+## Licence
 
 MIT License - Copyright (c) 2025 FactPulse

data/lib/factpulse/helpers/client.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-require 'net/http'; require 'json'; require 'base64'; require 'uri'; require 'securerandom'
+require 'net/http'; require 'json'; require 'base64'; require 'uri'; require 'securerandom'; require 'digest'; require 'tempfile'
 
 module FactPulse
   module Helpers
@@ -58,7 +58,7 @@ module FactPulse
         result = {
           'numero' => numero, 'denomination' => denomination,
           'quantite' => montant(quantite), 'montantUnitaireHt' => montant(montant_unitaire_ht),
-          'montantTotalLigneHt' => montant(montant_total_ligne_ht), 'tauxTva' => montant(taux_tva),
+          'montantTotalLigneHt' => montant(montant_total_ligne_ht), 'tauxTvaManuel' => montant(taux_tva),
           'categorieTva' => categorie_tva, 'unite' => unite
         }
         result['reference'] = options[:reference] if options[:reference]
@@ -111,7 +111,7 @@ module FactPulse
         result['numeroTvaIntra'] = numero_tva_intra if numero_tva_intra
         result['iban'] = options[:iban] if options[:iban]
         result['idServiceFournisseur'] = options[:code_service] if options[:code_service]
-        result['codeCoordonnesBancairesFournisseur'] = options[:code_coordonnees_bancaires] if options[:code_coordonnees_bancaires]
+        result['codeCoordonneeBancairesFournisseur'] = options[:code_coordonnees_bancaires] if options[:code_coordonnees_bancaires]
         result
       end
 
@@ -179,14 +179,6 @@ module FactPulse
       def self.format_montant(m); MontantHelpers.montant(m); end
 
       # Génère une facture Factur-X à partir d'un dict/hash et d'un PDF source.
-      # Accepte un Hash, un String JSON, ou tout objet avec une méthode to_h/to_hash.
-      # @param facture_data [Hash, String, Object] Données de la facture
-      # @param pdf_source [String, File] Chemin vers le PDF source ou objet File
-      # @param profil [String] Profil Factur-X (MINIMUM, BASIC, EN16931, EXTENDED)
-      # @param format_sortie [String] Format de sortie (pdf, xml, both)
-      # @param sync [Boolean] Mode synchrone (true) ou asynchrone (false)
-      # @param timeout [Integer, nil] Timeout en ms pour le polling
-      # @return [String] Contenu binaire du PDF généré
       def generer_facturx(facture_data, pdf_source, profil: 'EN16931', format_sortie: 'pdf', sync: true, timeout: nil)
         # Conversion des données en JSON string
         json_data = case facture_data
@@ -220,49 +212,17 @@ module FactPulse
 
         # Construire la requête multipart
         boundary = "----RubyFormBoundary#{SecureRandom.hex(16)}"
-        body = []
+        body = build_multipart_body(boundary, [
+          { name: 'donnees_facture', content: json_data },
+          { name: 'profil', content: profil },
+          { name: 'format_sortie', content: format_sortie },
+          { name: 'source_pdf', content: pdf_content, filename: pdf_filename, content_type: 'application/pdf' }
+        ])
 
-        # Champ donnees_facture
-        body << "--#{boundary}\r\n"
-        body << "Content-Disposition: form-data; name=\"donnees_facture\"\r\n\r\n"
-        body << "#{json_data}\r\n"
-
-        # Champ profil
-        body << "--#{boundary}\r\n"
-        body << "Content-Disposition: form-data; name=\"profil\"\r\n\r\n"
-        body << "#{profil}\r\n"
-
-        # Champ format_sortie
-        body << "--#{boundary}\r\n"
-        body << "Content-Disposition: form-data; name=\"format_sortie\"\r\n\r\n"
-        body << "#{format_sortie}\r\n"
-
-        # Champ source_pdf (fichier)
-        body << "--#{boundary}\r\n"
-        body << "Content-Disposition: form-data; name=\"source_pdf\"; filename=\"#{pdf_filename}\"\r\n"
-        body << "Content-Type: application/pdf\r\n\r\n"
-        body << pdf_content
-        body << "\r\n"
-
-        body << "--#{boundary}--\r\n"
-        body_str = body.join
-
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = uri.scheme == 'https'
-        http.read_timeout = 120
-
-        request = Net::HTTP::Post.new(uri)
-        request['Authorization'] = "Bearer #{@access_token}"
-        request['Content-Type'] = "multipart/form-data; boundary=#{boundary}"
-        request.body = body_str
-
-        response = http.request(request)
+        response = http_multipart_post(uri, body, boundary)
 
         if response.code == '401'
-          reset_auth
-          ensure_authenticated
-          request['Authorization'] = "Bearer #{@access_token}"
-          response = http.request(request)
+          reset_auth; ensure_authenticated; response = http_multipart_post(uri, body, boundary)
         end
 
         unless response.is_a?(Net::HTTPSuccess)
@@ -275,7 +235,6 @@ module FactPulse
         if sync && data['id_tache']
           result = poll_task(data['id_tache'], timeout: timeout)
           if result['contenu_b64']
-            require 'base64'
             return Base64.decode64(result['contenu_b64'])
           elsif result['contenu_xml']
             return result['contenu_xml']
@@ -286,15 +245,430 @@ module FactPulse
         data
       end
 
+      # =========================================================================
+      # AFNOR PDP - Authentication et helpers internes
+      # =========================================================================
+
+      private def get_afnor_credentials_internal
+        return @afnor_credentials if @afnor_credentials
+
+        ensure_authenticated
+        response = http_get(URI("#{@api_url}/api/v1/afnor/credentials"))
+        raise FactPulseAuthError, "Failed to get AFNOR credentials" unless response.is_a?(Net::HTTPSuccess)
+        creds = JSON.parse(response.body)
+        AFNORCredentials.new(
+          flow_service_url: creds['flow_service_url'],
+          token_url: creds['token_url'],
+          client_id: creds['client_id'],
+          client_secret: creds['client_secret'],
+          directory_service_url: creds['directory_service_url']
+        )
+      end
+
+      private def get_afnor_token_and_url
+        credentials = get_afnor_credentials_internal
+        uri = URI("#{@api_url}/api/v1/afnor/oauth/token")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        request = Net::HTTP::Post.new(uri)
+        request['X-PDP-Token-URL'] = credentials.token_url
+        request.set_form_data(
+          'grant_type' => 'client_credentials',
+          'client_id' => credentials.client_id,
+          'client_secret' => credentials.client_secret
+        )
+        response = http.request(request)
+        raise FactPulseAuthError, "AFNOR OAuth2 failed" unless response.is_a?(Net::HTTPSuccess)
+        token_data = JSON.parse(response.body)
+        raise FactPulseAuthError, "Invalid AFNOR OAuth2 response" unless token_data['access_token']
+        { token: token_data['access_token'], pdp_base_url: credentials.flow_service_url }
+      end
+
+      private def make_afnor_request(method, endpoint, json_data: nil, multipart: nil)
+        token_info = get_afnor_token_and_url
+        uri = URI("#{@api_url}/api/v1/afnor#{endpoint}")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.read_timeout = 60
+
+        request = case method.upcase
+                  when 'GET' then Net::HTTP::Get.new(uri)
+                  when 'POST' then Net::HTTP::Post.new(uri)
+                  else raise "Unsupported method: #{method}"
+                  end
+
+        request['Authorization'] = "Bearer #{token_info[:token]}"
+        request['X-PDP-Base-URL'] = token_info[:pdp_base_url]
+
+        if multipart
+          boundary = "----RubyFormBoundary#{SecureRandom.hex(16)}"
+          request['Content-Type'] = "multipart/form-data; boundary=#{boundary}"
+          request.body = build_multipart_body(boundary, multipart)
+        elsif json_data
+          request['Content-Type'] = 'application/json'
+          request.body = JSON.generate(json_data)
+        end
+
+        response = http.request(request)
+        raise FactPulseValidationError.new("AFNOR error: #{response.code} - #{response.body}") unless response.is_a?(Net::HTTPSuccess)
+
+        content_type = response['Content-Type'] || ''
+        if content_type.include?('application/json')
+          JSON.parse(response.body) rescue {}
+        else
+          { '_raw' => response.body }
+        end
+      end
+
+      # ==================== AFNOR Flow Service ====================
+
+      # Soumet une facture à une PDP via l'API AFNOR.
+      def soumettre_facture_afnor(pdf_path, flow_name, **options)
+        pdf_content = File.binread(pdf_path)
+        sha256 = Digest::SHA256.hexdigest(pdf_content)
+
+        flow_info = {
+          'name' => flow_name,
+          'flowSyntax' => options[:flow_syntax] || 'CII',
+          'flowProfile' => options[:flow_profile] || 'EN16931',
+          'sha256' => sha256
+        }
+        flow_info['trackingId'] = options[:tracking_id] if options[:tracking_id]
+
+        make_afnor_request('POST', '/flow/v1/flows', multipart: [
+          { name: 'file', content: pdf_content, filename: File.basename(pdf_path), content_type: 'application/pdf' },
+          { name: 'flowInfo', content: JSON.generate(flow_info), content_type: 'application/json' }
+        ])
+      end
+
+      # Recherche des flux de facturation AFNOR.
+      def rechercher_flux_afnor(**criteria)
+        search_body = {
+          'offset' => criteria[:offset] || 0,
+          'limit' => criteria[:limit] || 25,
+          'where' => {}
+        }
+        search_body['where']['trackingId'] = criteria[:tracking_id] if criteria[:tracking_id]
+        search_body['where']['status'] = criteria[:status] if criteria[:status]
+
+        make_afnor_request('POST', '/flow/v1/flows/search', json_data: search_body)
+      end
+
+      # Télécharge le fichier PDF d'un flux AFNOR.
+      def telecharger_flux_afnor(flow_id)
+        result = make_afnor_request('GET', "/flow/v1/flows/#{flow_id}")
+        result['_raw'] || ''
+      end
+
+      # Vérifie la disponibilité du Flow Service AFNOR.
+      def healthcheck_afnor
+        make_afnor_request('GET', '/flow/v1/healthcheck')
+      end
+
+      # ==================== AFNOR Directory ====================
+
+      # Recherche une entreprise par SIRET dans l'annuaire AFNOR.
+      def rechercher_siret_afnor(siret)
+        make_afnor_request('GET', "/directory/siret/#{siret}")
+      end
+
+      # Recherche une entreprise par SIREN dans l'annuaire AFNOR.
+      def rechercher_siren_afnor(siren)
+        make_afnor_request('GET', "/directory/siren/#{siren}")
+      end
+
+      # Liste les codes de routage disponibles pour un SIREN.
+      def lister_codes_routage_afnor(siren)
+        make_afnor_request('GET', "/directory/siren/#{siren}/routing-codes")
+      end
+
+      # =========================================================================
+      # Chorus Pro
+      # =========================================================================
+
+      private def make_chorus_request(method, endpoint, json_data = nil)
+        ensure_authenticated
+        uri = URI("#{@api_url}/api/v1/chorus-pro#{endpoint}")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.read_timeout = 60
+
+        body = json_data || {}
+        body['credentials'] = @chorus_credentials.to_h if @chorus_credentials
+
+        request = case method.upcase
+                  when 'GET' then Net::HTTP::Get.new(uri)
+                  when 'POST' then Net::HTTP::Post.new(uri)
+                  else raise "Unsupported method: #{method}"
+                  end
+
+        request['Authorization'] = "Bearer #{@access_token}"
+        request['Content-Type'] = 'application/json'
+        request.body = JSON.generate(body) if body.any?
+
+        response = http.request(request)
+        raise FactPulseValidationError.new("Chorus Pro error: #{response.code}") unless response.is_a?(Net::HTTPSuccess)
+        JSON.parse(response.body) rescue {}
+      end
+
+      # Recherche des structures sur Chorus Pro.
+      def rechercher_structure_chorus(identifiant_structure: nil, raison_sociale: nil, type_identifiant: 'SIRET', restreindre_privees: true)
+        body = { 'restreindre_structures_privees' => restreindre_privees }
+        body['identifiant_structure'] = identifiant_structure if identifiant_structure
+        body['raison_sociale_structure'] = raison_sociale if raison_sociale
+        body['type_identifiant_structure'] = type_identifiant if type_identifiant
+
+        make_chorus_request('POST', '/structures/rechercher', body)
+      end
+
+      # Consulte les détails d'une structure Chorus Pro.
+      def consulter_structure_chorus(id_structure_cpp)
+        make_chorus_request('POST', '/structures/consulter', { 'id_structure_cpp' => id_structure_cpp })
+      end
+
+      # Obtient l'ID Chorus Pro d'une structure depuis son SIRET.
+      def obtenir_id_chorus_depuis_siret(siret, type_identifiant: 'SIRET')
+        make_chorus_request('POST', '/structures/obtenir-id-depuis-siret', { 'siret' => siret, 'type_identifiant' => type_identifiant })
+      end
+
+      # Liste les services d'une structure Chorus Pro.
+      def lister_services_structure_chorus(id_structure_cpp)
+        make_chorus_request('GET', "/structures/#{id_structure_cpp}/services")
+      end
+
+      # Soumet une facture à Chorus Pro.
+      def soumettre_facture_chorus(facture_data)
+        make_chorus_request('POST', '/factures/soumettre', facture_data)
+      end
+
+      # Consulte le statut d'une facture Chorus Pro.
+      def consulter_facture_chorus(identifiant_facture_cpp)
+        make_chorus_request('POST', '/factures/consulter', { 'identifiant_facture_cpp' => identifiant_facture_cpp })
+      end
+
+      # =========================================================================
+      # Validation
+      # =========================================================================
+
+      # Valide un PDF Factur-X.
+      def valider_pdf_facturx(pdf_path, profil: 'EN16931')
+        ensure_authenticated
+        uri = URI("#{@api_url}/api/v1/traitement/valider-pdf-facturx")
+        pdf_content = File.binread(pdf_path)
+
+        boundary = "----RubyFormBoundary#{SecureRandom.hex(16)}"
+        body = build_multipart_body(boundary, [
+          { name: 'fichier_pdf', content: pdf_content, filename: File.basename(pdf_path), content_type: 'application/pdf' },
+          { name: 'profil', content: profil }
+        ])
+
+        response = http_multipart_post(uri, body, boundary)
+        raise FactPulseValidationError.new("Validation error: #{response.code}") unless response.is_a?(Net::HTTPSuccess)
+        JSON.parse(response.body) rescue {}
+      end
+
+      # Valide un XML Factur-X.
+      def valider_xml_facturx(xml_content, profil: 'EN16931')
+        ensure_authenticated
+        uri = URI("#{@api_url}/api/v1/traitement/valider-xml")
+
+        boundary = "----RubyFormBoundary#{SecureRandom.hex(16)}"
+        body = build_multipart_body(boundary, [
+          { name: 'fichier_xml', content: xml_content, filename: 'facture.xml', content_type: 'application/xml' },
+          { name: 'profil', content: profil }
+        ])
+
+        response = http_multipart_post(uri, body, boundary)
+        raise FactPulseValidationError.new("Validation error: #{response.code}") unless response.is_a?(Net::HTTPSuccess)
+        JSON.parse(response.body) rescue {}
+      end
+
+      # Valide la signature d'un PDF signé.
+      def valider_signature_pdf(pdf_path)
+        ensure_authenticated
+        uri = URI("#{@api_url}/api/v1/traitement/valider-signature-pdf")
+        pdf_content = File.binread(pdf_path)
+
+        boundary = "----RubyFormBoundary#{SecureRandom.hex(16)}"
+        body = build_multipart_body(boundary, [
+          { name: 'fichier_pdf', content: pdf_content, filename: File.basename(pdf_path), content_type: 'application/pdf' }
+        ])
+
+        response = http_multipart_post(uri, body, boundary)
+        raise FactPulseValidationError.new("Validation error: #{response.code}") unless response.is_a?(Net::HTTPSuccess)
+        JSON.parse(response.body) rescue {}
+      end
+
+      # =========================================================================
+      # Signature
+      # =========================================================================
+
+      # Signe un PDF avec le certificat configuré côté serveur.
+      def signer_pdf(pdf_path, **options)
+        ensure_authenticated
+        uri = URI("#{@api_url}/api/v1/traitement/signer-pdf")
+        pdf_content = File.binread(pdf_path)
+
+        parts = [
+          { name: 'fichier_pdf', content: pdf_content, filename: File.basename(pdf_path), content_type: 'application/pdf' },
+          { name: 'use_pades_lt', content: (options[:use_pades_lt] ? 'true' : 'false') },
+          { name: 'use_timestamp', content: (options.key?(:use_timestamp) ? (options[:use_timestamp] ? 'true' : 'false') : 'true') }
+        ]
+        parts << { name: 'raison', content: options[:raison] } if options[:raison]
+        parts << { name: 'localisation', content: options[:localisation] } if options[:localisation]
+        parts << { name: 'contact', content: options[:contact] } if options[:contact]
+
+        boundary = "----RubyFormBoundary#{SecureRandom.hex(16)}"
+        body = build_multipart_body(boundary, parts)
+
+        response = http_multipart_post(uri, body, boundary)
+        raise FactPulseValidationError.new("Signature error: #{response.code}") unless response.is_a?(Net::HTTPSuccess)
+
+        result = JSON.parse(response.body) rescue {}
+        raise FactPulseValidationError.new("Invalid signature response") unless result['pdf_signe_base64']
+        Base64.decode64(result['pdf_signe_base64'])
+      end
+
+      # Génère un certificat de test (NON PRODUCTION).
+      def generer_certificat_test(**options)
+        ensure_authenticated
+        uri = URI("#{@api_url}/api/v1/traitement/generer-certificat-test")
+        body = {
+          'cn' => options[:cn] || 'Test Organisation',
+          'organisation' => options[:organisation] || 'Test Organisation',
+          'email' => options[:email] || 'test@example.com',
+          'duree_jours' => options[:duree_jours] || 365,
+          'taille_cle' => options[:taille_cle] || 2048
+        }
+
+        response = http_post_json(uri, body)
+        raise FactPulseValidationError.new("Error: #{response.code}") unless response.is_a?(Net::HTTPSuccess)
+        JSON.parse(response.body) rescue {}
+      end
+
+      # =========================================================================
+      # Workflow complet
+      # =========================================================================
+
+      # Génère un PDF Factur-X complet avec validation, signature et soumission optionnelles.
+      def generer_facturx_complet(facture, pdf_source_path, **options)
+        profil = options[:profil] || 'EN16931'
+        valider = options.fetch(:valider, true)
+        signer = options.fetch(:signer, false)
+        soumettre_afnor = options.fetch(:soumettre_afnor, false)
+        timeout = options[:timeout] || 120000
+
+        result = {}
+
+        # 1. Génération
+        pdf_bytes = generer_facturx(facture, pdf_source_path, profil: profil, format_sortie: 'pdf', sync: true, timeout: timeout)
+        result[:pdf_bytes] = pdf_bytes
+
+        # Créer un fichier temporaire pour les opérations suivantes
+        temp_file = Tempfile.new(['facturx_', '.pdf'])
+        begin
+          temp_file.binmode
+          temp_file.write(pdf_bytes)
+          temp_file.flush
+
+          # 2. Validation
+          if valider
+            validation = valider_pdf_facturx(temp_file.path, profil: profil)
+            result[:validation] = validation
+            unless validation['est_conforme']
+              if options[:output_path]
+                File.binwrite(options[:output_path], pdf_bytes)
+                result[:pdf_path] = options[:output_path]
+              end
+              return result
+            end
+          end
+
+          # 3. Signature
+          if signer
+            pdf_bytes = signer_pdf(temp_file.path, **options)
+            result[:pdf_bytes] = pdf_bytes
+            result[:signature] = { 'signe' => true }
+            temp_file.rewind
+            temp_file.write(pdf_bytes)
+            temp_file.flush
+          end
+
+          # 4. Soumission AFNOR
+          if soumettre_afnor
+            numero_facture = facture['numeroFacture'] || facture['numero_facture'] || 'FACTURE'
+            flow_name = options[:afnor_flow_name] || "Facture #{numero_facture}"
+            tracking_id = options[:afnor_tracking_id] || numero_facture
+            afnor_result = soumettre_facture_afnor(temp_file.path, flow_name, tracking_id: tracking_id)
+            result[:afnor] = afnor_result
+          end
+
+          # Sauvegarde finale
+          if options[:output_path]
+            File.binwrite(options[:output_path], pdf_bytes)
+            result[:pdf_path] = options[:output_path]
+          end
+        ensure
+          temp_file.close
+          temp_file.unlink
+        end
+
+        result
+      end
+
       private
+
       def http_post(uri, payload)
         Net::HTTP.new(uri.host, uri.port).tap { |h| h.use_ssl = uri.scheme == 'https'; h.read_timeout = 30 }
           .request(Net::HTTP::Post.new(uri).tap { |r| r['Content-Type'] = 'application/json'; r.body = JSON.generate(payload) })
       end
+
+      def http_post_json(uri, payload)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.read_timeout = 30
+        request = Net::HTTP::Post.new(uri)
+        request['Authorization'] = "Bearer #{@access_token}"
+        request['Content-Type'] = 'application/json'
+        request.body = JSON.generate(payload)
+        http.request(request)
+      end
+
       def http_get(uri)
         Net::HTTP.new(uri.host, uri.port).tap { |h| h.use_ssl = uri.scheme == 'https'; h.read_timeout = 30 }
           .request(Net::HTTP::Get.new(uri).tap { |r| r['Authorization'] = "Bearer #{@access_token}" })
       end
+
+      def http_multipart_post(uri, body, boundary)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http.read_timeout = 120
+
+        request = Net::HTTP::Post.new(uri)
+        request['Authorization'] = "Bearer #{@access_token}"
+        request['Content-Type'] = "multipart/form-data; boundary=#{boundary}"
+        request.body = body
+        http.request(request)
+      end
+
+      def build_multipart_body(boundary, parts)
+        body_parts = []
+        parts.each do |part|
+          body_parts << "--#{boundary}\r\n"
+          if part[:filename]
+            body_parts << "Content-Disposition: form-data; name=\"#{part[:name]}\"; filename=\"#{part[:filename]}\"\r\n"
+            body_parts << "Content-Type: #{part[:content_type] || 'application/octet-stream'}\r\n\r\n"
+          else
+            body_parts << "Content-Disposition: form-data; name=\"#{part[:name]}\"\r\n"
+            body_parts << "Content-Type: #{part[:content_type]}\r\n" if part[:content_type]
+            body_parts << "\r\n"
+          end
+          body_parts << part[:content]
+          body_parts << "\r\n"
+        end
+        body_parts << "--#{boundary}--\r\n"
+        body_parts.join
+      end
     end
   end
 end

data/lib/factpulse/version.rb

@@ -11,5 +11,5 @@ Generator version: 7.18.0-SNAPSHOT
 =end
 
 module FactPulse
-  VERSION = '2.0.28'
+  VERSION = '2.0.30'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: factpulse
 version: !ruby/object:Gem::Version
-  version: 2.0.28
+  version: 2.0.30
 platform: ruby
 authors:
 - OpenAPI-Generator
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-27 00:00:00.000000000 Z
+date: 2025-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: typhoeus
@@ -229,9 +229,9 @@ files:
 - lib/factpulse/api_error.rb
 - lib/factpulse/api_model_base.rb
 - lib/factpulse/configuration.rb
-- lib/factpulse/helpers.rb
 - lib/factpulse/helpers/client.rb
 - lib/factpulse/helpers/exceptions.rb
+- lib/factpulse/helpers/helpers.rb
 - lib/factpulse/models/adresse_electronique.rb
 - lib/factpulse/models/adresse_postale.rb
 - lib/factpulse/models/api_error.rb