ox-tender-abstract 0.0.1

data/lib/oxtenderabstract/archive_processor.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "openssl"
+require "zlib"
+require "stringio"
+require "zip"
+
+module OxTenderAbstract
+  # Archive processor for downloading and extracting archive files
+  class ArchiveProcessor
+    include ContextualLogger
+
+    MAX_FILE_SIZE_BYTES = 100 * 1024 * 1024  # 100 MB in bytes
+    
+    def initialize
+      # Archive processor initialization
+    end
+
+    # Download and extract archive data
+    def download_and_extract(archive_url)
+      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)
+        return download_result if download_result.failure?
+
+        content = download_result.data[:content]
+
+        # Determine archive format by first bytes
+        first_bytes = content[0..1].unpack("H*").first
+
+        if first_bytes == "1f8b"
+          # This is GZIP archive - decompress GZIP, then ZIP
+          gunzip_result = decompress_gzip(content)
+          return gunzip_result if gunzip_result.failure?
+
+          zip_result = extract_zip_from_memory(gunzip_result.data[:content])
+
+          Result.success({
+            files: zip_result,
+            total_size: download_result.data[:size],
+            compressed_size: gunzip_result.data[:compressed_size],
+            file_count: zip_result.size
+          })
+        elsif content[0..1] == "PK"
+          # This is already ZIP archive - parse directly
+          zip_result = extract_zip_from_memory(content)
+
+          Result.success({
+            files: zip_result,
+            total_size: download_result.data[:size],
+            compressed_size: nil,
+            file_count: zip_result.size
+          })
+        else
+          Result.failure("Unknown archive format (not GZIP and not ZIP)")
+        end
+      rescue => e
+        Result.failure("Archive processing error: #{e.message}")
+      end
+    end
+
+    private
+
+    def download_to_memory(url)
+      begin
+        uri = URI.parse(url)
+        # Check if URI is valid HTTP/HTTPS
+        unless uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
+          return Result.failure("Invalid URL: not HTTP/HTTPS")
+        end
+      rescue URI::InvalidURIError => e
+        return Result.failure("Invalid URL: #{e.message}")
+      end
+
+      begin
+        http = create_http_client(uri)
+
+        request = Net::HTTP::Get.new(uri.request_uri)
+        request["User-Agent"] = "OxTenderAbstract/#{OxTenderAbstract::VERSION}"
+        request["individualPerson_token"] = OxTenderAbstract.configuration.token
+
+        log_debug "Downloading archive from: #{url}"
+
+        response = http.request(request)
+
+        unless response.is_a?(Net::HTTPSuccess)
+          return Result.failure("HTTP error: #{response.code} #{response.message}")
+        end
+
+        content = response.body
+        size = content.bytesize
+
+        if size > MAX_FILE_SIZE_BYTES
+          return Result.failure("Archive too large: #{size} bytes (max: #{MAX_FILE_SIZE_BYTES})")
+        end
+
+        log_debug "Downloaded archive: #{size} bytes"
+
+        Result.success({
+          content: content,
+          size: size,
+          content_type: response["content-type"]
+        })
+      rescue SocketError, Timeout::Error => e
+        Result.failure("Network error: #{e.message}")
+      rescue => e
+        Result.failure("Download error: #{e.message}")
+      end
+    end
+
+    def create_http_client(uri)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      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
+      http
+    end
+
+    def decompress_gzip(gzip_content)
+      begin
+        log_debug "Decompressing GZIP archive"
+        
+        gz = Zlib::GzipReader.new(StringIO.new(gzip_content))
+        decompressed_content = gz.read
+        gz.close
+
+        Result.success({
+          content: decompressed_content,
+          compressed_size: gzip_content.bytesize,
+          decompressed_size: decompressed_content.bytesize
+        })
+      rescue Zlib::GzipFile::Error => e
+        Result.failure("GZIP decompression error: #{e.message}")
+      rescue => e
+        Result.failure("Decompression error: #{e.message}")
+      end
+    end
+
+    def extract_zip_from_memory(zip_content)
+      begin
+        log_debug "Extracting ZIP archive from memory"
+        
+        files = {}
+        zip_io = StringIO.new(zip_content)
+
+        Zip::File.open_buffer(zip_io) do |zip_file|
+          zip_file.each do |entry|
+            next if entry.directory?
+            
+            log_debug "Extracting file: #{entry.name} (#{entry.size} bytes)"
+            
+            files[entry.name] = {
+              content: entry.get_input_stream.read,
+              size: entry.size,
+              compressed_size: entry.compressed_size,
+              crc: entry.crc
+            }
+          end
+        end
+
+        log_debug "Extracted #{files.size} files from ZIP archive"
+        files
+      rescue Zip::Error => e
+        raise ArchiveError, "ZIP extraction error: #{e.message}"
+      rescue => e
+        raise ArchiveError, "Archive extraction error: #{e.message}"
+      end
+    end
+  end
+end 

data/lib/oxtenderabstract/client.rb

@@ -0,0 +1,347 @@
+# frozen_string_literal: true
+
+require_relative 'document_types'
+require_relative 'result'
+require_relative 'errors'
+require_relative 'archive_processor'
+require_relative 'xml_parser'
+require_relative 'logger'
+require 'savon'
+require 'securerandom'
+require 'net/http'
+require 'uri'
+require 'openssl'
+
+module OxTenderAbstract
+  # Main client for working with Zakupki SOAP API
+  class Client
+    include ContextualLogger
+
+    def initialize(token: nil)
+      @token = token || OxTenderAbstract.configuration.token
+      @xml_parser = XmlParser.new
+      @archive_processor = ArchiveProcessor.new
+      validate_token!
+    end
+
+    # Get documents by region and date
+    def get_docs_by_region(org_region:, exact_date:, subsystem_type: DocumentTypes::DEFAULT_SUBSYSTEM,
+                           document_type: DocumentTypes::DEFAULT_DOCUMENT_TYPE)
+      validate_params!({
+                         org_region: org_region,
+                         subsystem_type: subsystem_type,
+                         document_type: document_type,
+                         exact_date: exact_date
+                       })
+
+      request_data = build_region_request(org_region, subsystem_type, document_type, exact_date)
+      execute_soap_request(:get_docs_by_org_region, request_data)
+    end
+
+    # Get documents by registry number
+    def get_docs_by_reestr_number(reestr_number:, subsystem_type: DocumentTypes::DEFAULT_SUBSYSTEM)
+      validate_params!({
+                         reestr_number: reestr_number,
+                         subsystem_type: subsystem_type
+                       })
+
+      request_data = build_reestr_request(reestr_number, subsystem_type)
+      log_info "Requesting documents for registry number: #{reestr_number}, type: #{subsystem_type}"
+
+      result = execute_soap_request(:get_docs_by_reestr_number, request_data)
+
+      if result.success?
+        log_info "Success response for #{reestr_number}. Found archives: #{result.data[:archive_urls]&.size || 0}"
+      else
+        log_error "Error for #{reestr_number}: #{result.error}"
+      end
+
+      result
+    end
+
+    # Download and parse archive data
+    def download_archive_data(archive_url)
+      @archive_processor.download_and_extract(archive_url)
+    end
+
+    # Parse XML document
+    def parse_xml_document(xml_content)
+      @xml_parser.parse(xml_content)
+    end
+
+    # Extract attachments info from XML
+    def extract_attachments_from_xml(xml_content)
+      @xml_parser.extract_attachments(xml_content)
+    end
+
+    # 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}"
+
+      # 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?
+
+      log_info "Found #{archive_urls.size} archives to process"
+
+      # Step 2: Process each archive
+      all_tenders = []
+      total_files = 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?
+
+        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') }
+
+        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
+
+          tender_data = parse_result.data[:content]
+          next if tender_data[:reestr_number].nil? || tender_data[:reestr_number].empty?
+
+          # Add metadata
+          tender_data[:source_file] = file_name
+          tender_data[:archive_url] = archive_url
+          tender_data[:processed_at] = Time.now
+
+          all_tenders << tender_data
+        end
+      end
+
+      log_info "Search completed. Found #{all_tenders.size} tenders in #{total_files} files"
+
+      Result.success({
+                       tenders: all_tenders,
+                       total_archives: archive_urls.size,
+                       total_files: total_files,
+                       processed_at: Time.now
+                     })
+    end
+
+    # Enhanced search tenders 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)
+      log_info "Starting enhanced tender search for region #{org_region}, date #{exact_date}"
+
+      # 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?
+
+      log_info "Found #{archive_urls.size} archives to process"
+
+      # Step 2: Process each archive with detailed information extraction
+      all_tenders = []
+      total_files = 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?
+
+        files = archive_result.data[:files]
+        total_files += files.size
+
+        # Step 3: Parse XML files from archive with enhanced data extraction
+        xml_files = files.select { |name, _| name.downcase.end_with?('.xml') }
+
+        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
+
+          tender_data = parse_result.data[:content]
+          next if tender_data[:reestr_number].nil? || tender_data[:reestr_number].empty?
+
+          # Step 4: Extract additional detailed information
+          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
+        end
+      end
+
+      log_info "Enhanced search completed. Found #{all_tenders.size} tenders in #{total_files} files"
+
+      Result.success({
+                       tenders: all_tenders,
+                       total_archives: archive_urls.size,
+                       total_files: total_files,
+                       processed_at: Time.now,
+                       enhanced: true
+                     })
+    end
+
+    private
+
+    def validate_token!
+      return if @token&.strip&.length&.positive?
+
+      raise AuthenticationError, 'Token cannot be empty. Set it via OxTenderAbstract.configure or pass as parameter'
+    end
+
+    def validate_params!(params)
+      params.each do |key, value|
+        raise ConfigurationError, "Parameter #{key} cannot be blank" if value.nil? || value.to_s.strip.empty?
+      end
+    end
+
+    def build_region_request(org_region, subsystem_type, document_type, exact_date)
+      {
+        'index' => {
+          'id' => SecureRandom.uuid,
+          'createDateTime' => Time.now.strftime('%Y-%m-%dT%H:%M:%S%:z'),
+          'mode' => 'PROD'
+        },
+        'selectionParams' => {
+          'orgRegion' => org_region,
+          'subsystemType' => subsystem_type,
+          'documentType44' => document_type,
+          'periodInfo' => {
+            'exactDate' => exact_date
+          }
+        }
+      }
+    end
+
+    def build_reestr_request(reestr_number, subsystem_type)
+      {
+        'index' => {
+          'id' => SecureRandom.uuid,
+          'createDateTime' => Time.now.strftime('%Y-%m-%dT%H:%M:%S%:z'),
+          'mode' => 'PROD'
+        },
+        'selectionParams' => {
+          'subsystemType' => subsystem_type,
+          'registryNumber' => reestr_number
+        }
+      }
+    end
+
+    def execute_soap_request(operation, message)
+      client = create_soap_client
+      log_debug "Executing SOAP request: #{operation}"
+      log_debug "SOAP header: #{client.globals[:soap_header]}"
+      log_debug "Request message: #{message.inspect}"
+
+      response = client.call(operation, message: message)
+      log_debug "SOAP response code: #{response.http.code}"
+      log_debug "SOAP response body keys: #{response.body.keys}"
+
+      process_soap_response(response, operation)
+    rescue Savon::SOAPFault => e
+      log_error "SOAP Fault: #{e.message}"
+      log_error "SOAP Fault details: #{e.to_hash}"
+      Result.failure("SOAP Fault: #{e.message}")
+    rescue Savon::HTTPError => e
+      log_error "HTTP Error: #{e.message}"
+      Result.failure("HTTP Error: #{e.message}")
+    rescue StandardError => e
+      log_error "General request error: #{e.message}"
+      log_error "#{e.backtrace.first(5).join("\n")}"
+      Result.failure("Request error: #{e.message}")
+    end
+
+    def create_soap_client
+      token_status = !@token.nil? && !@token.empty? ? "present (#{@token[0..5]}...)" : 'missing'
+      log_debug "Creating SOAP client with token: #{token_status}"
+
+      Savon.client(
+        wsdl: OxTenderAbstract.configuration.wsdl_url,
+        soap_header: { 'individualPerson_token' => @token },
+        open_timeout: OxTenderAbstract.configuration.timeout_open,
+        read_timeout: OxTenderAbstract.configuration.timeout_read,
+        ssl_verify_mode: OxTenderAbstract.configuration.ssl_verify ? :peer : :none,
+        log: false
+      )
+    end
+
+    def process_soap_response(response, operation)
+      return Result.failure('Empty response') unless response&.body
+
+      case operation
+      when :get_docs_by_org_region
+        process_region_response(response.body)
+      when :get_docs_by_reestr_number
+        process_reestr_response(response.body)
+      else
+        Result.failure("Unknown operation: #{operation}")
+      end
+    end
+
+    def process_region_response(body)
+      data_info = body.dig(:get_docs_by_org_region_response, :data_info)
+      return Result.failure('No data info in response') unless data_info
+
+      archive_urls = extract_archive_urls(data_info)
+
+      Result.success({
+                       archive_urls: archive_urls,
+                       response_metadata: {
+                         operation: :get_docs_by_org_region,
+                         timestamp: Time.now
+                       }
+                     })
+    end
+
+    def process_reestr_response(body)
+      data_info = body.dig(:get_docs_by_reestr_number_response, :data_info)
+      return Result.failure('No data info in response') unless data_info
+
+      archive_urls = extract_archive_urls(data_info)
+
+      Result.success({
+                       archive_urls: archive_urls,
+                       response_metadata: {
+                         operation: :get_docs_by_reestr_number,
+                         timestamp: Time.now
+                       }
+                     })
+    end
+
+    def extract_archive_urls(data_info)
+      return [] unless data_info&.dig(:archive_url)
+
+      Array(data_info[:archive_url]).compact
+    end
+  end
+end

data/lib/oxtenderabstract/compatibility.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Ruby
+  module OxTenderAbstract
+    VERSION = ::OxTenderAbstract::VERSION
+
+    Error = ::OxTenderAbstract::Error
+    ConfigurationError = ::OxTenderAbstract::ConfigurationError
+    Configuration = ::OxTenderAbstract::Configuration
+  end
+end

data/lib/oxtenderabstract/configuration.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module OxTenderAbstract
+  # Configuration for the library
+  class Configuration
+    attr_accessor :token, :timeout_open, :timeout_read, :ssl_verify
+    attr_writer :wsdl_url, :logger
+
+    def initialize
+      @token = nil
+      @timeout_open = 30
+      @timeout_read = 120
+      @ssl_verify = false
+      @wsdl_url = nil  # Will be set later
+      @logger = nil    # Will be set later
+    end
+
+    def wsdl_url
+      @wsdl_url ||= DocumentTypes::API_CONFIG[:wsdl]
+    end
+
+    def logger
+      @logger ||= Logger.new($stdout).tap do |log|
+        log.level = Logger::INFO
+        log.formatter = proc do |severity, datetime, progname, msg|
+          "[#{datetime.strftime('%Y-%m-%d %H:%M:%S')}] #{severity}: #{msg}\n"
+        end
+      end
+    end
+
+    def valid?
+      !token.nil? && !token.empty?
+    end
+
+    def token_from_file(file_path)
+      return nil unless File.exist?(file_path)
+
+      content = File.read(file_path).strip
+      content.empty? ? nil : content
+    end
+  end
+
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end

data/lib/oxtenderabstract/document_types.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module OxTenderAbstract
+  # Document types and constants for Zakupki API
+  module DocumentTypes
+    # Supported subsystem types
+    SUBSYSTEM_TYPES = %w[
+      PRIZ RPEC RPGZ RJ RDI BTK RPKLKP RPNZ RGK EA UR REC RPP RVP RRK RRA
+      RNP RKPO PPRF615 RD615 LKOK OZ OD223 RD223 MSP223 IPVP223 TRU223
+      RJ223 RPP223 RPZ223 RI223 RZ223 OV223 TPOZ223 POZ223 RNP223 POM223 ZC
+    ].freeze
+
+    # Document types for 44-FZ (federal law)
+    DOCUMENT_TYPES_44FZ = %w[
+      TENDER_PLAN TENDER_TERMS CONTRACT_PLAN TENDER_PROTOCOL
+      CONTRACT_EXECUTION_REPORT TENDER_NOTICE TENDER_DOCUMENTATION
+    ].freeze
+
+    # Electronic notification types
+    ELECTRONIC_NOTIFICATION_TYPES = %w[
+      epNotificationEF2020 epNotificationEF epNotificationOK2020
+      epNotificationEP2020 epNotificationZK2020 epNotificationZP2020
+      epNotificationISM2020 fcsNotificationEF fcsNotificationOK
+      fcsNotificationEP fcsNotificationZK fcsNotificationZP
+      fcsNotificationISM fcsPlacement fcsPlacementResult
+    ].freeze
+
+    # Default settings
+    DEFAULT_SUBSYSTEM = 'PRIZ'
+    DEFAULT_DOCUMENT_TYPE = 'epNotificationEF2020'
+
+    # API configuration
+    API_CONFIG = {
+      wsdl: 'https://int44.zakupki.gov.ru/eis-integration/services/getDocsIP?wsdl',
+      timeout: {
+        open: 30,
+        read: 120
+      },
+      ssl_verify: false
+    }.freeze
+  end
+end

data/lib/oxtenderabstract/engine.rb

@@ -0,0 +1,11 @@
+module OxTenderAbstract
+  class Engine < ::Rails::Engine
+    isolate_namespace OxTenderAbstract # this is generally recommended
+
+    # no other special configuration needed. But maybe you want
+    # an initializer to be added to the app? Easy!
+    # initializer 'yourgem.boot_stuff_up' do
+    #   OxTenderAbstract.boot_something_up!
+    # end
+  end
+end

data/lib/oxtenderabstract/errors.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module OxTenderAbstract
+  # Base error class for the library
+  class Error < StandardError; end
+
+  # Configuration related errors
+  class ConfigurationError < Error; end
+
+  # Network related errors
+  class NetworkError < Error; end
+
+  # SOAP API related errors
+  class SoapError < Error; end
+
+  # XML parsing related errors
+  class ParseError < Error; end
+
+  # Archive processing related errors
+  class ArchiveError < Error; end
+
+  # Authentication related errors
+  class AuthenticationError < Error; end
+end