io-complyance-unify-sdk 3.0.0

data/lib/complyance_sdk/jobs/sidekiq_job.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module ComplyanceSDK
+  module Jobs
+    # Sidekiq-specific job implementation
+    class SidekiqJob
+      # Include Sidekiq::Job if available
+      if defined?(Sidekiq)
+        include Sidekiq::Job
+        
+        # Configure Sidekiq options
+        sidekiq_options queue: :complyance_sdk, 
+                       retry: 3,
+                       backtrace: true,
+                       dead: false
+
+        # Custom retry logic for Sidekiq
+        sidekiq_retry_in do |count, exception|
+          case exception
+          when ComplyanceSDK::Exceptions::NetworkError
+            # Exponential backoff for network errors
+            (count ** 2) + 15 + (rand(30) * (count + 1))
+          when ComplyanceSDK::Exceptions::APIError
+            # Only retry certain API errors
+            if exception.status_code && [429, 500, 502, 503, 504].include?(exception.status_code)
+              (count ** 2) + 10 + (rand(10) * (count + 1))
+            else
+              :kill # Don't retry other API errors
+            end
+          when ComplyanceSDK::Exceptions::ConfigurationError,
+               ComplyanceSDK::Exceptions::ValidationError
+            :kill # Don't retry configuration or validation errors
+          else
+            # Default exponential backoff
+            (count ** 2) + 15 + (rand(30) * (count + 1))
+          end
+        end
+      end
+
+      # Process a document using Sidekiq
+      #
+      # @param request_data [Hash] The UnifyRequest data
+      # @param callback_url [String, nil] Optional callback URL for results
+      # @param callback_headers [Hash] Optional headers for callback
+      def perform(request_data, callback_url = nil, callback_headers = {})
+        unless ComplyanceSDK.configured?
+          raise ComplyanceSDK::Exceptions::ConfigurationError.new(
+            "ComplyanceSDK is not configured for Sidekiq jobs"
+          )
+        end
+
+        client = ComplyanceSDK::HTTP::Client.new(ComplyanceSDK.configuration)
+        
+        log_info("Starting Sidekiq document processing", {
+          document_type: request_data["document_type"],
+          country: request_data["country"],
+          jid: jid
+        })
+
+        begin
+          response = client.post("/api/v1/unify", request_data)
+          
+          log_info("Sidekiq document processed successfully", {
+            response_status: response["status"],
+            submission_id: response.dig("data", "submission_id"),
+            jid: jid
+          })
+
+          # Send callback if provided
+          if callback_url
+            send_callback(callback_url, callback_headers, {
+              status: "success",
+              data: response,
+              request_id: request_data["metadata"]&.dig("request_id"),
+              job_id: jid
+            })
+          end
+
+          response
+        rescue => error
+          log_error("Sidekiq document processing failed", {
+            error_class: error.class.name,
+            error_message: error.message,
+            jid: jid
+          })
+
+          # Send error callback if provided
+          if callback_url
+            send_callback(callback_url, callback_headers, {
+              status: "error",
+              error: {
+                code: error.respond_to?(:code) ? error.code : "unknown_error",
+                message: error.message
+              },
+              request_id: request_data["metadata"]&.dig("request_id"),
+              job_id: jid
+            })
+          end
+
+          raise error
+        end
+      end
+
+      private
+
+      def jid
+        @jid ||= defined?(Sidekiq) ? (bid || "unknown") : "no-sidekiq"
+      end
+
+      def send_callback(url, headers, payload)
+        require "net/http"
+        require "uri"
+        require "json"
+
+        uri = URI(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+        headers.each { |key, value| request[key] = value }
+        request.body = payload.to_json
+
+        response = http.request(request)
+        
+        log_info("Sidekiq callback sent", {
+          callback_url: url,
+          callback_status: response.code,
+          payload_status: payload[:status],
+          jid: jid
+        })
+      rescue => error
+        log_warn("Sidekiq callback failed", {
+          callback_url: url,
+          error: error.message,
+          jid: jid
+        })
+      end
+
+      def log_info(message, context = {})
+        log_message("INFO", message, context)
+      end
+
+      def log_warn(message, context = {})
+        log_message("WARN", message, context)
+      end
+
+      def log_error(message, context = {})
+        log_message("ERROR", message, context)
+      end
+
+      def log_message(level, message, context = {})
+        if defined?(Sidekiq) && Sidekiq.logger
+          full_message = "ComplyanceSDK Sidekiq Job: #{message}"
+          full_message += " Context: #{context}" unless context.empty?
+          Sidekiq.logger.send(level.downcase.to_sym, full_message)
+        elsif defined?(Rails) && Rails.logger
+          full_message = "ComplyanceSDK Sidekiq Job: #{message}"
+          full_message += " Context: #{context}" unless context.empty?
+          Rails.logger.send(level.downcase.to_sym, full_message)
+        end
+      end
+    end
+  end
+end

data/lib/complyance_sdk/middleware/rack_middleware.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ComplyanceSDK
+  module Middleware
+    # Rack middleware for ComplyanceSDK integration
+    class RackMiddleware
+      def initialize(app, options = {})
+        @app = app
+        @options = options
+      end
+
+      def call(env)
+        # Add ComplyanceSDK context to the request
+        env["complyance_sdk.configured"] = ComplyanceSDK.configured?
+        env["complyance_sdk.environment"] = ComplyanceSDK.configuration&.environment
+        
+        # Add request ID for tracing
+        env["complyance_sdk.request_id"] = generate_request_id
+        
+        status, headers, response = @app.call(env)
+        
+        # Add ComplyanceSDK headers to response if configured
+        if ComplyanceSDK.configured? && @options[:add_headers]
+          headers["X-ComplyanceSDK-Version"] = ComplyanceSDK::VERSION
+          headers["X-ComplyanceSDK-Environment"] = ComplyanceSDK.configuration.environment.to_s
+        end
+        
+        [status, headers, response]
+      end
+
+      private
+
+      def generate_request_id
+        require "securerandom"
+        SecureRandom.uuid
+      end
+    end
+  end
+end

data/lib/complyance_sdk/models/country.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module ComplyanceSDK
+  module Models
+    # Country enumeration for supported countries
+    class Country
+      # Supported countries
+      SA = :sa # Saudi Arabia
+      MY = :my # Malaysia
+      AE = :ae # United Arab Emirates
+      SG = :sg # Singapore
+      EG = :eg # Egypt
+      IN = :in # India
+      PH = :ph # Philippines
+      TH = :th # Thailand
+      VN = :vn # Vietnam
+      ID = :id # Indonesia
+      BD = :bd # Bangladesh
+      LK = :lk # Sri Lanka
+      PK = :pk # Pakistan
+      NP = :np # Nepal
+      MM = :mm # Myanmar
+      KH = :kh # Cambodia
+      LA = :la # Laos
+      BN = :bn # Brunei
+      MV = :mv # Maldives
+      BT = :bt # Bhutan
+
+      # All supported countries
+      ALL_COUNTRIES = [
+        SA, MY, AE, SG, EG, IN, PH, TH, VN, ID,
+        BD, LK, PK, NP, MM, KH, LA, BN, MV, BT
+      ].freeze
+
+      class << self
+        # Check if a country is valid
+        #
+        # @param country [Symbol] The country code to validate
+        # @return [Boolean] True if valid, false otherwise
+        def valid?(country)
+          ALL_COUNTRIES.include?(country)
+        end
+
+        # Parse a string to a country symbol
+        #
+        # @param str [String] The string to parse
+        # @return [Symbol] The country symbol
+        # @raise [ArgumentError] If the string is invalid
+        def from_string(str)
+          return str if str.is_a?(Symbol)
+          
+          country = str.to_s.downcase.to_sym
+          
+          unless valid?(country)
+            raise ArgumentError, "Invalid country: #{str}. Valid countries: #{ALL_COUNTRIES.join(', ')}"
+          end
+          
+          country
+        end
+
+        # Convert a country to string format
+        #
+        # @param country [Symbol] The country
+        # @return [String] The string representation
+        def to_string(country)
+          country.to_s.upcase
+        end
+
+        # Get the default tax authority for a country
+        #
+        # @param country [Symbol] The country
+        # @return [String, nil] The tax authority name or nil if not mapped
+        def default_tax_authority(country)
+          case country
+          when SA
+            'ZATCA'
+          when MY
+            'LHDN'
+          when AE
+            'FTA'
+          when SG
+            'IRAS'
+          when EG
+            'ETA'
+          when IN
+            'GSTN'
+          when PH
+            'BIR'
+          when TH
+            'RD'
+          when VN
+            'GDT'
+          when ID
+            'DJP'
+          else
+            nil
+          end
+        end
+
+        # Get the full country name
+        #
+        # @param country [Symbol] The country code
+        # @return [String] The full country name
+        def full_name(country)
+          case country
+          when SA
+            'Saudi Arabia'
+          when MY
+            'Malaysia'
+          when AE
+            'United Arab Emirates'
+          when SG
+            'Singapore'
+          when EG
+            'Egypt'
+          when IN
+            'India'
+          when PH
+            'Philippines'
+          when TH
+            'Thailand'
+          when VN
+            'Vietnam'
+          when ID
+            'Indonesia'
+          when BD
+            'Bangladesh'
+          when LK
+            'Sri Lanka'
+          when PK
+            'Pakistan'
+          when NP
+            'Nepal'
+          when MM
+            'Myanmar'
+          when KH
+            'Cambodia'
+          when LA
+            'Laos'
+          when BN
+            'Brunei'
+          when MV
+            'Maldives'
+          when BT
+            'Bhutan'
+          else
+            country.to_s.upcase
+          end
+        end
+
+        # Check if country is allowed for production environments
+        # Based on the Java SDK's validation rules
+        #
+        # @param country [Symbol] The country
+        # @param environment [Symbol] The environment
+        # @return [Boolean] True if allowed
+        def allowed_for_environment?(country, environment)
+          case environment
+          when :dev, :test, :stage, :local
+            # Development environments allow all countries
+            true
+          when :sandbox, :simulation, :production
+            # Production environments have restrictions
+            case country
+            when SA
+              # SA is allowed in all production environments
+              true
+            when MY
+              # MY is allowed in SANDBOX and PRODUCTION only (not SIMULATION)
+              environment != :simulation
+            else
+              # Other countries are blocked in production environments
+              false
+            end
+          else
+            # Unknown environment, default to allowing
+            true
+          end
+        end
+
+        # Get validation error message for country/environment combination
+        #
+        # @param country [Symbol] The country
+        # @param environment [Symbol] The environment
+        # @return [String, nil] Error message or nil if allowed
+        def validation_error_message(country, environment)
+          return nil if allowed_for_environment?(country, environment)
+
+          case environment
+          when :simulation
+            if country == MY
+              "MY (Malaysia) is not allowed in SIMULATION environment. Use SANDBOX or PRODUCTION."
+            else
+              "Only SA and MY are allowed for #{environment.to_s.upcase}. Use DEV/TEST/STAGE for other countries."
+            end
+          when :sandbox, :production
+            "Only SA and MY are allowed for #{environment.to_s.upcase}. Use DEV/TEST/STAGE for other countries."
+          else
+            "Country #{country.to_s.upcase} is not allowed for environment #{environment.to_s.upcase}."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/complyance_sdk/models/country_policy_registry.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require_relative 'logical_doc_type'
+require_relative 'policy_result'
+require_relative 'document_type'
+require_relative 'country'
+
+module ComplyanceSDK
+  module Models
+    # Registry for country-specific document type policies
+    # Maps logical document types to base document types and meta configuration flags
+    class CountryPolicyRegistry
+      class << self
+        # Evaluate a logical document type for a specific country
+        #
+        # @param country [Symbol] The country code
+        # @param logical_type [Symbol] The logical document type
+        # @return [PolicyResult] The policy result
+        # @raise [ComplyanceSDK::Exceptions::ValidationError] If the combination is not allowed
+        def evaluate(country, logical_type)
+          # Validate inputs
+          unless Country.valid?(country)
+            raise ComplyanceSDK::Exceptions::ValidationError.new(
+              "Invalid country: #{country}. Valid countries: #{Country::ALL_COUNTRIES.join(', ')}"
+            )
+          end
+
+          unless LogicalDocType.valid?(logical_type)
+            raise ComplyanceSDK::Exceptions::ValidationError.new(
+              "Invalid logical document type: #{logical_type}. Valid types: #{LogicalDocType::ALL_TYPES.join(', ')}"
+            )
+          end
+
+          # Get policy for the logical type (country-agnostic for now)
+          policy = create_policy_for_logical_type(logical_type)
+          
+          if policy.nil?
+            raise ComplyanceSDK::Exceptions::ValidationError.new(
+              "Document type not allowed for country: #{country}. Logical type: #{logical_type}"
+            )
+          end
+
+          policy
+        end
+
+        private
+
+        # Create meta configuration flags map
+        #
+        # @param is_export [Boolean] Export flag
+        # @param is_self_billed [Boolean] Self-billed flag
+        # @param is_third_party [Boolean] Third party flag
+        # @param is_nominal_supply [Boolean] Nominal supply flag
+        # @param is_summary [Boolean] Summary flag
+        # @param is_b2b [Boolean] B2B flag
+        # @param is_prepayment [Boolean] Prepayment flag
+        # @param is_adjusted [Boolean] Adjusted flag
+        # @param is_receipt [Boolean] Receipt flag
+        # @return [Hash] The configuration flags
+        def create_config_map(is_export: false, is_self_billed: false, is_third_party: false, 
+                             is_nominal_supply: false, is_summary: false, is_b2b: false,
+                             is_prepayment: false, is_adjusted: false, is_receipt: false)
+          {
+            isExport: is_export,
+            isSelfBilled: is_self_billed,
+            isThirdParty: is_third_party,
+            isNominal: is_nominal_supply, # Changed from isNominalSupply to isNominal to match Java
+            isSummary: is_summary,
+            isB2B: is_b2b,
+            isPrepayment: is_prepayment,
+            isAdjusted: is_adjusted,
+            isReceipt: is_receipt
+          }
+        end
+
+        # Get document type string for a logical type
+        #
+        # @param logical_type [Symbol] The logical document type
+        # @return [String] The document type string
+        def get_document_type_string(logical_type)
+          LogicalDocType.invoice_data_document_type(logical_type)
+        end
+
+        # Get meta config document type for a logical type
+        #
+        # @param logical_type [Symbol] The logical document type
+        # @return [String] The meta config document type
+        def get_meta_config_document_type(logical_type)
+          LogicalDocType.meta_config_document_type(logical_type)
+        end
+
+        # Create policy result for a logical document type
+        #
+        # @param logical_type [Symbol] The logical document type
+        # @return [PolicyResult] The policy result
+        def create_policy_for_logical_type(logical_type)
+          document_type = get_document_type_string(logical_type)
+          type_name = logical_type.to_s
+
+          # Determine B2B vs B2C based on TAX_INVOICE vs SIMPLIFIED_TAX_INVOICE
+          is_b2b = if type_name.start_with?('simplified_tax_invoice')
+                     false # B2C
+                   elsif type_name.start_with?('tax_invoice')
+                     true # B2B
+                   else
+                     # For legacy types, set appropriate defaults
+                     # Legacy types - determine B2B based on context
+                     # case logical_type
+                     # when LogicalDocType::INVOICE,
+                     #      LogicalDocType::EXPORT_INVOICE,
+                     #      LogicalDocType::EXPORT_THIRD_PARTY_INVOICE,
+                     #      LogicalDocType::THIRD_PARTY_INVOICE,
+                     #      LogicalDocType::SELF_BILLED_INVOICE,
+                     #      LogicalDocType::NOMINAL_SUPPLY_INVOICE,
+                     #      LogicalDocType::SUMMARY_INVOICE
+                     #   true
+                     # else
+                     #   false
+                     # end
+                     true # Default for non-simplified types
+                   end
+
+          # Determine other flags based on type name
+          is_export = type_name.include?('export')
+          is_self_billed = type_name.include?('self_billed')
+          is_third_party = type_name.include?('third_party')
+          is_nominal_supply = type_name.include?('nominal_supply')
+          is_summary = type_name.include?('summary')
+          is_prepayment = type_name.include?('prepayment')
+          is_adjusted = type_name.include?('adjusted')
+          is_receipt = type_name.include?('receipt')
+
+          config = create_config_map(
+            is_export: is_export,
+            is_self_billed: is_self_billed,
+            is_third_party: is_third_party,
+            is_nominal_supply: is_nominal_supply,
+            is_summary: is_summary,
+            is_b2b: is_b2b,
+            is_prepayment: is_prepayment,
+            is_adjusted: is_adjusted,
+            is_receipt: is_receipt
+          )
+
+          # Determine base DocumentType
+          base_type = if type_name.include?('credit_note')
+                        DocumentType::CREDIT_NOTE
+                      elsif type_name.include?('debit_note')
+                        DocumentType::DEBIT_NOTE
+                      else
+                        DocumentType::TAX_INVOICE
+                      end
+
+          PolicyResult.new(base_type, config, document_type)
+        end
+      end
+    end
+  end
+end

data/lib/complyance_sdk/models/document_type.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module ComplyanceSDK
+  module Models
+    # Document type enumeration
+    module DocumentType
+      # Tax invoice document type
+      TAX_INVOICE = :tax_invoice
+      
+      # Credit note document type
+      CREDIT_NOTE = :credit_note
+      
+      # Debit note document type
+      DEBIT_NOTE = :debit_note
+      
+      # Get all valid document types
+      #
+      # @return [Array<Symbol>] All valid document types
+      def self.all
+        [TAX_INVOICE, CREDIT_NOTE, DEBIT_NOTE]
+      end
+      
+      # Check if a document type is valid
+      #
+      # @param document_type [Symbol, String] The document type to check
+      # @return [Boolean] True if valid, false otherwise
+      def self.valid?(document_type)
+        return false if document_type.nil?
+        all.include?(document_type.to_sym)
+      end
+      
+      # Convert string to document type symbol
+      #
+      # @param document_type [String, Symbol] The document type
+      # @return [Symbol, nil] The document type symbol or nil if invalid
+      def self.normalize(document_type)
+        return nil if document_type.nil?
+        
+        case document_type.to_s.downcase.gsub(/[-_\s]/, '')
+        when "taxinvoice", "invoice"
+          TAX_INVOICE
+        when "creditnote", "credit"
+          CREDIT_NOTE
+        when "debitnote", "debit"
+          DEBIT_NOTE
+        else
+          document_type.to_sym if valid?(document_type)
+        end
+      end
+    end
+  end
+end