io-complyance-unify-sdk 3.0.0

data/lib/complyance_sdk/queue/persistent_queue_manager.rb

@@ -0,0 +1,609 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'json'
+require 'logger'
+require 'concurrent-ruby'
+
+module ComplyanceSDK
+  module Queue
+    # Persistent queue manager for handling failed submissions with retry logic
+    # Ruby equivalent of the Java PersistentQueueManager
+    class PersistentQueueManager
+      QUEUE_DIR = 'complyance-queue'
+      PENDING_DIR = 'pending'
+      PROCESSING_DIR = 'processing'
+      FAILED_DIR = 'failed'
+      SUCCESS_DIR = 'success'
+
+      attr_reader :api_key, :local, :queue_base_path, :logger
+
+      # Initialize the persistent queue manager
+      #
+      # @param api_key [String] The API key
+      # @param local [Boolean] Whether running in local mode
+      # @param logger [Logger] Optional logger instance
+      def initialize(api_key, local = false, logger = nil)
+        @api_key = api_key
+        @local = local
+        @queue_base_path = File.join(Dir.home, QUEUE_DIR)
+        @logger = logger || Logger.new(STDOUT)
+        @processing_lock = Mutex.new
+        @running = false
+
+        initialize_queue_directories
+        @logger.info("PersistentQueueManager initialized with queue directory: #{@queue_base_path}")
+
+        # Automatically start processing and retry any existing failed submissions
+        start_processing
+        retry_failed_submissions
+      end
+
+      # Enqueue a failed submission for retry
+      #
+      # @param submission [Hash] The submission data
+      def enqueue(submission)
+        file_name = generate_file_name(submission)
+        file_path = File.join(@queue_base_path, PENDING_DIR, file_name)
+
+        # Check if file already exists (same document ID)
+        if File.exist?(file_path)
+          @logger.info("Document already exists in queue: #{file_name}. Skipping duplicate submission.")
+          return
+        end
+
+        # Parse the UnifyRequest JSON string to proper JSON object
+        json_payload = submission[:payload] || submission['payload']
+        @logger.info("🔥 QUEUE: Received payload from submission with length: #{json_payload.length} characters")
+        @logger.info("🔥 QUEUE: Payload preview: #{json_payload[0..199]}")
+
+        # Verify the payload is not empty
+        if json_payload.strip.empty? || json_payload == '{}'
+          @logger.error("🔥 QUEUE: ERROR - Received empty or invalid payload: '#{json_payload}'")
+          raise RuntimeError, 'Cannot enqueue empty payload'
+        end
+
+        # Parse the UnifyRequest JSON string to a proper JSON object
+        begin
+          unify_request_map = JSON.parse(json_payload)
+        rescue JSON::ParserError => e
+          @logger.error("🔥 QUEUE: Failed to parse JSON payload: #{e.message}")
+          raise RuntimeError, "Invalid JSON payload: #{e.message}"
+        end
+
+        # Create submission record with the parsed UnifyRequest as proper JSON object
+        record = {
+          payload: unify_request_map, # Store as Hash instead of string
+          source_id: submission[:source][:id] || submission['source']['id'],
+          country: submission[:country].to_s || submission['country'].to_s,
+          document_type: submission[:document_type].to_s || submission['document_type'].to_s,
+          enqueued_at: Time.now.utc.strftime('%Y-%m-%dT%H:%M:%SZ'),
+          timestamp: Time.now.to_i
+        }
+
+        # Write to file
+        File.write(file_path, JSON.pretty_generate(record))
+
+        @logger.info("🔥 QUEUE: Stored record to file: #{file_name} with payload length: #{json_payload.length}")
+        @logger.info("Enqueued submission to persistent storage: #{file_name} for source: #{record[:source_id]}, country: #{record[:country]}")
+
+        # Start processing if not already running
+        start_processing
+      rescue => e
+        @logger.error("Failed to enqueue submission to persistent storage: #{e.message}")
+        raise RuntimeError, "Failed to persist submission: #{e.message}"
+      end
+
+      # Start processing pending submissions
+      def start_processing
+        return if @running
+
+        @running = true
+        
+        # Start background thread for processing
+        @processing_thread = Thread.new do
+          loop do
+            break unless @running
+            
+            begin
+              process_pending_submissions
+            rescue => e
+              @logger.error("Error in processing thread: #{e.message}")
+            end
+            
+            sleep(30) # Process every 30 seconds
+          end
+        end
+
+        @logger.info('Started persistent queue processing')
+      end
+
+      # Stop processing pending submissions
+      def stop_processing
+        @running = false
+        @processing_thread&.join(5) # Wait up to 5 seconds for thread to finish
+        @logger.info('Stopped persistent queue processing')
+      end
+
+      # Manually trigger processing of pending submissions
+      def process_pending_submissions_now
+        @logger.info('Manually triggering processing of pending submissions')
+        process_pending_submissions
+      end
+
+      # Get queue status and statistics
+      #
+      # @return [Hash] Queue status information
+      def queue_status
+        {
+          pending_count: count_files_in_directory(PENDING_DIR),
+          processing_count: count_files_in_directory(PROCESSING_DIR),
+          failed_count: count_files_in_directory(FAILED_DIR),
+          success_count: count_files_in_directory(SUCCESS_DIR),
+          running: @running
+        }
+      end
+
+      # Retry failed submissions by moving them back to pending
+      def retry_failed_submissions
+        failed_dir = File.join(@queue_base_path, FAILED_DIR)
+        pending_dir = File.join(@queue_base_path, PENDING_DIR)
+        
+        failed_files = Dir.glob(File.join(failed_dir, '*.json'))
+
+        if failed_files.empty?
+          @logger.info('No failed submissions to retry')
+          return
+        end
+
+        @logger.info("Retrying #{failed_files.length} failed submissions")
+
+        failed_files.each do |file_path|
+          file_name = File.basename(file_path)
+          pending_path = File.join(pending_dir, file_name)
+          
+          FileUtils.mv(file_path, pending_path)
+          @logger.debug("Moved failed submission back to pending: #{file_name}")
+        end
+      rescue => e
+        @logger.error("Failed to retry failed submissions: #{e.message}")
+      end
+
+      # Clean up old success files
+      #
+      # @param days_to_keep [Integer] Number of days to keep success files
+      def cleanup_old_success_files(days_to_keep)
+        success_dir = File.join(@queue_base_path, SUCCESS_DIR)
+        cutoff_time = Time.now - (days_to_keep * 24 * 60 * 60)
+
+        old_files = Dir.glob(File.join(success_dir, '*.json')).select do |file_path|
+          File.mtime(file_path) < cutoff_time
+        end
+
+        old_files.each do |file_path|
+          File.delete(file_path)
+          @logger.debug("Cleaned up old success file: #{File.basename(file_path)}")
+        end
+
+        @logger.info("Cleaned up #{old_files.length} old success files") unless old_files.empty?
+      rescue => e
+        @logger.error("Failed to cleanup old success files: #{e.message}")
+      end
+
+      # Clear all files from the queue (emergency cleanup)
+      def clear_all_queues
+        @logger.info('Clearing all queue directories...')
+
+        [PENDING_DIR, PROCESSING_DIR, FAILED_DIR, SUCCESS_DIR].each do |dir_name|
+          clear_directory(dir_name)
+        end
+
+        @logger.info('All queue directories cleared successfully')
+      rescue => e
+        @logger.error("Error clearing queue directories: #{e.message}")
+        raise RuntimeError, "Failed to clear queues: #{e.message}"
+      end
+
+      # Clean up duplicate files across queue directories
+      def cleanup_duplicate_files
+        @logger.info('Cleaning up duplicate files across queue directories...')
+
+        file_map = {}
+
+        [PENDING_DIR, PROCESSING_DIR, FAILED_DIR, SUCCESS_DIR].each do |dir_name|
+          dir_path = File.join(@queue_base_path, dir_name)
+          next unless Dir.exist?(dir_path)
+
+          Dir.glob(File.join(dir_path, '*.json')).each do |file_path|
+            file_name = File.basename(file_path)
+            existing_file = file_map[file_name]
+
+            if existing_file
+              # File exists in multiple directories, keep the one with latest modification time
+              begin
+                existing_time = File.mtime(existing_file)
+                current_time = File.mtime(file_path)
+
+                if current_time > existing_time
+                  # Delete the older file
+                  File.delete(existing_file)
+                  file_map[file_name] = file_path
+                  @logger.debug("Removed duplicate file (older): #{existing_file}")
+                else
+                  # Delete the current file
+                  File.delete(file_path)
+                  @logger.debug("Removed duplicate file (older): #{file_path}")
+                end
+              rescue => e
+                @logger.warn("Could not compare modification times for duplicate file: #{file_name}")
+                # Keep the existing file, delete current
+                File.delete(file_path)
+              end
+            else
+              file_map[file_name] = file_path
+            end
+          end
+        end
+
+        @logger.info('Duplicate file cleanup completed')
+      rescue => e
+        @logger.error("Error during duplicate file cleanup: #{e.message}")
+      end
+
+      private
+
+      # Initialize queue directories
+      def initialize_queue_directories
+        [PENDING_DIR, PROCESSING_DIR, FAILED_DIR, SUCCESS_DIR].each do |dir_name|
+          dir_path = File.join(@queue_base_path, dir_name)
+          FileUtils.mkdir_p(dir_path)
+        end
+        @logger.debug('Queue directories initialized')
+      rescue => e
+        @logger.error("Failed to create queue directories: #{e.message}")
+        raise RuntimeError, "Failed to initialize persistent queue: #{e.message}"
+      end
+
+      # Generate file name for a submission
+      #
+      # @param submission [Hash] The submission data
+      # @return [String] The generated file name
+      def generate_file_name(submission)
+        # Extract document ID from payload to create unique reference
+        document_id = extract_document_id(submission[:payload] || submission['payload'])
+
+        # Generate filename using source and document ID for unique reference
+        source_id = (submission[:source][:id] || submission['source']['id']).gsub(/[^a-zA-Z0-9]/, '_')
+        country = submission[:country].to_s || submission['country'].to_s
+        document_type = submission[:document_type].to_s || submission['document_type'].to_s
+
+        "#{source_id}_#{document_id}_#{country}_#{document_type}.json"
+      end
+
+      # Extract document ID from payload
+      #
+      # @param payload [String] The JSON payload string
+      # @return [String] The document ID or timestamp-based ID
+      def extract_document_id(payload)
+        # Parse the complete UnifyRequest JSON
+        request_map = JSON.parse(payload)
+
+        # Extract from payload.invoice_data.invoice_number
+        if request_map['payload'] && request_map['payload']['invoice_data'] && request_map['payload']['invoice_data']['invoice_number']
+          return request_map['payload']['invoice_data']['invoice_number']
+        end
+
+        # Fallback to timestamp if no invoice number found
+        "doc_#{Time.now.to_i}"
+      rescue => e
+        @logger.warn("Failed to extract document ID from UnifyRequest payload, using timestamp: #{e.message}")
+        "doc_#{Time.now.to_i}"
+      end
+
+      # Process pending submissions
+      def process_pending_submissions
+        return unless @running
+
+        @processing_lock.synchronize do
+          pending_dir = File.join(@queue_base_path, PENDING_DIR)
+          pending_files = Dir.glob(File.join(pending_dir, '*.json'))
+
+          return if pending_files.empty?
+
+          @logger.debug("Found #{pending_files.length} pending submissions to process")
+
+          pending_files.each do |file_path|
+            # Check if file still exists before processing
+            next unless File.exist?(file_path)
+            
+            process_submission_file(file_path)
+          end
+        end
+      rescue => e
+        @logger.error("Error processing pending submissions: #{e.message}")
+      end
+
+      # Process a single submission file
+      #
+      # @param file_path [String] Path to the submission file
+      def process_submission_file(file_path)
+        # Read submission record first (before moving)
+        record = JSON.parse(File.read(file_path), symbolize_names: true)
+
+        payload_json = JSON.pretty_generate(record[:payload])
+        @logger.info("🔥 QUEUE: Read record from file: #{File.basename(file_path)} with payload length: #{payload_json.length}")
+        @logger.info("🔥 QUEUE: Read payload preview: #{payload_json[0..199]}")
+
+        # Move to processing directory
+        processing_path = File.join(@queue_base_path, PROCESSING_DIR, File.basename(file_path))
+        FileUtils.mv(file_path, processing_path)
+
+        @logger.debug("Processing submission: #{File.basename(file_path)} for source: #{record[:source_id]}")
+
+        # Convert back to submission format
+        submission = convert_to_submission(record)
+
+        # Print the JSON payload being sent from queue
+        @logger.info('=== QUEUE SUBMISSION JSON ===')
+        @logger.info("File: #{File.basename(file_path)}")
+        @logger.info("Source: #{record[:source_id]}")
+        @logger.info("Country: #{record[:country]}")
+        @logger.info("Document Type: #{record[:document_type]}")
+        @logger.info("Enqueued At: #{record[:enqueued_at]}")
+        @logger.info('Payload JSON:')
+        @logger.info(JSON.pretty_generate(record[:payload]))
+        @logger.info('=== END QUEUE SUBMISSION JSON ===')
+
+        # Attempt to send using the stored UnifyRequest directly
+        begin
+          # Convert the stored Map back to UnifyRequest object
+          unify_request = convert_to_unify_request(record[:payload])
+
+          # Convert camelCase keys to snake_case for Ruby SDK compatibility
+          converted_request = convert_camelcase_to_snakecase(unify_request)
+
+          @logger.info('🔥 QUEUE: Successfully converted stored UnifyRequest Map to object')
+          @logger.info("🔥 QUEUE: Request ID: #{converted_request[:request_id]}")
+          @logger.info("🔥 QUEUE: Document Type: #{converted_request[:document_type]}")
+          @logger.info("🔥 QUEUE: Country: #{converted_request[:country]}")
+          @logger.info("🔥 QUEUE: Source: #{converted_request[:source][:id]}")
+          @logger.info("🔥 QUEUE: Operation: #{converted_request[:operation]}")
+          @logger.info("🔥 QUEUE: Mode: #{converted_request[:mode]}")
+          @logger.info("🔥 QUEUE: Purpose: #{converted_request[:purpose]}")
+
+          # Keep the environment as-is - no conversion
+          current_env = converted_request[:env]
+          @logger.info("🔥 QUEUE: Keeping environment as '#{current_env}'")
+
+          # Use the SDK's push_to_unify_request method to send the stored UnifyRequest
+          @logger.info('🔥 QUEUE: Sending stored UnifyRequest via SDK push_to_unify_request')
+          response = ComplyanceSDK.push_to_unify_request(converted_request)
+
+          # Log the complete response details
+          @logger.info('🔥 QUEUE: API Response received')
+          @logger.info("🔥 QUEUE: Response Status: #{response&.status || 'NULL'}")
+          @logger.info("🔥 QUEUE: Response Message: #{response&.message || 'NULL'}")
+
+          if response&.data
+            @logger.info('🔥 QUEUE: Response Data available')
+
+            # Log submission details if available
+            if response.data[:submission]
+              submission_response = response.data[:submission]
+              @logger.info("🔥 QUEUE: Submission ID: #{submission_response[:submission_id]}")
+              @logger.info("🔥 QUEUE: Submission Status: #{submission_response[:status]}")
+              @logger.info("🔥 QUEUE: Submission Country: #{submission_response[:country]}")
+              @logger.info("🔥 QUEUE: Submission Authority: #{submission_response[:authority]}")
+              @logger.info("🔥 QUEUE: Is Accepted: #{submission_response[:accepted]}")
+              @logger.info("🔥 QUEUE: Is Rejected: #{submission_response[:rejected]}")
+              @logger.info("🔥 QUEUE: Is Failed: #{submission_response[:failed]}")
+            end
+
+            # Log document details if available
+            if response.data[:document]
+              document = response.data[:document]
+              @logger.info("🔥 QUEUE: Document ID: #{document[:document_id]}")
+              @logger.info("🔥 QUEUE: Document Type: #{document[:document_type]}")
+              @logger.info("🔥 QUEUE: Document Status: #{document[:status]}")
+              @logger.info("🔥 QUEUE: Document Created At: #{document[:created_at]}")
+            end
+
+            # Log processing details if available
+            if response.data[:processing]
+              processing = response.data[:processing]
+              @logger.info("🔥 QUEUE: Processing Status: #{processing[:status]}")
+              @logger.info("🔥 QUEUE: Processing Purpose: #{processing[:purpose]}")
+              @logger.info("🔥 QUEUE: Processing Completed At: #{processing[:completed_at]}")
+            end
+          end
+
+          if response&.error
+            @logger.error('🔥 QUEUE: API Error Details:')
+            @logger.error("🔥 QUEUE: Error Code: #{response.error[:code]}")
+            @logger.error("🔥 QUEUE: Error Message: #{response.error[:message]}")
+            @logger.error("🔥 QUEUE: Error Suggestion: #{response.error[:suggestion]}")
+          end
+
+          # Check for success using the proper method and also check for HTTP 200 equivalent
+          is_success = false
+          status = response&.status || 'null'
+
+          @logger.info('🔥 QUEUE: Analyzing success criteria...')
+          @logger.info("🔥 QUEUE: Response Status: '#{status}'")
+
+          if response
+            # Use the proper success? method from UnifyResponse
+            response_success = response.success?
+            @logger.info("🔥 QUEUE: response.success?: #{response_success}")
+            is_success = response_success
+
+            # Also check if submission was accepted (for invoicing purpose)
+            if response.data&.dig(:submission)
+              submission_response = response.data[:submission]
+              submission_accepted = submission_response[:accepted] == true
+              status_accepted = submission_response[:status]&.downcase == 'accepted'
+              @logger.info("🔥 QUEUE: submission.accepted?: #{submission_accepted}")
+              @logger.info("🔥 QUEUE: submission.status == 'accepted': #{status_accepted}")
+              @logger.info("🔥 QUEUE: submission.status value: '#{submission_response[:status]}'")
+
+              is_success = is_success || submission_accepted || status_accepted
+            end
+
+            # Check for document creation success
+            if response.data&.dig(:document)
+              document = response.data[:document]
+              document_success = document[:status]&.downcase == 'success'
+              @logger.info("🔥 QUEUE: document.status == 'success': #{document_success}")
+              @logger.info("🔥 QUEUE: document.status value: '#{document[:status]}'")
+
+              is_success = is_success || document_success
+            end
+          end
+
+          @logger.info("🔥 QUEUE: Final is_success determination: #{is_success}")
+
+          if is_success
+            @logger.info('🔥 QUEUE: SUCCESS DETECTED - Removing file from queue')
+            @logger.info("🔥 QUEUE: File to remove: #{File.basename(processing_path)}")
+            # Remove the file completely - it's successfully processed
+            deleted = File.delete(processing_path) rescue false
+            @logger.info("🔥 QUEUE: File deletion result: #{deleted}")
+            @logger.info("🔥 QUEUE: Successfully processed and removed from queue: #{File.basename(file_path)}")
+            return # Exit successfully
+          else
+            # If response is not successful, treat as failure
+            @logger.warn('🔥 QUEUE: NON-SUCCESS DETECTED - Moving to failed directory')
+            @logger.warn("🔥 QUEUE: Response status: '#{status}'")
+            @logger.warn("🔥 QUEUE: File to move: #{File.basename(processing_path)}")
+            raise RuntimeError, "API returned non-success status: #{status}"
+          end
+        rescue => e
+          @logger.error("Failed to send queued submission via push_to_unify: #{e.message}")
+          # Move to failed directory instead of re-queuing
+          failed_path = File.join(@queue_base_path, FAILED_DIR, File.basename(processing_path))
+
+          # Check if file already exists in failed directory and handle it
+          if File.exist?(failed_path)
+            @logger.warn("File already exists in failed directory, deleting processing file: #{File.basename(processing_path)}")
+            File.delete(processing_path) rescue nil
+          else
+            FileUtils.mv(processing_path, failed_path)
+            @logger.info("Moved failed submission to: #{failed_path}")
+          end
+          raise e
+        end
+      rescue => e
+        @logger.warn("Failed to process submission: #{File.basename(file_path)} - Error: #{e.message}")
+
+        begin
+          # Move to failed directory
+          processing_path = File.join(@queue_base_path, PROCESSING_DIR, File.basename(file_path))
+          failed_path = File.join(@queue_base_path, FAILED_DIR, File.basename(file_path))
+
+          if File.exist?(processing_path)
+            # Check if file already exists in failed directory
+            if File.exist?(failed_path)
+              @logger.warn("File already exists in failed directory, deleting processing file: #{File.basename(file_path)}")
+              File.delete(processing_path) rescue nil
+            else
+              FileUtils.mv(processing_path, failed_path)
+              @logger.debug("Moved failed submission to failed directory: #{File.basename(file_path)}")
+            end
+          else
+            # If file was already moved to processing, move from pending to failed
+            pending_path = File.join(@queue_base_path, PENDING_DIR, File.basename(file_path))
+            if File.exist?(pending_path)
+              if File.exist?(failed_path)
+                @logger.warn("File already exists in failed directory, deleting pending file: #{File.basename(file_path)}")
+                File.delete(pending_path) rescue nil
+              else
+                FileUtils.mv(pending_path, failed_path)
+                @logger.debug("Moved failed submission from pending to failed directory: #{File.basename(file_path)}")
+              end
+            end
+          end
+        rescue => move_error
+          @logger.error("Failed to move submission to failed directory: #{File.basename(file_path)}: #{move_error.message}")
+        end
+      end
+
+      # Convert stored record back to submission format
+      #
+      # @param record [Hash] The stored record
+      # @return [Hash] The submission hash
+      def convert_to_submission(record)
+        # Convert Map back to JSON string for submission
+        json_payload = JSON.generate(record[:payload])
+        
+        {
+          payload: json_payload,
+          source: { id: record[:source_id] },
+          country: record[:country].to_sym,
+          document_type: record[:document_type].to_sym
+        }
+      end
+
+      # Convert stored payload to UnifyRequest format
+      #
+      # @param payload_map [Hash] The stored payload map
+      # @return [Hash] The UnifyRequest hash
+      def convert_to_unify_request(payload_map)
+        # The stored payload IS the UnifyRequest data (top-level)
+        # The nested "payload" field contains the invoice data, not the UnifyRequest
+        payload_map
+      end
+
+      # Convert camelCase keys to snake_case for Ruby SDK compatibility
+      def convert_camelcase_to_snakecase(hash)
+        return hash unless hash.is_a?(Hash)
+        
+        converted = {}
+        hash.each do |key, value|
+          # Convert camelCase to snake_case
+          snake_key = key.to_s.gsub(/([A-Z])/, '_\1').downcase.to_sym
+          
+          # Recursively convert nested hashes
+          if value.is_a?(Hash)
+            converted[snake_key] = convert_camelcase_to_snakecase(value)
+          elsif value.is_a?(Array)
+            converted[snake_key] = value.map do |item|
+              item.is_a?(Hash) ? convert_camelcase_to_snakecase(item) : item
+            end
+          else
+            converted[snake_key] = value
+          end
+        end
+        
+        converted
+      end
+
+      # Count files in a directory
+      #
+      # @param dir_name [String] Directory name
+      # @return [Integer] Number of JSON files
+      def count_files_in_directory(dir_name)
+        dir_path = File.join(@queue_base_path, dir_name)
+        return 0 unless Dir.exist?(dir_path)
+        
+        Dir.glob(File.join(dir_path, '*.json')).length
+      end
+
+      # Clear all files in a directory
+      #
+      # @param dir_name [String] Directory name
+      def clear_directory(dir_name)
+        dir_path = File.join(@queue_base_path, dir_name)
+        return unless Dir.exist?(dir_path)
+
+        files = Dir.glob(File.join(dir_path, '*.json'))
+        
+        files.each do |file_path|
+          File.delete(file_path) rescue nil
+          @logger.debug("Deleted file: #{File.basename(file_path)}")
+        end
+
+        @logger.info("Cleared #{files.length} files from #{dir_name}")
+      end
+    end
+  end
+end

data/lib/complyance_sdk/railtie.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rails"
+
+module ComplyanceSDK
+  # Railtie for Rails integration
+  class Railtie < Rails::Railtie
+    initializer "complyance_sdk.configure" do |app|
+      # Auto-configure from Rails credentials if not already configured
+      ComplyanceSDK.configure_from_rails unless ComplyanceSDK.configured?
+      
+      # Add middleware if configured
+      if ComplyanceSDK.configured? && defined?(ActionDispatch::Request)
+        require "complyance_sdk/middleware/rack_middleware"
+        app.middleware.use ComplyanceSDK::Middleware::RackMiddleware
+      end
+    end
+    
+    # Add generators
+    generators do
+      require "complyance_sdk/generators/install_generator" if defined?(Rails::Generators)
+    end
+    
+    # Add rake tasks
+    rake_tasks do
+      load "complyance_sdk/tasks/complyance.rake" if File.exist?(File.join(File.dirname(__FILE__), "tasks/complyance.rake"))
+    end
+  end
+end