ox-tender-abstract 0.9.3 → 0.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9924cb49a0b35703d8e0093b3ae40b8b8556f7da398990b3ff5f84f185c7d944
-  data.tar.gz: 2598c2bb4af463aa3cbf1bde9c1cc76aac352f8e58a193152305dccc4a2cef8a
+  metadata.gz: 29f0092ce09cc7fd85cfdea5489dbe645e1d28f99a12a2f98e57a48761bf2f13
+  data.tar.gz: abb88a96187a2a0e11e16efdf067368e5e4cd20504e080384789504a8a530c21
 SHA512:
-  metadata.gz: 3c0a783ab40ca1f45be2d0d5c32db63345a40502bdf6140b446018686b73482afba84ce3097d7ab7afe821b106915e06ba32b03b66a35a19adf95fdc4ad2c404
-  data.tar.gz: 53a15a50dad376969b8ff1869e88197a669288bdd57b3931ce59105c8288b25f6f9a9768e03b9211f8284570e4bbf219daa98f2702270c39c967c5e1737c4ead
+  metadata.gz: 7351bf939d3e42d07ae65f313e5cb0621732cfa5c9c4cc3d0bfa77581fd9c4b51d284844901dcd50eed4e93d1dddff6a79a8055b4f79c45c1fbbeca2efc24129
+  data.tar.gz: 8df04c15cd6381544847fce45624f148b1ea824812aa7717ff52a1fcf304e030cc8beb910b02bbfd294d84411397d10cd1e03fac7a90d061b3c600f41c76276c

data/.ruby-version

@@ -1 +1 @@
-3.4.4
+3.4.5

data/CHANGELOG.md

@@ -1,3 +1,21 @@
+## [0.9.5] - 2025-08-06
+
+### Fixed
+
+- Fixed encoding compatibility error when processing API blocking messages
+- Fixed missing `include_attachments` parameter in `search_tenders` and `search_tenders_with_auto_wait` methods
+- Improved error handling for binary response data from API
+
+### Changed
+
+- Enhanced encoding handling in `ArchiveProcessor` to safely handle UTF-8 and BINARY responses
+- Restored `include_attachments` parameter to all search methods with default value `true`
+
+### Added
+
+- Better error logging for encoding issues
+- Safe encoding conversion using `force_encoding('UTF-8').scrub`
+
 ## [0.9.3] - 2025-07-27
 
 - Added support for parsing tender documents

data/SIDEKIQ_USAGE.md

@@ -0,0 +1,341 @@
+# Использование OxTenderAbstract с Sidekiq
+
+## Обработка блокировок API в отложенных задачах
+
+При частых запросах к API zakupki.gov.ru сервер может заблокировать загрузку архивов на 10 минут. Библиотека теперь правильно обрабатывает такие блокировки и возвращает специальные результаты.
+
+## Рекомендуемый Sidekiq Worker с автоматическим ожиданием
+
+```ruby
+class TenderImportWorker
+  include Sidekiq::Worker
+  
+  # Простая настройка - библиотека сама управляет блокировками
+  sidekiq_options retry: 3
+  
+  def perform(region, date, subsystem_type = 'PRIZ', document_type = 'epNotificationEF2020', resume_state = nil)
+    # Используем новый метод с автоматическим ожиданием
+    result = OxTenderAbstract.search_tenders_with_auto_wait(
+      org_region: region,
+      exact_date: date,
+      subsystem_type: subsystem_type,
+      document_type: document_type,
+      resume_state: resume_state
+    )
+    
+    if result.failure?
+      # Обрабатываем только критические ошибки
+      handle_failure(result, region, date, subsystem_type, document_type)
+    else
+      process_tenders(result.data[:tenders])
+    end
+  end
+  
+  private
+  
+  def handle_failure(result, region, date, subsystem_type, document_type)
+    # С автоматическим ожиданием блокировки обрабатываются автоматически
+    # Нужно обрабатывать только реальные ошибки
+    logger.error "Tender import failed: #{result.error}"
+    raise StandardError, result.error
+  end
+  
+  def process_tenders(tenders)
+    tenders.each do |tender|
+      save_tender_to_database(tender)
+    end
+    
+    logger.info "Processed #{tenders.size} tenders"
+  end
+end
+```
+
+## Альтернативный Worker с ручным управлением
+
+```ruby
+class TenderImportWorkerManual
+  include Sidekiq::Worker
+  
+  # Настраиваем повторные попытки с увеличенной задержкой для блокировок
+  sidekiq_options retry: 5
+  
+  def perform(region, date, subsystem_type = 'PRIZ', document_type = 'epNotificationEF2020', resume_state = nil)
+    # Отключаем автоматическое ожидание для ручного управления
+    OxTenderAbstract.configure do |config|
+      config.auto_wait_on_block = false
+    end
+    
+    result = OxTenderAbstract.search_tenders_with_auto_wait(
+      org_region: region,
+      exact_date: date,
+      subsystem_type: subsystem_type,
+      document_type: document_type,
+      resume_state: resume_state
+    )
+    
+    if result.failure?
+      handle_failure(result, region, date, subsystem_type, document_type)
+    else
+      process_tenders(result.data[:tenders])
+    end
+  end
+  
+  private
+  
+  def handle_failure(result, region, date, subsystem_type, document_type)
+    # Проверяем тип ошибки
+    if result.metadata[:error_type] == :blocked
+      # API заблокировал доступ на 10 минут
+      retry_after = result.metadata[:retry_after] || 600
+      
+      logger.warn "Archive download blocked, retrying in #{retry_after} seconds"
+      
+      # Перепланируем задачу через указанное время
+      TenderImportWorker.perform_in(
+        retry_after.seconds + 30, # +30 секунд для гарантии
+        region, date, subsystem_type, document_type
+      )
+    else
+      # Обычная ошибка - логируем и возможно повторяем стандартно
+      logger.error "Tender import failed: #{result.error}"
+      raise StandardError, result.error
+    end
+  end
+  
+  def process_tenders(tenders)
+    tenders.each do |tender|
+      # Обработка каждого тендера
+      save_tender_to_database(tender)
+    end
+    
+    logger.info "Processed #{tenders.size} tenders"
+  end
+end
+```
+
+## Конфигурация автоматического ожидания
+
+Библиотека теперь поддерживает встроенное автоматическое ожидание при блокировках:
+
+```ruby
+# config/initializers/ox_tender_abstract.rb
+OxTenderAbstract.configure do |config|
+  config.token = ENV['ZAKUPKI_API_TOKEN']
+  
+  # Настройки автоматического ожидания
+  config.auto_wait_on_block = true    # Автоматически ждать при блокировке (по умолчанию true)
+  config.block_wait_time = 610        # Время ожидания в секундах (10 мин + 10 сек)
+  config.max_wait_time = 900          # Максимальное время ожидания (15 мин)
+end
+```
+
+### Режимы работы
+
+1. **Автоматическое ожидание** (`auto_wait_on_block = true`) - библиотека сама ждет и продолжает
+2. **Ручное управление** (`auto_wait_on_block = false`) - возвращает состояние для продолжения в Sidekiq
+
+## Настройка Sidekiq для обработки блокировок
+
+### 1. Кастомная стратегия повторов
+
+```ruby
+# config/initializers/sidekiq.rb
+
+# Кастомная стратегия повторов для API блокировок
+class TenderRetryStrategy
+  def call(worker, job, queue)
+    # Извлекаем информацию об ошибке
+    exception = job['error_message']
+    
+    if exception&.include?('blocked')
+      # Для блокировок используем фиксированную задержку
+      return 600 # 10 минут
+    else
+      # Стандартная экспоненциальная задержка
+      return (job['retry_count'] ** 4) + 15
+    end
+  end
+end
+
+Sidekiq.configure_server do |config|
+  config.death_handlers << lambda do |job, ex|
+    # Логируем окончательно проваленные задачи
+    Rails.logger.error "Sidekiq job #{job['class']} failed permanently: #{ex.message}"
+  end
+end
+```
+
+### 2. Настройка очередей с приоритетами
+
+```ruby
+# config/sidekiq.yml
+:queues:
+  - [critical, 2]
+  - [tenders_import, 1] 
+  - [tenders_retry, 1]
+  - [default, 1]
+```
+
+### 3. Worker с интеллектуальными повторами
+
+```ruby
+class SmartTenderImportWorker
+  include Sidekiq::Worker
+  
+  sidekiq_options queue: 'tenders_import', retry: 3
+  
+  # Кастомная логика повторов
+  sidekiq_retry_in do |count, exception|
+    case exception.message
+    when /blocked/
+      # Для блокировок ждем 10 минут
+      600
+    when /network error/i
+      # Для сетевых ошибок короткая задержка
+      30 * (count + 1)
+    else
+      # Стандартная задержка
+      60 * (count + 1)
+    end
+  end
+  
+  def perform(params)
+    with_error_handling do
+      import_tenders(params)
+    end
+  end
+  
+  private
+  
+  def with_error_handling
+    yield
+  rescue => e
+    if e.message.include?('blocked')
+      # Перемещаем в специальную очередь для повторов
+      SmartTenderImportWorker.set(queue: 'tenders_retry')
+                            .perform_in(610.seconds, { retry: true }.merge(params))
+    else
+      raise e
+    end
+  end
+end
+```
+
+## Мониторинг и отладка
+
+### 1. Логирование блокировок
+
+```ruby
+class TenderImportLogger
+  def self.log_blocked_request(region, date, retry_after)
+    Rails.logger.warn {
+      "[TENDER_BLOCKED] Region: #{region}, Date: #{date}, Retry after: #{retry_after}s"
+    }
+    
+    # Отправка в системы мониторинга
+    StatsD.increment('tender_import.blocked')
+    StatsD.histogram('tender_import.retry_delay', retry_after)
+  end
+end
+```
+
+### 2. Метрики для мониторинга
+
+```ruby
+# В worker'е
+def perform(params)
+  start_time = Time.current
+  
+  begin
+    result = import_tenders(params)
+    StatsD.increment('tender_import.success')
+    StatsD.histogram('tender_import.duration', Time.current - start_time)
+  rescue => e
+    StatsD.increment('tender_import.error')
+    StatsD.increment("tender_import.error.#{error_type(e)}")
+    raise
+  end
+end
+
+def error_type(exception)
+  case exception.message
+  when /blocked/ then 'blocked'
+  when /network/ then 'network'
+  when /parse/ then 'parse'
+  else 'unknown'
+  end
+end
+```
+
+## Рекомендации
+
+1. **Используйте разные очереди** для обычных и повторных задач
+2. **Мониторьте частоту блокировок** - если они частые, уменьшите нагрузку
+3. **Настройте алерты** на высокий процент блокировок
+4. **Кэшируйте результаты** где возможно, чтобы уменьшить количество запросов
+5. **Используйте rate limiting** на уровне приложения
+
+## Пример полной настройки
+
+```ruby
+# app/workers/tender_import_worker.rb
+class TenderImportWorker
+  include Sidekiq::Worker
+  include Sidekiq::Throttled::Worker
+  
+  # Ограничиваем количество одновременных запросов
+  sidekiq_throttle(
+    threshold: { limit: 5, period: 1.minute },
+    key: ->(region, date) { "tender_import:#{region}" }
+  )
+  
+  sidekiq_options queue: 'tenders', retry: 5
+  
+  def perform(region, date, options = {})
+    TenderImportService.new(region, date, options).call
+  end
+end
+
+# app/services/tender_import_service.rb
+class TenderImportService
+  def initialize(region, date, options = {})
+    @region = region
+    @date = date
+    @options = options
+  end
+  
+  def call
+    result = OxTenderAbstract.search_tenders(
+      org_region: @region,
+      exact_date: @date,
+      subsystem_type: @options[:subsystem_type] || 'PRIZ'
+    )
+    
+    if result.failure?
+      handle_error(result)
+    else
+      process_success(result)
+    end
+  end
+  
+  private
+  
+  def handle_error(result)
+    case result.metadata[:error_type]
+    when :blocked
+      schedule_retry(result.metadata[:retry_after])
+    when :network
+      raise NetworkError, result.error
+    else
+      raise StandardError, result.error
+    end
+  end
+  
+  def schedule_retry(retry_after)
+    TenderImportWorker.perform_in(
+      (retry_after + 30).seconds,
+      @region, @date, @options.merge(retry: true)
+    )
+  end
+end
+```

data/lib/ox-tender-abstract.rb

@@ -29,18 +29,19 @@ module OxTenderAbstract
 
     # Convenience method for searching tenders in specific subsystem
     def search_tenders(org_region:, exact_date:, subsystem_type: DocumentTypes::DEFAULT_SUBSYSTEM,
-                       document_type: DocumentTypes::DEFAULT_DOCUMENT_TYPE)
+                       document_type: DocumentTypes::DEFAULT_DOCUMENT_TYPE, include_attachments: true)
       client = Client.new
       client.search_tenders(
         org_region: org_region,
         exact_date: exact_date,
         subsystem_type: subsystem_type,
-        document_type: document_type
+        document_type: document_type,
+        include_attachments: include_attachments
       )
     end
 
     # Enhanced method for searching tenders across multiple subsystems
-    def search_all_tenders(org_region:, exact_date:, subsystems: nil, document_types: nil)
+    def search_all_tenders(org_region:, exact_date:, subsystems: nil, document_types: nil, include_attachments: true)
       # Default subsystems to search
       subsystems ||= %w[PRIZ RPEC RPGZ BTK UR RGK OD223 RD223]
 
@@ -67,7 +68,8 @@ module OxTenderAbstract
             org_region: org_region,
             exact_date: exact_date,
             subsystem_type: subsystem_type,
-            document_type: doc_type
+            document_type: doc_type,
+            include_attachments: include_attachments
           )
 
           if result.success?
@@ -134,7 +136,8 @@ module OxTenderAbstract
 
     # Search tenders with automatic wait on API blocks and resume capability
     def search_tenders_with_auto_wait(org_region:, exact_date:, subsystem_type: DocumentTypes::DEFAULT_SUBSYSTEM,
-                                      document_type: DocumentTypes::DEFAULT_DOCUMENT_TYPE, resume_state: nil)
+                                      document_type: DocumentTypes::DEFAULT_DOCUMENT_TYPE, resume_state: nil,
+                                      include_attachments: true)
       client = Client.new
       
       # Если есть состояние для продолжения
@@ -146,7 +149,8 @@ module OxTenderAbstract
           subsystem_type: subsystem_type,
           document_type: document_type,
           start_from_archive: start_from,
-          resume_state: resume_state
+          resume_state: resume_state,
+          include_attachments: include_attachments
         )
       else
         # Используем обычный метод если авто-ожидание включено
@@ -155,7 +159,8 @@ module OxTenderAbstract
             org_region: org_region,
             exact_date: exact_date,
             subsystem_type: subsystem_type,
-            document_type: document_type
+            document_type: document_type,
+            include_attachments: include_attachments
           )
         else
           # Используем метод с возможностью продолжения
@@ -163,7 +168,8 @@ module OxTenderAbstract
             org_region: org_region,
             exact_date: exact_date,
             subsystem_type: subsystem_type,
-            document_type: document_type
+            document_type: document_type,
+            include_attachments: include_attachments
           )
         end
       end

data/lib/oxtenderabstract/archive_processor.rb

@@ -88,8 +88,12 @@ module OxTenderAbstract
             log_warn "Download attempt #{attempt} failed: #{last_error}"
           end
         rescue StandardError => e
-          last_error = e.message
-          log_error "Download attempt #{attempt} exception: #{last_error}"
+          last_error = begin
+            e.message.force_encoding('UTF-8').scrub
+          rescue StandardError
+            e.message.to_s
+          end
+          log_error "Download error details: #{e.class} - #{last_error}"
         end
 
         if attempt < MAX_RETRY_ATTEMPTS
@@ -128,34 +132,42 @@ module OxTenderAbstract
         unless response.is_a?(Net::HTTPSuccess)
           error_msg = "HTTP error: #{response.code} #{response.message}"
           if response.body && !response.body.empty?
-            # Log first part of response body for debugging
-            body_preview = response.body[0..500]
-            log_error "Response body preview: #{body_preview}"
-            error_msg += ". Response: #{body_preview[0..100]}"
+            # Log first part of response body for debugging - safely handle encoding
+            begin
+              body_preview = response.body.force_encoding('UTF-8').scrub[0..500]
+              log_error "Response body preview: #{body_preview}"
+              error_msg += ". Response: #{body_preview[0..100]}"
+            rescue StandardError => e
+              log_error "Response body encoding error: #{e.message}"
+              error_msg += '. Response body unreadable (encoding issue)'
+            end
           end
           return Result.failure(error_msg)
         end
 
-        # Check for download blocking message in successful response
-        if response.body&.include?('Скачивание архива по данной ссылке заблокировано')
-          if OxTenderAbstract.configuration.auto_wait_on_block
-            wait_time = OxTenderAbstract.configuration.block_wait_time
-            log_error "Archive download blocked. Auto-waiting for #{wait_time} seconds..."
-
-            # Показываем прогресс ожидания
-            show_wait_progress(wait_time)
-
-            log_info 'Wait completed, retrying download...'
-            # Рекурсивно повторяем попытку после ожидания
-            return download_to_memory(url)
-          else
-            log_error 'Archive download blocked for 10 minutes'
-            return Result.failure(
-              'Archive download blocked for 10 minutes',
-              error_type: :blocked,
-              retry_after: 600
-            )
+        # Check for download blocking message in successful response - safely handle encoding
+        begin
+          response_text = response.body&.force_encoding('UTF-8')&.scrub
+          if response_text&.include?('Скачивание архива по данной ссылке заблокировано')
+            if OxTenderAbstract.configuration.auto_wait_on_block
+              wait_time = OxTenderAbstract.configuration.block_wait_time
+              log_error "Archive download blocked. Auto-waiting for #{wait_time} seconds..."
+
+              # Показываем прогресс ожидания
+              show_wait_progress(wait_time)
+
+              log_info 'Wait completed, retrying download...'
+              # Рекурсивно повторяем попытку после ожидания
+              return download_to_memory(url)
+            else
+              # Возвращаем специальную ошибку блокировки для ручной обработки
+              return Result.failure('Archive download blocked for 10 minutes',
+                                    ArchiveBlockedError.new('Archive download blocked', 600))
+            end
           end
+        rescue StandardError => e
+          log_error "Encoding error when checking for blocking message: #{e.message}"
+          # Продолжаем обработку, так как это может быть просто архив
         end
 
         content = response.body

data/lib/oxtenderabstract/client.rb

@@ -76,7 +76,7 @@ module OxTenderAbstract
 
     # Search tenders with full workflow: API -> Archive -> Parse
     def search_tenders(org_region:, exact_date:, subsystem_type: DocumentTypes::DEFAULT_SUBSYSTEM,
-                       document_type: DocumentTypes::DEFAULT_DOCUMENT_TYPE)
+                       document_type: DocumentTypes::DEFAULT_DOCUMENT_TYPE, include_attachments: true)
       log_info "Starting tender search for region #{org_region}, date #{exact_date}, subsystem: #{subsystem_type}, type: #{document_type}"
 
       # Step 1: Get archive URLs from API
@@ -133,6 +133,15 @@ module OxTenderAbstract
             tender_data = parse_result.data[:content]
             next if tender_data[:reestr_number].nil? || tender_data[:reestr_number].empty?
 
+            # Extract attachments if requested
+            if include_attachments
+              attachments_result = extract_attachments_from_xml(file_data[:content])
+              if attachments_result.success?
+                tender_data[:attachments] = attachments_result.data[:attachments]
+                tender_data[:attachments_count] = attachments_result.data[:total_count]
+              end
+            end
+
             # Add metadata
             tender_data[:source_file] = file_name
             tender_data[:archive_url] = archive_url
@@ -240,7 +249,7 @@ module OxTenderAbstract
     # Позволяет продолжить загрузку с места паузы при блокировках API
     def search_tenders_with_resume(org_region:, exact_date:, subsystem_type: DocumentTypes::DEFAULT_SUBSYSTEM,
                                    document_type: DocumentTypes::DEFAULT_DOCUMENT_TYPE,
-                                   start_from_archive: 0, resume_state: nil)
+                                   start_from_archive: 0, resume_state: nil, include_attachments: true)
       log_info "Starting tender search with resume capability for region #{org_region}, date #{exact_date}"
       log_info "Starting from archive #{start_from_archive}" if start_from_archive > 0
 
@@ -330,6 +339,15 @@ module OxTenderAbstract
             tender_data = parse_result.data[:content]
             next if tender_data[:reestr_number].nil? || tender_data[:reestr_number].empty?
 
+            # Extract attachments if requested
+            if include_attachments
+              attachments_result = extract_attachments_from_xml(file_data[:content])
+              if attachments_result.success?
+                tender_data[:attachments] = attachments_result.data[:attachments]
+                tender_data[:attachments_count] = attachments_result.data[:total_count]
+              end
+            end
+
             # Add metadata
             tender_data[:source_file] = file_name
             tender_data[:archive_url] = archive_url

data/lib/oxtenderabstract/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OxTenderAbstract
-  VERSION = '0.9.3'
+  VERSION = '0.9.5'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ox-tender-abstract
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.9.5
 platform: ruby
 authors:
 - smolev
@@ -187,6 +187,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- SIDEKIQ_USAGE.md
 - lib/ox-tender-abstract.rb
 - lib/oxtenderabstract/archive_processor.rb
 - lib/oxtenderabstract/client.rb
@@ -222,7 +223,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.7.1
 specification_version: 4
 summary: Ruby library for working with Russian tender system (zakupki.gov.ru) SOAP
   API