isds 0.1.0

data/lib/isds/large_messages/uploader.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ISDS
+  module LargeMessages
+    class Uploader
+      DEFAULT_CHUNK_SIZE = 10 * 1024 * 1024 # 10MB
+
+      attr_reader :connection, :chunk_size
+
+      def initialize(connection:, chunk_size: DEFAULT_CHUNK_SIZE)
+        @connection = connection
+        @chunk_size = chunk_size
+      end
+
+      def upload(file_path, message_envelope, &progress_callback) # rubocop:disable Metrics/AbcSize
+        validate_file!(file_path)
+
+        file_size = File.size(file_path)
+        chunks = (file_size.to_f / chunk_size).ceil
+        uploaded_bytes = 0
+
+        File.open(file_path, 'rb') do |file|
+          chunks.times do |i|
+            chunk_data = file.read(chunk_size)
+            upload_chunk(message_envelope, chunk_data, i + 1, chunks)
+
+            uploaded_bytes += chunk_data.bytesize
+            progress_callback&.call(uploaded_bytes, file_size, i + 1, chunks)
+          end
+        end
+
+        finalize_upload(message_envelope)
+      end
+
+      private
+
+      def validate_file!(file_path)
+        raise AttachmentError, "File not found: #{file_path}" unless File.exist?(file_path)
+
+        file_size = File.size(file_path)
+        return unless file_size > Attachment::LARGE_MAX_FILE_SIZE
+
+        raise FileSizeExceededError, 'File exceeds maximum size of 100MB for large messages'
+      end
+
+      def upload_chunk(_envelope, chunk_data, sequence, total)
+        encoded = Base64.strict_encode64(chunk_data)
+
+        connection.call(:large_messages, :upload_chunk, {
+                          'isds:dmChunk' => {
+                            'isds:dmEncodedContent' => encoded,
+                            'isds:dmChunkSeq' => sequence,
+                            'isds:dmChunksTotal' => total
+                          }
+                        })
+      end
+
+      def finalize_upload(envelope)
+        connection.call(:large_messages, :finalize_upload, {
+                          'isds:dmEnvelope' => envelope
+                        })
+      end
+    end
+  end
+end

data/lib/isds/message.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module ISDS
+  class Message # rubocop:disable Metrics/ClassLength
+    attr_reader :id, :databox_id, :subject, :sender, :recipient,
+                :status, :delivery_time, :acceptance_time,
+                :attachments, :annotation, :raw_data
+
+    ENVELOPE_OPTION_MAPPINGS = {
+      sender_org_unit: 'isds:dmSenderOrgUnit',
+      sender_org_unit_num: 'isds:dmSenderOrgUnitNum',
+      recipient_org_unit: 'isds:dmRecipientOrgUnit',
+      recipient_org_unit_num: 'isds:dmRecipientOrgUnitNum',
+      to_hands: 'isds:dmToHands',
+      personal_delivery: 'isds:dmPersonalDelivery',
+      allow_subst_delivery: 'isds:dmAllowSubstDelivery',
+      legal_title_law: 'isds:dmLegalTitleLaw',
+      legal_title_year: 'isds:dmLegalTitleYear',
+      legal_title_sect: 'isds:dmLegalTitleSect',
+      legal_title_par: 'isds:dmLegalTitlePar',
+      legal_title_point: 'isds:dmLegalTitlePoint',
+      type: 'isds:dmType'
+    }.freeze
+    private_constant :ENVELOPE_OPTION_MAPPINGS
+
+    def initialize(connection: nil, **attributes)
+      @connection = connection
+      @id = attributes[:id]
+      @databox_id = attributes[:databox_id]
+      @subject = attributes[:subject]
+      @sender = attributes[:sender]
+      @recipient = attributes[:recipient]
+      @status = attributes[:status]
+      @delivery_time = attributes[:delivery_time]
+      @acceptance_time = attributes[:acceptance_time]
+      @attachments = attributes[:attachments] || []
+      @annotation = attributes[:annotation]
+      @raw_data = attributes[:raw_data]
+    end
+
+    def create(to_databox_id, subject:, attachments: [], **options)
+      envelope = build_envelope(to_databox_id, subject, options)
+      files = build_attachments(attachments)
+
+      response = @connection.call(:operations, :create_message, {
+                                    'isds:dmEnvelope' => envelope,
+                                    'isds:dmFiles' => files
+                                  })
+
+      extract_message_id(response)
+    end
+
+    def delivered?
+      [4, 5].include?(status)
+    end
+
+    def read?
+      status == 6
+    end
+
+    def large_message?
+      attachments.any? { |a| a.respond_to?(:size) && a.size > 10 * 1024 * 1024 }
+    end
+
+    def download_attachment(attachment_id, path = nil)
+      response = @connection.call(:info, :message_download, { 'isds:dmID' => id })
+      extract_attachment(response, attachment_id, path)
+    end
+
+    def download_all_attachments(directory)
+      response = @connection.call(:info, :message_download, { 'isds:dmID' => id })
+      extract_all_attachments(response, directory)
+    end
+
+    def signed_content
+      response = @connection.call(:info, :signed_message_download, { 'isds:dmID' => id })
+      response.dig(:signed_message_download_response, :dm_signature)
+    end
+
+    class << self
+      def find(message_id, connection:)
+        response = connection.call(:info, :message_download, { 'isds:dmID' => message_id })
+        from_response(response, connection: connection)
+      end
+
+      def received(connection:, limit: 50, unread_only: true, **filters)
+        params = build_list_params(limit: limit, **filters)
+        params['isds:dmStatusFilter'] = unread_only ? '4' : '-1'
+
+        response = connection.call(:info, :get_list_of_received_messages, params)
+        parse_message_list(response, connection: connection)
+      end
+
+      def sent(connection:, limit: 50, **filters)
+        params = build_list_params(limit: limit, **filters)
+
+        response = connection.call(:info, :get_list_of_sent_messages, params)
+        parse_message_list(response, connection: connection)
+      end
+
+      def mark_as_read(message_id, connection:)
+        connection.call(:info, :mark_message_as_downloaded, { 'isds:dmID' => message_id })
+      end
+
+      private
+
+      def build_list_params(limit:, **filters)
+        params = { 'isds:dmLimit' => limit }
+        params['isds:dmFromTime'] = format_time_filter(filters[:from_time]) if filters[:from_time]
+        params['isds:dmToTime'] = format_time_filter(filters[:to_time]) if filters[:to_time]
+        params['isds:dmOffset'] = filters[:offset] if filters[:offset]
+        params
+      end
+
+      def format_time_filter(value)
+        value.is_a?(Time) ? value.iso8601 : value
+      end
+
+      def parse_message_list(response, connection:)
+        records_key = response.keys.first
+        records = response.dig(records_key, :dm_records, :dm_record)
+        return [] if records.nil?
+
+        records = [records] unless records.is_a?(Array)
+        records.map { |record| from_record(record, connection: connection) }
+      end
+
+      def from_response(response, connection:)
+        data = response.dig(:message_download_response, :dm_return_data_message)
+        return nil unless data
+
+        build_from_envelope(data[:dm_dm] || {}, data, connection)
+      end
+
+      def from_record(record, connection:)
+        build_from_envelope(record, record, connection)
+      end
+
+      def build_from_envelope(envelope, raw, connection)
+        new(
+          connection: connection,
+          id: envelope[:dm_id],
+          subject: envelope[:dm_annotation],
+          sender: envelope[:dm_sender],
+          recipient: envelope[:dm_recipient],
+          status: envelope[:dm_message_status]&.to_i,
+          delivery_time: envelope[:dm_delivery_time],
+          acceptance_time: envelope[:dm_acceptance_time],
+          raw_data: raw
+        )
+      end
+    end
+
+    private
+
+    def build_envelope(to_databox_id, subject, options)
+      envelope = {
+        'isds:dbIDRecipient' => to_databox_id,
+        'isds:dmAnnotation' => subject
+      }
+
+      ENVELOPE_OPTION_MAPPINGS.each do |option_key, xml_key|
+        envelope[xml_key] = options[option_key] if options[option_key]
+      end
+
+      envelope
+    end
+
+    def build_attachments(attachments)
+      return {} if attachments.empty?
+
+      { 'isds:dmFile' => attachments.map { |a| Attachment.build_soap_element(a) } }
+    end
+
+    def extract_message_id(response)
+      response.dig(:create_message_response, :dm_id) ||
+        response.dig(:create_message_response, :message_id)
+    end
+
+    def extract_attachment(response, attachment_id, path)
+      files = extract_files(response)
+      file = files.find { |f| f[:dm_file_meta_type] == attachment_id || f[:dm_file_descr] == attachment_id }
+      return nil unless file
+
+      content = Base64.decode64(file[:dm_encoded_content])
+      path ? File.binwrite(path, content) && path : content
+    end
+
+    def extract_all_attachments(response, directory)
+      FileUtils.mkdir_p(directory)
+
+      extract_files(response).filter_map do |file|
+        next unless file[:dm_encoded_content]
+
+        content = Base64.decode64(file[:dm_encoded_content])
+        filename = file[:dm_file_descr] || "attachment_#{file[:dm_file_meta_type]}"
+        path = File.join(directory, filename)
+        File.binwrite(path, content)
+        path
+      end
+    end
+
+    def extract_files(response)
+      files = response.dig(:message_download_response, :dm_return_data_message, :dm_files, :dm_file)
+      files.is_a?(Array) ? files : [files]
+    end
+  end
+end

data/lib/isds/search.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module ISDS
+  class Search
+    DATABOX_TYPES = {
+      fo: 'FO',
+      pfo: 'PFO',
+      po: 'PO',
+      ovm: 'OVM'
+    }.freeze
+
+    def self.databoxes(query, connection:, **options)
+      criteria = build_search_criteria(query, **options)
+      response = connection.call(:search, :find_data_box, criteria)
+      parse_search_response(response)
+    end
+
+    def self.by_name(name, connection:, exact: false)
+      criteria = {
+        'isds:dbOwnerInfo' => {
+          'isds:firmName' => name
+        }
+      }
+
+      response = connection.call(:search, :find_data_box, criteria)
+      results = parse_search_response(response)
+
+      if exact
+        results.select { |db| db.name.casecmp?(name) }
+      else
+        results
+      end
+    end
+
+    def self.by_ico(ico, connection:)
+      Databox.find_by_ico(ico, connection: connection)
+    end
+
+    def self.by_address(connection:, **address_parts)
+      criteria = { 'isds:dbOwnerInfo' => {} }
+      criteria['isds:dbOwnerInfo']['isds:adCity'] = address_parts[:city] if address_parts[:city]
+      criteria['isds:dbOwnerInfo']['isds:adStreet'] = address_parts[:street] if address_parts[:street]
+      criteria['isds:dbOwnerInfo']['isds:adZipCode'] = address_parts[:zip_code] if address_parts[:zip_code]
+
+      response = connection.call(:search, :find_data_box, criteria)
+      parse_search_response(response)
+    end
+
+    def self.by_type(databox_type, connection:, query: nil)
+      type_value = DATABOX_TYPES[databox_type.to_sym] || databox_type.to_s
+      criteria = {
+        'isds:dbOwnerInfo' => {
+          'isds:dbType' => type_value
+        }
+      }
+      criteria['isds:dbOwnerInfo']['isds:firmName'] = query if query
+
+      response = connection.call(:search, :find_data_box, criteria)
+      parse_search_response(response)
+    end
+
+    def self.ovm_only(connection:, query: nil)
+      by_type(:ovm, connection: connection, query: query)
+    end
+
+    def self.paginated_search(query, connection:, page: 1, per_page: 100)
+      criteria = build_search_criteria(query)
+      criteria['isds:dbOffset'] = (page - 1) * per_page
+      criteria['isds:dbLimit'] = per_page
+
+      response = connection.call(:search, :find_data_box, criteria)
+      results = parse_search_response(response)
+
+      {
+        results: results,
+        page: page,
+        per_page: per_page,
+        total: results.length
+      }
+    end
+
+    def self.build_search_criteria(query, **options)
+      criteria = { 'isds:dbOwnerInfo' => {} }
+
+      case query
+      when Hash
+        query.each do |key, value|
+          criteria['isds:dbOwnerInfo']["isds:#{key}"] = value
+        end
+      when String
+        criteria['isds:dbOwnerInfo']['isds:firmName'] = query
+      end
+
+      criteria['isds:dbOwnerInfo']['isds:dbType'] = options[:type] if options[:type]
+      criteria
+    end
+    private_class_method :build_search_criteria
+
+    def self.parse_search_response(response)
+      key = response.keys.first
+      records = response.dig(key, :db_results, :db_owner_info)
+      return [] if records.nil?
+
+      records = [records] unless records.is_a?(Array)
+      records.map do |record|
+        Databox.send(:from_record, record)
+      end
+    end
+    private_class_method :parse_search_response
+  end
+end

data/lib/isds/status.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module ISDS
+  class Status
+    CODES = {
+      1 => :submitted,
+      2 => :stamped,
+      3 => :infected,
+      4 => :delivered,
+      5 => :delivered_by_fiction,
+      6 => :read,
+      7 => :undeliverable,
+      8 => :removed,
+      9 => :in_vault,
+      10 => :in_vault_delivered
+    }.freeze
+
+    LABELS = {
+      submitted: 'Podána',
+      stamped: 'Opatřena časovým razítkem',
+      infected: 'Infikována virem',
+      delivered: 'Dodána',
+      delivered_by_fiction: 'Doručena fikcí',
+      read: 'Přečtena',
+      undeliverable: 'Nedoručitelná',
+      removed: 'Odstraněna',
+      in_vault: 'V datovém trezoru',
+      in_vault_delivered: 'V datovém trezoru - dodána'
+    }.freeze
+
+    attr_reader :code
+
+    def initialize(code)
+      @code = code.to_i
+    end
+
+    def name
+      CODES[code]
+    end
+
+    def label
+      LABELS[name]
+    end
+
+    def delivered?
+      %i[delivered delivered_by_fiction read in_vault_delivered].include?(name)
+    end
+
+    def read?
+      name == :read
+    end
+
+    def problematic?
+      %i[infected undeliverable removed].include?(name)
+    end
+
+    def final?
+      %i[read undeliverable removed in_vault in_vault_delivered].include?(name)
+    end
+
+    def to_s
+      "#{code} - #{label || 'Unknown'}"
+    end
+  end
+end

data/lib/isds/timestamp/verifier.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ISDS
+  module Timestamp
+    class Verifier
+      attr_reader :connection
+
+      def initialize(connection:)
+        @connection = connection
+      end
+
+      def verify(message_id)
+        response = connection.call(:info, :get_message_state_changes, {
+                                     'isds:dmID' => message_id
+                                   })
+
+        key = response.keys.first
+        events = response.dig(key, :dm_events, :dm_event)
+        return [] if events.nil?
+
+        events = [events] unless events.is_a?(Array)
+        events.map { |event| parse_event(event) }
+      end
+
+      private
+
+      def parse_event(event)
+        {
+          time: event[:dm_event_time],
+          type: event[:dm_event_type],
+          description: event[:dm_event_descr]
+        }
+      end
+    end
+  end
+end

data/lib/isds/types.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ISDS
+  module Types
+    include Dry.Types()
+
+    DataboxType = Types::Coercible::String.enum('FO', 'PFO', 'PFO_ADVOK', 'PFO_DANPOR', 'PFO_INSSPR',
+                                                'PFO_AUDITOR', 'PO', 'PO_ZAK', 'PO_REQ', 'OVM', 'OVM_NOTAR',
+                                                'OVM_EXEKUT', 'OVM_REQ')
+
+    MessageStatus = Types::Coercible::Integer.enum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+    # 1 = submitted, 2 = stamped, 3 = infected, 4 = delivered,
+    # 5 = delivered by fiction, 6 = read, 7 = undeliverable,
+    # 8 = removed, 9 = in data vault, 10 = in data vault delivered
+
+    Environment = Types::Coercible::Symbol.enum(:test, :production)
+    AuthMethod = Types::Coercible::Symbol.enum(:basic, :certificate, :access_interface)
+  end
+end

data/lib/isds/user.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module ISDS
+  class User
+    attr_reader :id, :first_name, :last_name, :type, :privileges, :raw_data
+
+    def initialize(**attributes)
+      @id = attributes[:id]
+      @first_name = attributes[:first_name]
+      @last_name = attributes[:last_name]
+      @type = attributes[:type]
+      @privileges = attributes[:privileges] || {}
+      @raw_data = attributes[:raw_data]
+    end
+
+    def full_name
+      [first_name, last_name].compact.join(' ')
+    end
+
+    def self.list(connection:)
+      response = connection.call(:access, :get_data_box_users, {})
+      parse_users(response)
+    end
+
+    def self.add(connection:, databox_id:, **user_info)
+      Databox.validate_databox_id!(databox_id)
+
+      connection.call(:access, :add_data_box_user, {
+                        'isds:dbID' => databox_id,
+                        'isds:dbUserInfo' => build_user_info(user_info)
+                      })
+    end
+
+    def self.remove(connection:, user_id:)
+      connection.call(:access, :delete_data_box_user, {
+                        'isds:dbUserID' => user_id
+                      })
+    end
+
+    def self.build_user_info(info)
+      user = {}
+      user['isds:pnFirstName'] = info[:first_name] if info[:first_name]
+      user['isds:pnLastName'] = info[:last_name] if info[:last_name]
+      user['isds:userPrivils'] = info[:privileges] if info[:privileges]
+      user
+    end
+    private_class_method :build_user_info
+
+    def self.parse_users(response)
+      key = response.keys.first
+      records = response.dig(key, :db_users, :db_user_info)
+      return [] if records.nil?
+
+      records = [records] unless records.is_a?(Array)
+      records.map { |record| from_record(record) }
+    end
+    private_class_method :parse_users
+
+    def self.from_record(record)
+      new(
+        id: record[:user_id],
+        first_name: record[:pn_first_name],
+        last_name: record[:pn_last_name],
+        type: record[:user_type],
+        privileges: record[:user_privils],
+        raw_data: record
+      )
+    end
+    private_class_method :from_record
+  end
+end

data/lib/isds/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ISDS
+  VERSION = '0.1.0'
+end

data/lib/isds.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'zeitwerk'
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect('isds' => 'ISDS')
+loader.setup
+
+require 'savon'
+require 'nokogiri'
+require 'faraday'
+require 'faraday/retry'
+require 'dry-configurable'
+require 'dry-validation'
+require 'dry-struct'
+require 'dry-types'
+
+module ISDS
+  ISDS_NAMESPACE = 'http://isds.czechpoint.cz/v20'
+
+  ENDPOINTS = {
+    production: {
+      base_url: 'https://ws1.mojedatovaschranka.cz/',
+      ws_url: 'https://ws1.mojedatovaschranka.cz/soap',
+      ws2_url: 'https://ws1.mojedatovaschranka.cz/vdz_ws/'
+    },
+    test: {
+      base_url: 'https://www.czebox.cz/',
+      ws_url: 'https://www.czebox.cz/soap',
+      ws2_url: 'https://www.czebox.cz/vdz_ws/',
+      wsdl_base: 'https://www.czebox.cz/static/wsdl/v20/'
+    }
+  }.freeze
+
+  SERVICE_ENDPOINT_MAP = {
+    operations: :ws_url,
+    info: :ws_url,
+    search: :ws_url,
+    access: :ws_url,
+    supplementary: :ws_url,
+    large_messages: :ws2_url
+  }.freeze
+
+  class << self
+    def configure
+      yield(configuration)
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end