ox-tender-abstract 0.9.2 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1e519805302809f117b67e75099300485fc5910038e6ab6012eb9a4343f8e0b
-  data.tar.gz: ffccc77f4305ca644cbe5128a2f1178e8ff30170b25180686fc3db12d5a19761
+  metadata.gz: cf4b74ab15f633cbfb3ad65d37a5fa900016e45e01f1bb300284b28609d805d7
+  data.tar.gz: 53564ab6b3af3c30998b241ee69a899875394833bdce28f2e2ad765edd81dfca
 SHA512:
-  metadata.gz: d062a1e8139143c3c86490c54b9e367f9e6053d27e2a981f8202b2496d187d56f11e2b1b2f101c1c3b9ae69045e5388f34365f9d88e77f480177603c8fd7a1f8
-  data.tar.gz: 57710ad7e471c7165d2878b7ffcbac5a2fbd6ffba10bc9c6c2a47af4015ca639df1d53f1cf89956858838dce7d18efdfca811a4d5f5bef2d53fb46c6a4fa14b7
+  metadata.gz: d122d953f825672d6b61d551f49c08a669eaeb4ef60b55d4c718c4d9dd9ee68e99d83a026745ff77451963ed30957a0ef684bcb67300574dab9f7e18e64e22c7
+  data.tar.gz: 7396189e5e44a5c3fa5b9e988b6ed0394072b1b7fadacfed60df6ebe36afd741685efa3f46978912028c561f4c0aa5820a85560bf5222134fab840815a88c25a

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [0.9.4] - 2025-07-28
+
+- include_attachments
+
+## [0.9.3] - 2025-07-27
+
+- Added support for parsing tender documents
+- Added support for parsing contract documents
+- Added support for parsing organization documents
+- Added support for parsing generic documents
+- Added support for parsing attachments
+- Added support for parsing tender documents
+- Added support for parsing contract documents
+- Added support for parsing organization documents
+
 ## [0.9.0] - 2025-07-15
 
 - Initial release

data/README.md

@@ -273,6 +273,41 @@ puts result.data[:total_archives] # => 6
 # Processing typically takes 10-15 seconds for a full day's data
 ```
 
+## Error Handling
+
+The library uses the `Result` pattern for error handling:
+
+```ruby
+result = OxTenderAbstract.search_tenders(org_region: '77', exact_date: '2024-01-01')
+
+if result.success?
+  puts "Found tenders: #{result.data[:tenders].size}"
+else
+  puts "Error: #{result.error}"
+  
+  # Check error type for special handling
+  if result.metadata[:error_type] == :blocked
+    retry_after = result.metadata[:retry_after] || 600
+    puts "API blocked for #{retry_after} seconds"
+  end
+end
+```
+
+### Handling API Blocks
+
+When making frequent requests, the API may block archive downloads for 10 minutes. The library automatically detects such blocks:
+
+```ruby
+result = OxTenderAbstract.search_tenders(org_region: '77', exact_date: '2024-01-01')
+
+if result.failure? && result.metadata[:error_type] == :blocked
+  retry_after = result.metadata[:retry_after] # 600 seconds (10 minutes)
+  puts "Download blocked, retry in #{retry_after} seconds"
+end
+```
+
+For detailed guidance on using with Sidekiq background jobs, see [SIDEKIQ_USAGE.md](SIDEKIQ_USAGE.md).
+
 ## Requirements
 
 - Ruby >= 3.0.0

data/lib/ox-tender-abstract.rb

@@ -1,39 +1,178 @@
 # frozen_string_literal: true
 
 require_relative 'oxtenderabstract/version'
-require_relative 'oxtenderabstract/logger'
+require_relative 'oxtenderabstract/configuration'
 require_relative 'oxtenderabstract/errors'
+require_relative 'oxtenderabstract/logger'
 require_relative 'oxtenderabstract/result'
 require_relative 'oxtenderabstract/document_types'
-require_relative 'oxtenderabstract/configuration'
-require_relative 'oxtenderabstract/xml_parser'
 require_relative 'oxtenderabstract/archive_processor'
+require_relative 'oxtenderabstract/xml_parser'
 require_relative 'oxtenderabstract/client'
 
 # Main module for OxTenderAbstract library
 module OxTenderAbstract
   class Error < StandardError; end
 
-  # Convenience method to create a new client
-  def self.client(token: nil)
-    Client.new(token: token)
-  end
+  class << self
+    def configure
+      yield(configuration)
+    end
 
-  # Search tenders by region and date (convenience method)
-  def self.search_tenders(org_region:, exact_date:, token: nil, **options)
-    client = Client.new(token: token)
-    client.search_tenders(org_region: org_region, exact_date: exact_date, **options)
-  end
+    def configuration
+      @configuration ||= Configuration.new
+    end
 
-  # Enhanced search tenders with detailed information (convenience method)
-  def self.enhanced_search_tenders(org_region:, exact_date:, token: nil, **options)
-    client = Client.new(token: token)
-    client.enhanced_search_tenders(org_region: org_region, exact_date: exact_date, **options)
-  end
+    def reset_configuration!
+      @configuration = nil
+    end
+
+    # 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, 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,
+        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, include_attachments: true)
+      # Default subsystems to search
+      subsystems ||= %w[PRIZ RPEC RPGZ BTK UR RGK OD223 RD223]
+
+      client = Client.new
+      all_results = {}
+      total_tenders = []
+      total_archives = 0
+
+      subsystems.each do |subsystem_type|
+        # Get appropriate document types for this subsystem
+        available_types = DocumentTypes.document_types_for_subsystem(subsystem_type)
+        test_types = document_types || [available_types.first] # Test first type by default
+
+        subsystem_results = {
+          subsystem: subsystem_type,
+          description: DocumentTypes.description_for_subsystem(subsystem_type),
+          tenders: [],
+          archives: 0,
+          errors: []
+        }
+
+        test_types.each do |doc_type|
+          result = client.search_tenders(
+            org_region: org_region,
+            exact_date: exact_date,
+            subsystem_type: subsystem_type,
+            document_type: doc_type,
+            include_attachments: include_attachments
+          )
+
+          if result.success?
+            tenders = result.data[:tenders] || []
+            archives = result.data[:total_archives] || 0
+
+            subsystem_results[:tenders].concat(tenders)
+            subsystem_results[:archives] += archives
+            total_archives += archives
+
+            # Add subsystem info to each tender
+            tenders.each do |tender|
+              tender[:subsystem_type] = subsystem_type
+              tender[:subsystem_description] = DocumentTypes.description_for_subsystem(subsystem_type)
+              tender[:document_type_used] = doc_type
+            end
+
+            total_tenders.concat(tenders)
+          else
+            subsystem_results[:errors] << "#{doc_type}: #{result.error}"
+          end
+        rescue StandardError => e
+          subsystem_results[:errors] << "#{doc_type}: #{e.message}"
+        end
+
+        all_results[subsystem_type] = subsystem_results
+      end
+
+      Result.success({
+                       tenders: total_tenders,
+                       total_archives: total_archives,
+                       subsystem_results: all_results,
+                       search_params: {
+                         org_region: org_region,
+                         exact_date: exact_date,
+                         subsystems_searched: subsystems.size
+                       },
+                       processed_at: Time.now
+                     })
+    end
+
+    # Get documents by registry number across subsystems
+    def get_docs_by_reestr_number(reestr_number:, subsystem_type: DocumentTypes::DEFAULT_SUBSYSTEM)
+      client = Client.new
+      client.get_docs_by_reestr_number(
+        reestr_number: reestr_number,
+        subsystem_type: subsystem_type
+      )
+    end
+
+    # Enhanced search with detailed information extraction
+    def enhanced_search_tenders(org_region:, exact_date:, subsystem_type: DocumentTypes::DEFAULT_SUBSYSTEM,
+                                document_type: DocumentTypes::DEFAULT_DOCUMENT_TYPE,
+                                include_attachments: true)
+      client = Client.new
+      client.enhanced_search_tenders(
+        org_region: org_region,
+        exact_date: exact_date,
+        subsystem_type: subsystem_type,
+        document_type: document_type,
+        include_attachments: include_attachments
+      )
+    end
 
-  # Get documents by registry number (convenience method)
-  def self.get_docs_by_reestr_number(reestr_number:, token: nil, **options)
-    client = Client.new(token: token)
-    client.get_docs_by_reestr_number(reestr_number: reestr_number, **options)
+    # 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,
+                                      include_attachments: true)
+      client = Client.new
+      
+      # Если есть состояние для продолжения
+      if resume_state
+        start_from = resume_state[:next_archive_index] || 0
+        client.search_tenders_with_resume(
+          org_region: org_region,
+          exact_date: exact_date,
+          subsystem_type: subsystem_type,
+          document_type: document_type,
+          start_from_archive: start_from,
+          resume_state: resume_state,
+          include_attachments: include_attachments
+        )
+      else
+        # Используем обычный метод если авто-ожидание включено
+        if configuration.auto_wait_on_block
+          client.search_tenders(
+            org_region: org_region,
+            exact_date: exact_date,
+            subsystem_type: subsystem_type,
+            document_type: document_type,
+            include_attachments: include_attachments
+          )
+        else
+          # Используем метод с возможностью продолжения
+          client.search_tenders_with_resume(
+            org_region: org_region,
+            exact_date: exact_date,
+            subsystem_type: subsystem_type,
+            document_type: document_type,
+            include_attachments: include_attachments
+          )
+        end
+      end
+    end
   end
 end

data/lib/oxtenderabstract/archive_processor.rb

@@ -13,6 +13,8 @@ module OxTenderAbstract
     include ContextualLogger
 
     MAX_FILE_SIZE_BYTES = 100 * 1024 * 1024 # 100 MB in bytes
+    MAX_RETRY_ATTEMPTS = 3
+    RETRY_DELAY_SECONDS = 2
 
     def initialize
       # Archive processor initialization
@@ -23,8 +25,8 @@ module OxTenderAbstract
       return Result.failure('Empty archive URL') if archive_url.nil? || archive_url.empty?
 
       begin
-        # Download archive to memory
-        download_result = download_to_memory(archive_url)
+        # Download archive to memory with retry logic
+        download_result = download_with_retry(archive_url)
         return download_result if download_result.failure?
 
         content = download_result.data[:content]
@@ -56,15 +58,52 @@ module OxTenderAbstract
                            file_count: zip_result.size
                          })
         else
+          # Log first bytes for debugging
+          log_error "Unknown archive format. First 10 bytes: #{content[0..9].unpack1('H*')}"
           Result.failure('Unknown archive format (not GZIP and not ZIP)')
         end
       rescue StandardError => e
+        log_error "Archive processing error: #{e.message}"
+        log_error e.backtrace.first(3).join("\n") if e.backtrace
         Result.failure("Archive processing error: #{e.message}")
       end
     end
 
     private
 
+    def download_with_retry(archive_url)
+      attempt = 1
+      last_error = nil
+
+      while attempt <= MAX_RETRY_ATTEMPTS
+        begin
+          log_info "Download attempt #{attempt}/#{MAX_RETRY_ATTEMPTS} for archive"
+          result = download_to_memory(archive_url)
+
+          if result.success?
+            log_info "Download successful on attempt #{attempt}"
+            return result
+          else
+            last_error = result.error
+            log_warn "Download attempt #{attempt} failed: #{last_error}"
+          end
+        rescue StandardError => e
+          last_error = e.message
+          log_error "Download attempt #{attempt} exception: #{last_error}"
+        end
+
+        if attempt < MAX_RETRY_ATTEMPTS
+          sleep_time = RETRY_DELAY_SECONDS * attempt
+          log_info "Waiting #{sleep_time} seconds before retry..."
+          sleep(sleep_time)
+        end
+
+        attempt += 1
+      end
+
+      Result.failure("Download failed after #{MAX_RETRY_ATTEMPTS} attempts. Last error: #{last_error}")
+    end
+
     def download_to_memory(url)
       begin
         uri = URI.parse(url)
@@ -81,12 +120,42 @@ module OxTenderAbstract
         request['User-Agent'] = "OxTenderAbstract/#{OxTenderAbstract::VERSION}"
         request['individualPerson_token'] = OxTenderAbstract.configuration.token
 
-        log_debug "Downloading archive from: #{url}"
+        log_debug "Downloading archive from: #{url[0..100]}..."
 
         response = http.request(request)
 
+        # Enhanced error handling with response details
         unless response.is_a?(Net::HTTPSuccess)
-          return Result.failure("HTTP error: #{response.code} #{response.message}")
+          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]}"
+          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
+            )
+          end
         end
 
         content = response.body
@@ -96,7 +165,9 @@ module OxTenderAbstract
           return Result.failure("Archive too large: #{size} bytes (max: #{MAX_FILE_SIZE_BYTES})")
         end
 
-        log_debug "Downloaded archive: #{size} bytes"
+        return Result.failure('Empty archive downloaded') if size == 0
+
+        log_debug "Downloaded archive: #{size} bytes, content-type: #{response['content-type']}"
 
         Result.success({
                          content: content,
@@ -106,6 +177,7 @@ module OxTenderAbstract
       rescue SocketError, Timeout::Error => e
         Result.failure("Network error: #{e.message}")
       rescue StandardError => e
+        log_error "Download error details: #{e.class} - #{e.message}"
         Result.failure("Download error: #{e.message}")
       end
     end
@@ -116,6 +188,10 @@ module OxTenderAbstract
       http.verify_mode = OxTenderAbstract.configuration.ssl_verify ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
       http.open_timeout = OxTenderAbstract.configuration.timeout_open
       http.read_timeout = OxTenderAbstract.configuration.timeout_read
+
+      # Add debug logging for HTTP client configuration
+      log_debug "HTTP client config: SSL=#{http.use_ssl?}, verify=#{http.verify_mode}, open_timeout=#{http.open_timeout}, read_timeout=#{http.read_timeout}"
+
       http
     end
 
@@ -126,19 +202,23 @@ module OxTenderAbstract
       decompressed_content = gz.read
       gz.close
 
+      log_debug "GZIP decompression: #{gzip_content.bytesize} -> #{decompressed_content.bytesize} bytes"
+
       Result.success({
                        content: decompressed_content,
                        compressed_size: gzip_content.bytesize,
                        decompressed_size: decompressed_content.bytesize
                      })
     rescue Zlib::GzipFile::Error => e
+      log_error "GZIP decompression error: #{e.message}"
       Result.failure("GZIP decompression error: #{e.message}")
     rescue StandardError => e
+      log_error "Decompression error: #{e.message}"
       Result.failure("Decompression error: #{e.message}")
     end
 
     def extract_zip_from_memory(zip_content)
-      log_debug 'Extracting ZIP archive from memory'
+      log_debug "Extracting ZIP archive from memory (#{zip_content.bytesize} bytes)"
 
       files = {}
       zip_io = StringIO.new(zip_content)
@@ -149,23 +229,63 @@ module OxTenderAbstract
 
           log_debug "Extracting file: #{entry.name} (#{entry.size} bytes)"
 
-          content = entry.get_input_stream.read
-
-          files[entry.name] = {
-            content: content,
-            size: entry.size,
-            compressed_size: entry.compressed_size,
-            crc: entry.crc
-          }
+          begin
+            content = entry.get_input_stream.read
+
+            files[entry.name] = {
+              content: content,
+              size: entry.size,
+              compressed_size: entry.compressed_size,
+              crc: entry.crc
+            }
+          rescue StandardError => e
+            log_error "Error extracting file #{entry.name}: #{e.message}"
+            # Continue with other files instead of failing completely
+          end
         end
       end
 
       log_debug "Extracted #{files.size} files from ZIP archive"
       files
     rescue Zip::Error => e
+      log_error "ZIP extraction error: #{e.message}"
       raise ArchiveError, "ZIP extraction error: #{e.message}"
     rescue StandardError => e
+      log_error "Archive extraction error: #{e.message}"
+      log_error e.backtrace.first(3).join("\n") if e.backtrace
       raise ArchiveError, "Archive extraction error: #{e.message}"
     end
+
+    # Show wait progress during API block
+    def show_wait_progress(total_seconds)
+      return if total_seconds <= 0
+
+      log_info "Waiting #{total_seconds} seconds for API block to expire..."
+
+      # Показываем прогресс каждые 30 секунд для больших интервалов
+      if total_seconds > 60
+        intervals = [30, 60, 120, 180, 300].select { |i| i < total_seconds }
+
+        intervals.each do |interval|
+          sleep(interval)
+          remaining = total_seconds - interval
+          total_seconds = remaining
+
+          if remaining > 60
+            log_info "Still waiting... #{remaining} seconds remaining (#{(remaining / 60.0).round(1)} minutes)"
+          else
+            log_info "Still waiting... #{remaining} seconds remaining"
+          end
+        end
+
+        # Ждем оставшееся время
+        sleep(total_seconds) if total_seconds > 0
+      else
+        # Для коротких интервалов просто ждем
+        sleep(total_seconds)
+      end
+
+      log_info 'Wait period completed!'
+    end
   end
 end

data/lib/oxtenderabstract/client.rb

@@ -76,8 +76,8 @@ 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)
-      log_info "Starting tender search for region #{org_region}, date #{exact_date}"
+                       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
       api_result = get_docs_by_region(
@@ -94,44 +94,78 @@ module OxTenderAbstract
 
       log_info "Found #{archive_urls.size} archives to process"
 
-      # Step 2: Process each archive
+      # Step 2: Process each archive with error resilience
       all_tenders = []
       total_files = 0
+      processed_archives = 0
+      failed_archives = 0
 
       archive_urls.each_with_index do |archive_url, index|
         log_info "Processing archive #{index + 1}/#{archive_urls.size}"
 
-        archive_result = download_archive_data(archive_url)
-        next if archive_result.failure?
+        begin
+          archive_result = download_archive_data(archive_url)
 
-        files = archive_result.data[:files]
-        total_files += files.size
+          if archive_result.failure?
+            log_error "Failed to download archive #{index + 1}: #{archive_result.error}"
+            failed_archives += 1
+            next
+          end
 
-        # Step 3: Parse XML files from archive
-        xml_files = files.select { |name, _| name.downcase.end_with?('.xml') }
+          processed_archives += 1
+          files = archive_result.data[:files]
+          total_files += files.size
 
-        xml_files.each do |file_name, file_data|
-          parse_result = parse_xml_document(file_data[:content])
-          next if parse_result.failure?
-          next unless parse_result.data[:document_type] == :tender
+          # Step 3: Parse XML files from archive
+          xml_files = files.select { |name, _| name.downcase.end_with?('.xml') }
+          log_debug "Found #{xml_files.size} XML files in archive #{index + 1}"
 
-          tender_data = parse_result.data[:content]
-          next if tender_data[:reestr_number].nil? || tender_data[:reestr_number].empty?
+          xml_files.each do |file_name, file_data|
+            parse_result = parse_xml_document(file_data[:content])
 
-          # Add metadata
-          tender_data[:source_file] = file_name
-          tender_data[:archive_url] = archive_url
-          tender_data[:processed_at] = Time.now
+            if parse_result.failure?
+              log_debug "Failed to parse #{file_name}: #{parse_result.error}"
+              next
+            end
 
-          all_tenders << tender_data
+            next unless parse_result.data[:document_type] == :tender
+
+            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
+            tender_data[:processed_at] = Time.now
+
+            all_tenders << tender_data
+          rescue StandardError => e
+            log_error "Error processing file #{file_name}: #{e.message}"
+            # Continue with other files
+          end
+        rescue StandardError => e
+          log_error "Critical error processing archive #{index + 1}: #{e.message}"
+          failed_archives += 1
+          # Continue with other archives
         end
       end
 
-      log_info "Search completed. Found #{all_tenders.size} tenders in #{total_files} files"
+      log_info "Search completed. Processed: #{processed_archives}/#{archive_urls.size} archives, Failed: #{failed_archives}, Found #{all_tenders.size} tenders in #{total_files} files"
 
       Result.success({
                        tenders: all_tenders,
                        total_archives: archive_urls.size,
+                       processed_archives: processed_archives,
+                       failed_archives: failed_archives,
                        total_files: total_files,
                        processed_at: Time.now
                      })
@@ -211,6 +245,140 @@ module OxTenderAbstract
                      })
     end
 
+    # Search tenders with automatic resume capability
+    # Позволяет продолжить загрузку с места паузы при блокировках 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, 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
+
+      # Восстанавливаем состояние если есть
+      if resume_state
+        log_info "Resuming from previous state: #{resume_state[:processed_archives]} archives processed"
+        all_tenders = resume_state[:tenders] || []
+        total_files = resume_state[:total_files] || 0
+        processed_archives = resume_state[:processed_archives] || 0
+        failed_archives = resume_state[:failed_archives] || 0
+        archive_urls = resume_state[:archive_urls]
+      else
+        # Step 1: Get archive URLs from API
+        api_result = get_docs_by_region(
+          org_region: org_region,
+          subsystem_type: subsystem_type,
+          document_type: document_type,
+          exact_date: exact_date
+        )
+
+        return api_result if api_result.failure?
+
+        archive_urls = api_result.data[:archive_urls]
+        return Result.success({ tenders: [], total_archives: 0, total_files: 0 }) if archive_urls.empty?
+
+        all_tenders = []
+        total_files = 0
+        processed_archives = 0
+        failed_archives = 0
+      end
+
+      log_info "Found #{archive_urls.size} archives to process (starting from #{start_from_archive})"
+
+      # Step 2: Process archives starting from specified position
+      (start_from_archive...archive_urls.size).each do |index|
+        archive_url = archive_urls[index]
+        log_info "Processing archive #{index + 1}/#{archive_urls.size}"
+
+        begin
+          archive_result = download_archive_data(archive_url)
+
+          if archive_result.failure?
+            # Проверяем, была ли блокировка с автоматическим ожиданием
+            if archive_result.metadata[:error_type] == :blocked &&
+               !OxTenderAbstract.configuration.auto_wait_on_block
+              # Возвращаем состояние для возможности продолжения
+              resume_state = {
+                tenders: all_tenders,
+                total_files: total_files,
+                processed_archives: processed_archives,
+                failed_archives: failed_archives,
+                archive_urls: archive_urls,
+                next_archive_index: index
+              }
+
+              return Result.failure(
+                "Archive download blocked, can resume from archive #{index + 1}",
+                error_type: :blocked,
+                retry_after: 600,
+                resume_state: resume_state
+              )
+            else
+              log_error "Failed to download archive #{index + 1}: #{archive_result.error}"
+              failed_archives += 1
+              next
+            end
+          end
+
+          processed_archives += 1
+          files = archive_result.data[:files]
+          total_files += files.size
+
+          # Step 3: Parse XML files from archive
+          xml_files = files.select { |name, _| name.downcase.end_with?('.xml') }
+          log_debug "Found #{xml_files.size} XML files in archive #{index + 1}"
+
+          xml_files.each do |file_name, file_data|
+            parse_result = parse_xml_document(file_data[:content])
+
+            if parse_result.failure?
+              log_debug "Failed to parse #{file_name}: #{parse_result.error}"
+              next
+            end
+
+            next unless parse_result.data[:document_type] == :tender
+
+            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
+            tender_data[:processed_at] = Time.now
+            tender_data[:archive_index] = index
+
+            all_tenders << tender_data
+          rescue StandardError => e
+            log_error "Error processing file #{file_name}: #{e.message}"
+            # Continue with other files
+          end
+        rescue StandardError => e
+          log_error "Critical error processing archive #{index + 1}: #{e.message}"
+          failed_archives += 1
+          # Continue with other archives
+        end
+      end
+
+      log_info "Search completed. Processed: #{processed_archives}/#{archive_urls.size} archives, Failed: #{failed_archives}, Found #{all_tenders.size} tenders in #{total_files} files"
+
+      Result.success({
+                       tenders: all_tenders,
+                       total_archives: archive_urls.size,
+                       processed_archives: processed_archives,
+                       failed_archives: failed_archives,
+                       total_files: total_files,
+                       processed_at: Time.now,
+                       completed: true
+                     })
+    end
+
     private
 
     def validate_token!

data/lib/oxtenderabstract/configuration.rb

@@ -5,7 +5,8 @@ require 'logger'
 module OxTenderAbstract
   # Configuration for the library
   class Configuration
-    attr_accessor :token, :timeout_open, :timeout_read, :ssl_verify
+    attr_accessor :token, :timeout_open, :timeout_read, :ssl_verify,
+                  :auto_wait_on_block, :block_wait_time, :max_wait_time
     attr_writer :wsdl_url, :logger
 
     def initialize
@@ -15,6 +16,9 @@ module OxTenderAbstract
       @ssl_verify = false
       @wsdl_url = nil  # Will be set later
       @logger = nil    # Will be set later
+      @auto_wait_on_block = true  # Автоматически ждать при блокировке
+      @block_wait_time = 610      # Время ожидания при блокировке (10 мин + 10 сек)
+      @max_wait_time = 900        # Максимальное время ожидания (15 мин)
     end
 
     def wsdl_url

data/lib/oxtenderabstract/document_types.rb

@@ -16,8 +16,8 @@ module OxTenderAbstract
       CONTRACT_EXECUTION_REPORT TENDER_NOTICE TENDER_DOCUMENTATION
     ].freeze
 
-    # Electronic notification types
-    ELECTRONIC_NOTIFICATION_TYPES = %w[
+    # Electronic notification types for 44-FZ
+    ELECTRONIC_NOTIFICATION_TYPES_44FZ = %w[
       epNotificationEF2020 epNotificationEF epNotificationOK2020
       epNotificationEP2020 epNotificationZK2020 epNotificationZP2020
       epNotificationISM2020 fcsNotificationEF fcsNotificationOK
@@ -25,10 +25,80 @@ module OxTenderAbstract
       fcsNotificationISM fcsPlacement fcsPlacementResult
     ].freeze
 
+    # Electronic notification types for 223-FZ
+    ELECTRONIC_NOTIFICATION_TYPES_223FZ = %w[
+      epNotification223 notification223 purchaseNotice223
+      purchaseNoticeEA223 purchaseNoticeZK223 purchaseNoticeZP223
+      purchaseNoticeOK223 purchaseNoticeIS223 contractNotice223
+      contractExecutionNotice223 purchasePlan223
+    ].freeze
+
+    # Electronic notification types for regional and municipal
+    ELECTRONIC_NOTIFICATION_TYPES_REGIONAL = %w[
+      epNotificationRP epNotificationRPGZ notificationRP
+      notificationRPGZ purchaseNoticeRP purchaseNoticeRPGZ
+      contractNoticeRP contractNoticeRPGZ
+    ].freeze
+
+    # All supported electronic notification types
+    ELECTRONIC_NOTIFICATION_TYPES = (
+      ELECTRONIC_NOTIFICATION_TYPES_44FZ +
+      ELECTRONIC_NOTIFICATION_TYPES_223FZ +
+      ELECTRONIC_NOTIFICATION_TYPES_REGIONAL
+    ).freeze
+
     # Default settings
     DEFAULT_SUBSYSTEM = 'PRIZ'
     DEFAULT_DOCUMENT_TYPE = 'epNotificationEF2020'
 
+    # Subsystem descriptions
+    SUBSYSTEM_DESCRIPTIONS = {
+      'PRIZ' => '44-ФЗ - Основные закупки федеральных органов',
+      'OD223' => '223-ФЗ - Закупки отдельных видов юридических лиц',
+      'RD223' => '223-ФЗ - Реестр договоров',
+      'RPEC' => 'Закупки субъектов РФ',
+      'RPGZ' => 'Муниципальные закупки',
+      'RGK' => 'Закупки государственных корпораций',
+      'BTK' => 'Закупки бюджетных, автономных учреждений',
+      'UR' => 'Закупки субъектов естественных монополий',
+      'RJ' => 'Закупки для нужд судебной системы',
+      'RDI' => 'Закупки для нужд дошкольных образовательных учреждений',
+      'RPKLKP' => 'Закупки для нужд подведомственных Калининградской области',
+      'RPNZ' => 'Закупки для нужд образовательных учреждений НЗО',
+      'EA' => 'Электронные аукционы',
+      'REC' => 'Реестр недобросовестных поставщиков',
+      'RPP' => 'Реестр поставщиков',
+      'RVP' => 'Реестр внутренних поставщиков',
+      'RRK' => 'Реестр результатов контроля',
+      'RRA' => 'Реестр результатов аудита',
+      'RNP' => 'Реестр нарушений при проведении закупок',
+      'RKPO' => 'Реестр контрольно-проверочных организаций'
+    }.freeze
+
+    # Get appropriate document types for subsystem
+    def self.document_types_for_subsystem(subsystem_type)
+      case subsystem_type
+      when 'PRIZ', 'RPEC', 'RPGZ', 'RGK', 'BTK', 'UR', 'RJ', 'RDI'
+        ELECTRONIC_NOTIFICATION_TYPES_44FZ
+      when 'OD223', 'RD223'
+        ELECTRONIC_NOTIFICATION_TYPES_223FZ + ELECTRONIC_NOTIFICATION_TYPES_44FZ
+      when /RP/
+        ELECTRONIC_NOTIFICATION_TYPES_REGIONAL + ELECTRONIC_NOTIFICATION_TYPES_44FZ
+      else
+        ELECTRONIC_NOTIFICATION_TYPES_44FZ
+      end
+    end
+
+    # Check if subsystem supports document type
+    def self.subsystem_supports_document_type?(subsystem_type, document_type)
+      document_types_for_subsystem(subsystem_type).include?(document_type)
+    end
+
+    # Get description for subsystem
+    def self.description_for_subsystem(subsystem_type)
+      SUBSYSTEM_DESCRIPTIONS[subsystem_type] || "Подсистема #{subsystem_type}"
+    end
+
     # API configuration
     API_CONFIG = {
       wsdl: 'https://int44.zakupki.gov.ru/eis-integration/services/getDocsIP?wsdl',

data/lib/oxtenderabstract/errors.rb

@@ -7,18 +7,30 @@ module OxTenderAbstract
   # Configuration related errors
   class ConfigurationError < Error; end
 
-  # Network related errors
-  class NetworkError < Error; end
+  # API related errors
+  class ApiError < Error; end
 
-  # SOAP API related errors
-  class SoapError < Error; end
+  # Archive processing errors
+  class ArchiveError < Error; end
 
-  # XML parsing related errors
+  # XML parsing errors
   class ParseError < Error; end
 
-  # Archive processing related errors
-  class ArchiveError < Error; end
+  # Network related errors
+  class NetworkError < Error; end
+
+  # Archive download blocked error (10 minute block)
+  class ArchiveBlockedError < ArchiveError
+    attr_reader :blocked_until, :retry_after_seconds
+
+    def initialize(message = 'Archive download blocked', retry_after_seconds = 600)
+      super(message)
+      @retry_after_seconds = retry_after_seconds
+      @blocked_until = Time.now + retry_after_seconds
+    end
 
-  # Authentication related errors
-  class AuthenticationError < Error; end
+    def can_retry_at
+      @blocked_until
+    end
+  end
 end

data/lib/oxtenderabstract/version.rb

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

data/lib/oxtenderabstract/xml_parser.rb

@@ -486,36 +486,57 @@ module OxTenderAbstract
       total_sum = nil
 
       begin
-        # Find purchase objects nodes - use more defensive approach
+        # Find purchase objects nodes - including drug and non-drug objects
+        # Regular purchase objects
         purchase_object_nodes = doc.xpath(
           '//ns5:purchaseObjectsInfo//ns4:purchaseObject | //purchaseObjectsInfo//purchaseObject', namespaces
         )
 
+        # Drug purchase objects (лекарственные препараты)
+        drug_object_nodes = doc.xpath(
+          '//ns5:drugPurchaseObjectsInfo//ns4:drugPurchaseObjectInfo | //drugPurchaseObjectsInfo//drugPurchaseObjectInfo', namespaces
+        )
+
+        # Process regular purchase objects
         purchase_objects = purchase_object_nodes.map do |object_node|
           extract_purchase_object_data(object_node, namespaces)
         end.compact
 
-        # Extract total sum from purchaseObjectsInfo
+        # Process drug purchase objects
+        drug_objects = drug_object_nodes.map do |drug_node|
+          extract_drug_purchase_object_data(drug_node, namespaces)
+        end.compact
+
+        # Combine all objects
+        all_objects = purchase_objects + drug_objects
+
+        # Extract total sum from various sources
         total_sum = extract_price_from_text(find_text_with_namespaces(doc, [
                                                                         '//ns5:purchaseObjectsInfo//ns4:totalSum',
                                                                         '//purchaseObjectsInfo//totalSum',
                                                                         '//ns5:notDrugPurchaseObjectsInfo/ns4:totalSum',
-                                                                        '//notDrugPurchaseObjectsInfo/totalSum'
+                                                                        '//notDrugPurchaseObjectsInfo/totalSum',
+                                                                        '//ns5:drugPurchaseObjectsInfo/ns4:total',
+                                                                        '//drugPurchaseObjectsInfo/total'
                                                                       ], namespaces))
 
         # Extract quantity undefined flag
         quantity_undefined = find_text_with_namespaces(doc, [
                                                          '//ns5:purchaseObjectsInfo//ns5:quantityUndefined',
-                                                         '//purchaseObjectsInfo//quantityUndefined'
+                                                         '//purchaseObjectsInfo//quantityUndefined',
+                                                         '//ns5:drugPurchaseObjectsInfo//ns5:quantityUndefined',
+                                                         '//drugPurchaseObjectsInfo//quantityUndefined'
                                                        ], namespaces) == 'true'
 
-        return {} if purchase_objects.empty? && total_sum.nil?
+        return {} if all_objects.empty? && total_sum.nil?
 
         {
-          objects: purchase_objects,
-          objects_count: purchase_objects.size,
+          objects: all_objects,
+          objects_count: all_objects.size,
           total_sum: total_sum,
-          quantity_undefined: quantity_undefined
+          quantity_undefined: quantity_undefined,
+          drug_objects_count: drug_objects.size,
+          regular_objects_count: purchase_objects.size
         }.compact
       rescue StandardError => e
         log_debug "Error extracting purchase objects: #{e.message}"
@@ -632,6 +653,106 @@ module OxTenderAbstract
       object_data.compact
     end
 
+    def extract_drug_purchase_object_data(drug_node, namespaces)
+      # Extract data from drug purchase object info
+      drug_data = {
+        sid: extract_text_from_node(drug_node, './/ns4:sid | .//sid'),
+        external_sid: extract_text_from_node(drug_node, './/ns4:externalSid | .//externalSid'),
+        name: extract_text_from_node(drug_node, './/ns4:name | .//name'),
+        price: extract_price_from_text(extract_text_from_node(drug_node, './/ns4:price | .//price')),
+        quantity: extract_text_from_node(drug_node, './/ns4:quantity/ns4:value | .//quantity/value')&.to_i,
+        sum: extract_price_from_text(extract_text_from_node(drug_node, './/ns4:sum | .//sum')),
+        type: 'drug', # Mark as drug object
+        hierarchy_type: extract_text_from_node(drug_node, './/ns4:hierarchyType | .//hierarchyType')
+      }
+
+      # Extract INN (International Nonproprietary Name) for drugs
+      inn_node = drug_node.at_xpath('.//ns4:INN | .//INN', namespaces)
+      if inn_node
+        drug_data[:inn] = {
+          code: extract_text_from_node(inn_node, './/ns2:code | .//code'),
+          name: extract_text_from_node(inn_node, './/ns2:name | .//name')
+        }
+      end
+
+      # Extract dosage form information
+      dosage_form_node = drug_node.at_xpath('.//ns4:dosageForm | .//dosageForm', namespaces)
+      if dosage_form_node
+        drug_data[:dosage_form] = {
+          code: extract_text_from_node(dosage_form_node, './/ns2:code | .//code'),
+          name: extract_text_from_node(dosage_form_node, './/ns2:name | .//name')
+        }
+      end
+
+      # OKPD2 information for drugs
+      okpd2_node = drug_node.at_xpath('.//ns4:OKPD2 | .//OKPD2', namespaces)
+      if okpd2_node
+        drug_data[:okpd2] = {
+          code: extract_text_from_node(okpd2_node, './/ns2:OKPDCode | .//OKPDCode'),
+          name: extract_text_from_node(okpd2_node, './/ns2:OKPDName | .//OKPDName')
+        }
+      end
+
+      # OKEI information (units of measurement)
+      okei_node = drug_node.at_xpath('.//ns4:OKEI | .//OKEI', namespaces)
+      if okei_node
+        drug_data[:okei] = {
+          code: extract_text_from_node(okei_node, './/ns2:code | .//code'),
+          national_code: extract_text_from_node(okei_node, './/ns2:nationalCode | .//nationalCode'),
+          name: extract_text_from_node(okei_node, './/ns2:name | .//name')
+        }
+      end
+
+      # Extract characteristics for drugs
+      characteristics_nodes = drug_node.xpath(
+        './/ns4:characteristics//ns4:characteristicsUsingReferenceInfo | .//characteristics//characteristicsUsingReferenceInfo', namespaces
+      )
+      characteristics_nodes += drug_node.xpath(
+        './/ns4:characteristics//ns4:characteristicsUsingTextForm | .//characteristics//characteristicsUsingTextForm', namespaces
+      )
+
+      if characteristics_nodes.any?
+        characteristics_details = characteristics_nodes.map do |char_node|
+          char_data = {
+            name: extract_text_from_node(char_node, './/ns4:name | .//name'),
+            type: extract_text_from_node(char_node, './/ns4:type | .//type')
+          }
+
+          # Extract values from text form characteristics
+          values_nodes = char_node.xpath('.//ns4:values/ns4:value | .//values/value', namespaces)
+          if values_nodes.any?
+            char_data[:values] = values_nodes.map do |value_node|
+              extract_text_from_node(value_node, './/ns4:qualityDescription | .//qualityDescription') ||
+                extract_text_from_node(value_node, './/ns4:textValue | .//textValue')
+            end.compact
+          end
+
+          char_data
+        end
+
+        drug_data[:characteristics] = {
+          count: characteristics_nodes.size,
+          details: characteristics_details
+        }
+      end
+
+      # Determine the product name
+      product_name = if drug_data[:name] && !drug_data[:name].empty?
+                       drug_data[:name]
+                     elsif drug_data[:inn] && drug_data[:inn][:name] && !drug_data[:inn][:name].empty?
+                       drug_data[:inn][:name]
+                     elsif drug_data[:okpd2] && drug_data[:okpd2][:name] && !drug_data[:okpd2][:name].empty?
+                       drug_data[:okpd2][:name]
+                     else
+                       'Unknown drug'
+                     end
+
+      drug_data[:product_name] = product_name
+      drug_data[:name_type] = 'drug_name'
+
+      drug_data.compact
+    end
+
     private
 
     def determine_name_type(name)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ox-tender-abstract
 version: !ruby/object:Gem::Version
-  version: 0.9.2
+  version: 0.9.4
 platform: ruby
 authors:
 - smolev