factpulse 1.0.0 → 1.0.8

data/lib/factpulse/helpers/client.rb

@@ -1,300 +0,0 @@
-# frozen_string_literal: true
-require 'net/http'; require 'json'; require 'base64'; require 'uri'; require 'securerandom'
-
-module FactPulse
-  module Helpers
-    # Credentials Chorus Pro pour le mode Zero-Trust.
-    # Ces credentials sont passés dans chaque requête et ne sont jamais stockés côté serveur.
-    class ChorusProCredentials
-      attr_reader :piste_client_id, :piste_client_secret, :chorus_pro_login, :chorus_pro_password, :sandbox
-      def initialize(piste_client_id:, piste_client_secret:, chorus_pro_login:, chorus_pro_password:, sandbox: true)
-        @piste_client_id, @piste_client_secret = piste_client_id, piste_client_secret
-        @chorus_pro_login, @chorus_pro_password, @sandbox = chorus_pro_login, chorus_pro_password, sandbox
-      end
-      def to_h
-        { 'piste_client_id' => @piste_client_id, 'piste_client_secret' => @piste_client_secret,
-          'chorus_pro_login' => @chorus_pro_login, 'chorus_pro_password' => @chorus_pro_password, 'sandbox' => @sandbox }
-      end
-    end
-
-    # Credentials AFNOR PDP pour le mode Zero-Trust.
-    # L'API FactPulse utilise ces credentials pour s'authentifier auprès de la PDP AFNOR.
-    class AFNORCredentials
-      attr_reader :flow_service_url, :token_url, :client_id, :client_secret, :directory_service_url
-      def initialize(flow_service_url:, token_url:, client_id:, client_secret:, directory_service_url: nil)
-        @flow_service_url, @token_url = flow_service_url, token_url
-        @client_id, @client_secret, @directory_service_url = client_id, client_secret, directory_service_url
-      end
-      def to_h
-        result = { 'flow_service_url' => @flow_service_url, 'token_url' => @token_url,
-                   'client_id' => @client_id, 'client_secret' => @client_secret }
-        result['directory_service_url'] = @directory_service_url if @directory_service_url
-        result
-      end
-    end
-
-    # Helpers pour créer des montants totaux simplifiés.
-    module MontantHelpers
-      def self.montant(value)
-        return '0.00' if value.nil?
-        return format('%.2f', value) if value.is_a?(Numeric)
-        value.is_a?(String) ? value : '0.00'
-      end
-
-      def self.montant_total(ht, tva, ttc, a_payer, remise_ttc: nil, motif_remise: nil, acompte: nil)
-        result = {
-          'montantHtTotal' => montant(ht), 'montantTva' => montant(tva),
-          'montantTtcTotal' => montant(ttc), 'montantAPayer' => montant(a_payer)
-        }
-        result['montantRemiseGlobaleTtc'] = montant(remise_ttc) if remise_ttc
-        result['motifRemiseGlobaleTtc'] = motif_remise if motif_remise
-        result['acompte'] = montant(acompte) if acompte
-        result
-      end
-
-      # Crée une ligne de poste (aligné sur LigneDePoste de models.py).
-      def self.ligne_de_poste(numero, denomination, quantite, montant_unitaire_ht, montant_total_ligne_ht,
-                              taux_tva: '20.00', categorie_tva: 'S', unite: 'FORFAIT', **options)
-        result = {
-          'numero' => numero, 'denomination' => denomination,
-          'quantite' => montant(quantite), 'montantUnitaireHt' => montant(montant_unitaire_ht),
-          'montantTotalLigneHt' => montant(montant_total_ligne_ht), 'tauxTva' => montant(taux_tva),
-          'categorieTva' => categorie_tva, 'unite' => unite
-        }
-        result['reference'] = options[:reference] if options[:reference]
-        result['montantRemiseHt'] = montant(options[:montant_remise_ht]) if options[:montant_remise_ht]
-        result['codeRaisonReduction'] = options[:code_raison_reduction] if options[:code_raison_reduction]
-        result['raisonReduction'] = options[:raison_reduction] if options[:raison_reduction]
-        result['dateDebutPeriode'] = options[:date_debut_periode] if options[:date_debut_periode]
-        result['dateFinPeriode'] = options[:date_fin_periode] if options[:date_fin_periode]
-        result
-      end
-
-      # Crée une ligne de TVA (aligné sur LigneDeTVA de models.py).
-      def self.ligne_de_tva(taux_manuel, montant_base_ht, montant_tva, categorie: 'S')
-        {
-          'tauxManuel' => montant(taux_manuel), 'montantBaseHt' => montant(montant_base_ht),
-          'montantTva' => montant(montant_tva), 'categorie' => categorie
-        }
-      end
-
-      # Crée une adresse postale pour l'API FactPulse.
-      def self.adresse_postale(ligne1, code_postal, ville, pays: 'FR', ligne2: nil, ligne3: nil)
-        result = { 'ligneUn' => ligne1, 'codePostal' => code_postal, 'nomVille' => ville, 'paysCodeIso' => pays }
-        result['ligneDeux'] = ligne2 if ligne2
-        result['ligneTrois'] = ligne3 if ligne3
-        result
-      end
-
-      # Crée une adresse électronique. scheme_id: "0009"=SIREN, "0225"=SIRET
-      def self.adresse_electronique(identifiant, scheme_id: '0009')
-        { 'identifiant' => identifiant, 'schemeId' => scheme_id }
-      end
-
-      # Calcule le numéro TVA intracommunautaire français depuis un SIREN.
-      def self.calculer_tva_intra(siren)
-        return nil if siren.nil? || siren.length != 9 || !siren.match?(/^\d+$/)
-        cle = (12 + 3 * (siren.to_i % 97)) % 97
-        format('FR%02d%s', cle, siren)
-      end
-
-      # Crée un fournisseur (émetteur) avec auto-calcul SIREN, TVA intracommunautaire et adresses.
-      def self.fournisseur(nom, siret, adresse_ligne1, code_postal, ville, **options)
-        siren = options[:siren] || (siret.length == 14 ? siret[0, 9] : nil)
-        numero_tva_intra = options[:numero_tva_intra] || (siren ? calculer_tva_intra(siren) : nil)
-        result = {
-          'nom' => nom, 'idFournisseur' => options[:id_fournisseur] || 0, 'siret' => siret,
-          'adresseElectronique' => adresse_electronique(siret, scheme_id: '0225'),
-          'adressePostale' => adresse_postale(adresse_ligne1, code_postal, ville, pays: options[:pays] || 'FR', ligne2: options[:adresse_ligne2])
-        }
-        result['siren'] = siren if siren
-        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
-      end
-
-      # Crée un destinataire (client) avec auto-calcul SIREN et adresses.
-      def self.destinataire(nom, siret, adresse_ligne1, code_postal, ville, **options)
-        siren = options[:siren] || (siret.length == 14 ? siret[0, 9] : nil)
-        result = {
-          'nom' => nom, 'siret' => siret,
-          'adresseElectronique' => adresse_electronique(siret, scheme_id: '0225'),
-          'adressePostale' => adresse_postale(adresse_ligne1, code_postal, ville, pays: options[:pays] || 'FR', ligne2: options[:adresse_ligne2])
-        }
-        result['siren'] = siren if siren
-        result['codeServiceExecutant'] = options[:code_service_executant] if options[:code_service_executant]
-        result
-      end
-    end
-
-    class FactPulseClient
-      attr_reader :chorus_credentials, :afnor_credentials
-
-      def initialize(email:, password:, api_url: nil, client_uid: nil, chorus_credentials: nil, afnor_credentials: nil,
-                     polling_interval: nil, polling_timeout: nil, max_retries: nil)
-        @email, @password = email, password; @api_url = (api_url || 'https://factpulse.fr').chomp('/')
-        @client_uid, @polling_interval, @polling_timeout, @max_retries = client_uid, polling_interval || 2000, polling_timeout || 120000, max_retries || 1
-        @chorus_credentials, @afnor_credentials = chorus_credentials, afnor_credentials
-        @access_token = @refresh_token = @token_expires_at = nil
-      end
-
-      def chorus_credentials_for_api; @chorus_credentials&.to_h; end
-      def afnor_credentials_for_api; @afnor_credentials&.to_h; end
-      # Alias plus courts
-      def get_chorus_pro_credentials; chorus_credentials_for_api; end
-      def get_afnor_credentials; afnor_credentials_for_api; end
-
-      def ensure_authenticated(force_refresh: false)
-        now = (Time.now.to_f * 1000).to_i
-        if force_refresh || @access_token.nil? || (@token_expires_at && now >= @token_expires_at)
-          payload = { 'username' => @email, 'password' => @password }; payload['client_uid'] = @client_uid if @client_uid
-          response = http_post(URI("#{@api_url}/api/token/"), payload)
-          raise FactPulseAuthError, "Auth failed" unless response.is_a?(Net::HTTPSuccess)
-          tokens = JSON.parse(response.body); @access_token, @refresh_token = tokens['access'], tokens['refresh']
-          @token_expires_at = now + (28 * 60 * 1000)
-        end
-      end
-
-      def reset_auth; @access_token = @refresh_token = @token_expires_at = nil; end
-
-      def poll_task(task_id, timeout: nil, interval: nil)
-        timeout_ms, interval_ms = timeout || @polling_timeout, interval || @polling_interval
-        start_time, current_interval = (Time.now.to_f * 1000).to_i, interval_ms.to_f
-        loop do
-          raise FactPulsePollingTimeout.new(task_id, timeout_ms) if (Time.now.to_f * 1000).to_i - start_time > timeout_ms
-          ensure_authenticated; response = http_get(URI("#{@api_url}/api/v1/traitement/taches/#{task_id}/statut"))
-          reset_auth and next if response.code == '401'
-          data = JSON.parse(response.body)
-          return data['resultat'] || {} if data['statut'] == 'SUCCESS'
-          if data['statut'] == 'FAILURE'
-            r = data['resultat'] || {}
-            raise FactPulseValidationError.new("Task #{task_id} failed: #{r['message_erreur'] || '?'}", (r['erreurs'] || []).map { |e| ValidationErrorDetail.from_hash(e) })
-          end
-          sleep(current_interval / 1000.0); current_interval = [current_interval * 1.5, 10000].min
-        end
-      end
-
-      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
-                    when String then facture_data
-                    when Hash then JSON.generate(facture_data)
-                    else
-                      if facture_data.respond_to?(:to_h)
-                        JSON.generate(facture_data.to_h)
-                      elsif facture_data.respond_to?(:to_hash)
-                        JSON.generate(facture_data.to_hash)
-                      else
-                        raise FactPulseValidationError.new("Type de données non supporté: #{facture_data.class}")
-                      end
-                    end
-
-        # Lecture du PDF source
-        pdf_content = case pdf_source
-                      when String then File.binread(pdf_source)
-                      when File then pdf_source.read
-                      else
-                        if pdf_source.respond_to?(:read)
-                          pdf_source.read
-                        else
-                          raise FactPulseValidationError.new("Type de PDF non supporté: #{pdf_source.class}")
-                        end
-                      end
-        pdf_filename = pdf_source.is_a?(String) ? File.basename(pdf_source) : 'facture.pdf'
-
-        ensure_authenticated
-        uri = URI("#{@api_url}/api/v1/traitement/generer-facture")
-
-        # Construire la requête multipart
-        boundary = "----RubyFormBoundary#{SecureRandom.hex(16)}"
-        body = []
-
-        # 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)
-
-        if response.code == '401'
-          reset_auth
-          ensure_authenticated
-          request['Authorization'] = "Bearer #{@access_token}"
-          response = http.request(request)
-        end
-
-        unless response.is_a?(Net::HTTPSuccess)
-          error_data = JSON.parse(response.body) rescue { 'detail' => response.body }
-          raise FactPulseValidationError.new("Erreur API: #{error_data['detail'] || response.body}")
-        end
-
-        data = JSON.parse(response.body)
-
-        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']
-          end
-          raise FactPulseValidationError.new("Résultat inattendu: #{result.keys.join(', ')}")
-        end
-
-        data
-      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_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
-    end
-  end
-end

data/lib/factpulse/helpers/exceptions.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-module FactPulse
-  module Helpers
-    class FactPulseError < StandardError; end
-    class FactPulseAuthError < FactPulseError; end
-    class FactPulsePollingTimeout < FactPulseError
-      attr_reader :task_id, :timeout
-      def initialize(task_id, timeout); @task_id, @timeout = task_id, timeout; super("Timeout (#{timeout}ms) pour #{task_id}"); end
-    end
-    class ValidationErrorDetail
-      attr_accessor :level, :item, :reason, :source, :code
-      def initialize(level: '', item: '', reason: '', source: nil, code: nil); @level, @item, @reason, @source, @code = level, item, reason, source, code; end
-      def to_s; "[#{@item.to_s.empty? ? 'unknown' : @item}] #{@reason.to_s.empty? ? 'Unknown error' : @reason}"; end
-      def self.from_hash(h); new(level: h['level']||'', item: h['item']||'', reason: h['reason']||'', source: h['source'], code: h['code']); end
-    end
-    class FactPulseValidationError < FactPulseError
-      attr_reader :errors
-      def initialize(msg, errors = []); @errors = errors; super(errors.empty? ? msg : "#{msg}\n\nDétails:\n#{errors.map{|e| "  - #{e}"}.join("\n")}"); end
-    end
-  end
-end

data/lib/factpulse/helpers.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-require_relative 'helpers/exceptions'
-require_relative 'helpers/client'
-module FactPulse
-  module Helpers
-    def self.create_client(**opts); FactPulseClient.new(**opts); end
-    def self.format_montant(m); MontantHelpers.montant(m); end
-    def self.montant(m); MontantHelpers.montant(m); end
-    def self.montant_total(*args, **kwargs); MontantHelpers.montant_total(*args, **kwargs); end
-    def self.ligne_de_poste(*args, **kwargs); MontantHelpers.ligne_de_poste(*args, **kwargs); end
-    def self.ligne_de_tva(*args, **kwargs); MontantHelpers.ligne_de_tva(*args, **kwargs); end
-  end
-end

data/lib/factpulse/models/montant_base_ht.rb

@@ -1,104 +0,0 @@
-=begin
-#API REST FactPulse
-
-# API REST pour la facturation électronique en France : Factur-X, AFNOR PDP/PA, signatures électroniques.  ## 🎯 Fonctionnalités principales  ### 📄 Génération de factures Factur-X - **Formats** : XML seul ou PDF/A-3 avec XML embarqué - **Profils** : MINIMUM, BASIC, EN16931, EXTENDED - **Normes** : EN 16931 (directive UE 2014/55), ISO 19005-3 (PDF/A-3), CII (UN/CEFACT) - **🆕 Format simplifié** : Génération à partir de SIRET + auto-enrichissement (API Chorus Pro + Recherche Entreprises)  ### ✅ Validation et conformité - **Validation XML** : Schematron (45 à 210+ règles selon profil) - **Validation PDF** : PDF/A-3, métadonnées XMP Factur-X, signatures électroniques - **VeraPDF** : Validation stricte PDF/A (146+ règles ISO 19005-3) - **Traitement asynchrone** : Support Celery pour validations lourdes (VeraPDF)  ### 📡 Intégration AFNOR PDP/PA (XP Z12-013) - **Soumission de flux** : Envoi de factures vers Plateformes de Dématérialisation Partenaires - **Recherche de flux** : Consultation des factures soumises - **Téléchargement** : Récupération des PDF/A-3 avec XML - **Directory Service** : Recherche d'entreprises (SIREN/SIRET) - **Multi-client** : Support de plusieurs configs PDP par utilisateur (stored credentials ou zero-storage)  ### ✍️ Signature électronique PDF - **Standards** : PAdES-B-B, PAdES-B-T (horodatage RFC 3161), PAdES-B-LT (archivage long terme) - **Niveaux eIDAS** : SES (auto-signé), AdES (CA commerciale), QES (PSCO) - **Validation** : Vérification intégrité cryptographique et certificats - **Génération de certificats** : Certificats X.509 auto-signés pour tests  ### 🔄 Traitement asynchrone - **Celery** : Génération, validation et signature asynchrones - **Polling** : Suivi d'état via `/taches/{id_tache}/statut` - **Pas de timeout** : Idéal pour gros fichiers ou validations lourdes  ## 🔒 Authentification  Toutes les requêtes nécessitent un **token JWT** dans le header Authorization : ``` Authorization: Bearer YOUR_JWT_TOKEN ```  ### Comment obtenir un token JWT ?  #### 🔑 Méthode 1 : API `/api/token/` (Recommandée)  **URL :** `https://www.factpulse.fr/api/token/`  Cette méthode est **recommandée** pour l'intégration dans vos applications et workflows CI/CD.  **Prérequis :** Avoir défini un mot de passe sur votre compte  **Pour les utilisateurs inscrits via email/password :** - Vous avez déjà un mot de passe, utilisez-le directement  **Pour les utilisateurs inscrits via OAuth (Google/GitHub) :** - Vous devez d'abord définir un mot de passe sur : https://www.factpulse.fr/accounts/password/set/ - Une fois le mot de passe créé, vous pourrez utiliser l'API  **Exemple de requête :** ```bash curl -X POST https://www.factpulse.fr/api/token/ \\   -H \"Content-Type: application/json\" \\   -d '{     \"username\": \"votre_email@example.com\",     \"password\": \"votre_mot_de_passe\"   }' ```  **Paramètre optionnel `client_uid` :**  Pour sélectionner les credentials d'un client spécifique (PA/PDP, Chorus Pro, certificats de signature), ajoutez `client_uid` :  ```bash curl -X POST https://www.factpulse.fr/api/token/ \\   -H \"Content-Type: application/json\" \\   -d '{     \"username\": \"votre_email@example.com\",     \"password\": \"votre_mot_de_passe\",     \"client_uid\": \"550e8400-e29b-41d4-a716-446655440000\"   }' ```  Le `client_uid` sera inclus dans le JWT et permettra à l'API d'utiliser automatiquement : - Les credentials AFNOR/PDP configurés pour ce client - Les credentials Chorus Pro configurés pour ce client - Les certificats de signature électronique configurés pour ce client  **Réponse :** ```json {   \"access\": \"eyJ0eXAiOiJKV1QiLCJhbGc...\",  // Token d'accès (validité: 30 min)   \"refresh\": \"eyJ0eXAiOiJKV1QiLCJhbGc...\"  // Token de rafraîchissement (validité: 7 jours) } ```  **Avantages :** - ✅ Automatisation complète (CI/CD, scripts) - ✅ Gestion programmatique des tokens - ✅ Support du refresh token pour renouveler automatiquement l'accès - ✅ Intégration facile dans n'importe quel langage/outil  #### 🖥️ Méthode 2 : Génération via Dashboard (Alternative)  **URL :** https://www.factpulse.fr/dashboard/  Cette méthode convient pour des tests rapides ou une utilisation occasionnelle via l'interface graphique.  **Fonctionnement :** - Connectez-vous au dashboard - Utilisez les boutons \"Generate Test Token\" ou \"Generate Production Token\" - Fonctionne pour **tous** les utilisateurs (OAuth et email/password), sans nécessiter de mot de passe  **Types de tokens :** - **Token Test** : Validité 24h, quota 1000 appels/jour (gratuit) - **Token Production** : Validité 7 jours, quota selon votre forfait  **Avantages :** - ✅ Rapide pour tester l'API - ✅ Aucun mot de passe requis - ✅ Interface visuelle simple  **Inconvénients :** - ❌ Nécessite une action manuelle - ❌ Pas de refresh token - ❌ Moins adapté pour l'automatisation  ### 📚 Documentation complète  Pour plus d'informations sur l'authentification et l'utilisation de l'API : https://www.factpulse.fr/documentation-api/     
-
-The version of the OpenAPI document: 1.0.0
-
-Generated by: https://openapi-generator.tech
-Generator version: 7.18.0-SNAPSHOT
-
-=end
-
-require 'date'
-require 'time'
-
-module FactPulse
-  # Montant de la base HT pour cette ligne de TVA. (Accepte number, string ou integer)
-  module MontantBaseHt
-    class << self
-      # List of class defined in anyOf (OpenAPI v3)
-      def openapi_any_of
-        [
-          :'Float',
-          :'String'
-        ]
-      end
-
-      # Builds the object
-      # @param [Mixed] Data to be matched against the list of anyOf items
-      # @return [Object] Returns the model or the data itself
-      def build(data)
-        # Go through the list of anyOf items and attempt to identify the appropriate one.
-        # Note:
-        # - No advanced validation of types in some cases (e.g. "x: { type: string }" will happily match { x: 123 })
-        #   due to the way the deserialization is made in the base_object template (it just casts without verifying).
-        # - TODO: scalar values are de facto behaving as if they were nullable.
-        # - TODO: logging when debugging is set.
-        openapi_any_of.each do |klass|
-          begin
-            next if klass == :AnyType # "nullable: true"
-            return find_and_cast_into_type(klass, data)
-          rescue # rescue all errors so we keep iterating even if the current item lookup raises
-          end
-        end
-
-        openapi_any_of.include?(:AnyType) ? data : nil
-      end
-
-      private
-
-      SchemaMismatchError = Class.new(StandardError)
-
-      # Note: 'File' is missing here because in the regular case we get the data _after_ a call to JSON.parse.
-      def find_and_cast_into_type(klass, data)
-        return if data.nil?
-
-        case klass.to_s
-        when 'Boolean'
-          return data if data.instance_of?(TrueClass) || data.instance_of?(FalseClass)
-        when 'Float'
-          return data if data.instance_of?(Float)
-        when 'Integer'
-          return data if data.instance_of?(Integer)
-        when 'Time'
-          return Time.parse(data)
-        when 'Date'
-          return Date.iso8601(data)
-        when 'String'
-          return data if data.instance_of?(String)
-        when 'Object' # "type: object"
-          return data if data.instance_of?(Hash)
-        when /\AArray<(?<sub_type>.+)>\z/ # "type: array"
-          if data.instance_of?(Array)
-            sub_type = Regexp.last_match[:sub_type]
-            return data.map { |item| find_and_cast_into_type(sub_type, item) }
-          end
-        when /\AHash<String, (?<sub_type>.+)>\z/ # "type: object" with "additionalProperties: { ... }"
-          if data.instance_of?(Hash) && data.keys.all? { |k| k.instance_of?(Symbol) || k.instance_of?(String) }
-            sub_type = Regexp.last_match[:sub_type]
-            return data.each_with_object({}) { |(k, v), hsh| hsh[k] = find_and_cast_into_type(sub_type, v) }
-          end
-        else # model
-          const = FactPulse.const_get(klass)
-          if const
-            if const.respond_to?(:openapi_any_of) # nested anyOf model
-              model = const.build(data)
-              return model if model
-            else
-              # raise if data contains keys that are not known to the model
-              raise if const.respond_to?(:acceptable_attributes) && !(data.keys - const.acceptable_attributes).empty?
-              model = const.build_from_hash(data)
-              return model if model
-            end
-          end
-        end
-
-        raise # if no match by now, raise
-      rescue
-        raise SchemaMismatchError, "#{data} doesn't match the #{klass} type"
-      end
-    end
-  end
-
-end

data/lib/factpulse/models/montant_remise_globale_ttc.rb

@@ -1,104 +0,0 @@
-=begin
-#API REST FactPulse
-
-# API REST pour la facturation électronique en France : Factur-X, AFNOR PDP/PA, signatures électroniques.  ## 🎯 Fonctionnalités principales  ### 📄 Génération de factures Factur-X - **Formats** : XML seul ou PDF/A-3 avec XML embarqué - **Profils** : MINIMUM, BASIC, EN16931, EXTENDED - **Normes** : EN 16931 (directive UE 2014/55), ISO 19005-3 (PDF/A-3), CII (UN/CEFACT) - **🆕 Format simplifié** : Génération à partir de SIRET + auto-enrichissement (API Chorus Pro + Recherche Entreprises)  ### ✅ Validation et conformité - **Validation XML** : Schematron (45 à 210+ règles selon profil) - **Validation PDF** : PDF/A-3, métadonnées XMP Factur-X, signatures électroniques - **VeraPDF** : Validation stricte PDF/A (146+ règles ISO 19005-3) - **Traitement asynchrone** : Support Celery pour validations lourdes (VeraPDF)  ### 📡 Intégration AFNOR PDP/PA (XP Z12-013) - **Soumission de flux** : Envoi de factures vers Plateformes de Dématérialisation Partenaires - **Recherche de flux** : Consultation des factures soumises - **Téléchargement** : Récupération des PDF/A-3 avec XML - **Directory Service** : Recherche d'entreprises (SIREN/SIRET) - **Multi-client** : Support de plusieurs configs PDP par utilisateur (stored credentials ou zero-storage)  ### ✍️ Signature électronique PDF - **Standards** : PAdES-B-B, PAdES-B-T (horodatage RFC 3161), PAdES-B-LT (archivage long terme) - **Niveaux eIDAS** : SES (auto-signé), AdES (CA commerciale), QES (PSCO) - **Validation** : Vérification intégrité cryptographique et certificats - **Génération de certificats** : Certificats X.509 auto-signés pour tests  ### 🔄 Traitement asynchrone - **Celery** : Génération, validation et signature asynchrones - **Polling** : Suivi d'état via `/taches/{id_tache}/statut` - **Pas de timeout** : Idéal pour gros fichiers ou validations lourdes  ## 🔒 Authentification  Toutes les requêtes nécessitent un **token JWT** dans le header Authorization : ``` Authorization: Bearer YOUR_JWT_TOKEN ```  ### Comment obtenir un token JWT ?  #### 🔑 Méthode 1 : API `/api/token/` (Recommandée)  **URL :** `https://www.factpulse.fr/api/token/`  Cette méthode est **recommandée** pour l'intégration dans vos applications et workflows CI/CD.  **Prérequis :** Avoir défini un mot de passe sur votre compte  **Pour les utilisateurs inscrits via email/password :** - Vous avez déjà un mot de passe, utilisez-le directement  **Pour les utilisateurs inscrits via OAuth (Google/GitHub) :** - Vous devez d'abord définir un mot de passe sur : https://www.factpulse.fr/accounts/password/set/ - Une fois le mot de passe créé, vous pourrez utiliser l'API  **Exemple de requête :** ```bash curl -X POST https://www.factpulse.fr/api/token/ \\   -H \"Content-Type: application/json\" \\   -d '{     \"username\": \"votre_email@example.com\",     \"password\": \"votre_mot_de_passe\"   }' ```  **Paramètre optionnel `client_uid` :**  Pour sélectionner les credentials d'un client spécifique (PA/PDP, Chorus Pro, certificats de signature), ajoutez `client_uid` :  ```bash curl -X POST https://www.factpulse.fr/api/token/ \\   -H \"Content-Type: application/json\" \\   -d '{     \"username\": \"votre_email@example.com\",     \"password\": \"votre_mot_de_passe\",     \"client_uid\": \"550e8400-e29b-41d4-a716-446655440000\"   }' ```  Le `client_uid` sera inclus dans le JWT et permettra à l'API d'utiliser automatiquement : - Les credentials AFNOR/PDP configurés pour ce client - Les credentials Chorus Pro configurés pour ce client - Les certificats de signature électronique configurés pour ce client  **Réponse :** ```json {   \"access\": \"eyJ0eXAiOiJKV1QiLCJhbGc...\",  // Token d'accès (validité: 30 min)   \"refresh\": \"eyJ0eXAiOiJKV1QiLCJhbGc...\"  // Token de rafraîchissement (validité: 7 jours) } ```  **Avantages :** - ✅ Automatisation complète (CI/CD, scripts) - ✅ Gestion programmatique des tokens - ✅ Support du refresh token pour renouveler automatiquement l'accès - ✅ Intégration facile dans n'importe quel langage/outil  #### 🖥️ Méthode 2 : Génération via Dashboard (Alternative)  **URL :** https://www.factpulse.fr/dashboard/  Cette méthode convient pour des tests rapides ou une utilisation occasionnelle via l'interface graphique.  **Fonctionnement :** - Connectez-vous au dashboard - Utilisez les boutons \"Generate Test Token\" ou \"Generate Production Token\" - Fonctionne pour **tous** les utilisateurs (OAuth et email/password), sans nécessiter de mot de passe  **Types de tokens :** - **Token Test** : Validité 24h, quota 1000 appels/jour (gratuit) - **Token Production** : Validité 7 jours, quota selon votre forfait  **Avantages :** - ✅ Rapide pour tester l'API - ✅ Aucun mot de passe requis - ✅ Interface visuelle simple  **Inconvénients :** - ❌ Nécessite une action manuelle - ❌ Pas de refresh token - ❌ Moins adapté pour l'automatisation  ### 📚 Documentation complète  Pour plus d'informations sur l'authentification et l'utilisation de l'API : https://www.factpulse.fr/documentation-api/     
-
-The version of the OpenAPI document: 1.0.0
-
-Generated by: https://openapi-generator.tech
-Generator version: 7.18.0-SNAPSHOT
-
-=end
-
-require 'date'
-require 'time'
-
-module FactPulse
-  # Montant de la remise globale TTC. (Accepte number, string ou integer)
-  module MontantRemiseGlobaleTtc
-    class << self
-      # List of class defined in anyOf (OpenAPI v3)
-      def openapi_any_of
-        [
-          :'Float',
-          :'String'
-        ]
-      end
-
-      # Builds the object
-      # @param [Mixed] Data to be matched against the list of anyOf items
-      # @return [Object] Returns the model or the data itself
-      def build(data)
-        # Go through the list of anyOf items and attempt to identify the appropriate one.
-        # Note:
-        # - No advanced validation of types in some cases (e.g. "x: { type: string }" will happily match { x: 123 })
-        #   due to the way the deserialization is made in the base_object template (it just casts without verifying).
-        # - TODO: scalar values are de facto behaving as if they were nullable.
-        # - TODO: logging when debugging is set.
-        openapi_any_of.each do |klass|
-          begin
-            next if klass == :AnyType # "nullable: true"
-            return find_and_cast_into_type(klass, data)
-          rescue # rescue all errors so we keep iterating even if the current item lookup raises
-          end
-        end
-
-        openapi_any_of.include?(:AnyType) ? data : nil
-      end
-
-      private
-
-      SchemaMismatchError = Class.new(StandardError)
-
-      # Note: 'File' is missing here because in the regular case we get the data _after_ a call to JSON.parse.
-      def find_and_cast_into_type(klass, data)
-        return if data.nil?
-
-        case klass.to_s
-        when 'Boolean'
-          return data if data.instance_of?(TrueClass) || data.instance_of?(FalseClass)
-        when 'Float'
-          return data if data.instance_of?(Float)
-        when 'Integer'
-          return data if data.instance_of?(Integer)
-        when 'Time'
-          return Time.parse(data)
-        when 'Date'
-          return Date.iso8601(data)
-        when 'String'
-          return data if data.instance_of?(String)
-        when 'Object' # "type: object"
-          return data if data.instance_of?(Hash)
-        when /\AArray<(?<sub_type>.+)>\z/ # "type: array"
-          if data.instance_of?(Array)
-            sub_type = Regexp.last_match[:sub_type]
-            return data.map { |item| find_and_cast_into_type(sub_type, item) }
-          end
-        when /\AHash<String, (?<sub_type>.+)>\z/ # "type: object" with "additionalProperties: { ... }"
-          if data.instance_of?(Hash) && data.keys.all? { |k| k.instance_of?(Symbol) || k.instance_of?(String) }
-            sub_type = Regexp.last_match[:sub_type]
-            return data.each_with_object({}) { |(k, v), hsh| hsh[k] = find_and_cast_into_type(sub_type, v) }
-          end
-        else # model
-          const = FactPulse.const_get(klass)
-          if const
-            if const.respond_to?(:openapi_any_of) # nested anyOf model
-              model = const.build(data)
-              return model if model
-            else
-              # raise if data contains keys that are not known to the model
-              raise if const.respond_to?(:acceptable_attributes) && !(data.keys - const.acceptable_attributes).empty?
-              model = const.build_from_hash(data)
-              return model if model
-            end
-          end
-        end
-
-        raise # if no match by now, raise
-      rescue
-        raise SchemaMismatchError, "#{data} doesn't match the #{klass} type"
-      end
-    end
-  end
-
-end