ox-tender-abstract 0.9.1 → 0.9.3

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.1'
+  VERSION = '0.9.3'
 end

data/lib/oxtenderabstract/xml_parser.rb

@@ -408,8 +408,11 @@ module OxTenderAbstract
     def extract_price_from_text(text)
       return nil if text.nil? || text.empty?
 
+      # Remove currency symbols and text like 'руб.', 'рублей' etc.
+      cleaned = text.gsub(/[а-яё]+\.?/i, '').strip
+
       # Remove any non-digit characters except decimal separator and spaces
-      cleaned = text.gsub(/[^\d\s.,]/, '').strip
+      cleaned = cleaned.gsub(/[^\d\s.,]/, '').strip
       return nil if cleaned.empty?
 
       # Remove spaces (used as thousand separators in Russian format)
@@ -483,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}"
@@ -522,10 +546,13 @@ module OxTenderAbstract
 
     def extract_purchase_object_data(object_node, namespaces)
       # Basic object information
+      # CRITICAL FIX: Extract name that's direct child of purchaseObject, not from characteristics
+      direct_name = object_node.xpath('./ns4:name | ./name', namespaces).first&.text&.strip
+
       object_data = {
         sid: extract_text_from_node(object_node, './/ns4:sid | .//sid'),
         external_sid: extract_text_from_node(object_node, './/ns4:externalSid | .//externalSid'),
-        name: extract_text_from_node(object_node, './/ns4:name | .//name'),
+        name: direct_name,
         price: extract_price_from_text(extract_text_from_node(object_node, './/ns4:price | .//price')),
         quantity: extract_text_from_node(object_node, './/ns4:quantity/ns4:value | .//quantity/value')&.to_i,
         sum: extract_price_from_text(extract_text_from_node(object_node, './/ns4:sum | .//sum')),
@@ -573,7 +600,7 @@ module OxTenderAbstract
         }
       end
 
-      # Extract characteristics (simplified - just count and basic info)
+      # Extract characteristics (detailed extraction)
       characteristics_nodes = object_node.xpath(
         './/ns4:characteristics//ns4:characteristicsUsingReferenceInfo | .//characteristics//characteristicsUsingReferenceInfo', namespaces
       )
@@ -582,36 +609,150 @@ module OxTenderAbstract
       )
 
       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
+
         object_data[:characteristics] = {
           count: characteristics_nodes.size,
-          details: characteristics_nodes.first(5).map do |char_node|
-            {
-              name: extract_text_from_node(char_node, './/ns4:name | .//name'),
-              type: extract_text_from_node(char_node, './/ns4:type | .//type')
-            }
-          end
+          details: characteristics_details
         }
       end
 
       # Determine the actual product name from available sources
-      # Priority: KTRU name > OKPD2 name > name field
-      product_name = nil
-      product_name = if object_data[:ktru] && object_data[:ktru][:name] && !object_data[:ktru][:name].empty?
+      # Priority: Direct name field (now fixed) > KTRU name > OKPD2 name
+      product_name = if object_data[:name] && !object_data[:name].empty?
+                       object_data[:name]
+                     elsif object_data[:ktru] && object_data[:ktru][:name] && !object_data[:ktru][:name].empty?
                        object_data[:ktru][:name]
                      elsif object_data[:okpd2] && object_data[:okpd2][:name] && !object_data[:okpd2][:name].empty?
                        object_data[:okpd2][:name]
                      else
-                       object_data[:name]
+                       'Unknown product'
                      end
 
       object_data[:product_name] = product_name
 
-      # Add field description indicating what the 'name' field actually contains
-      object_data[:name_type] = determine_name_type(object_data[:name])
+      # Now the name field should contain actual product names, not characteristics
+      object_data[:name_type] = 'product_name'
 
       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.1
+  version: 0.9.3
 platform: ruby
 authors:
 - smolev