nuncium 0.13.0

data/lib/nuncium/data_box.rb

@@ -0,0 +1,41 @@
+module Nuncium
+  class DataBox
+    def self.check(options = {})
+      ::Nuncium::WebServices::DbSearch::CheckDataBox
+        .call(options.merge(dbID: ::Nuncium.configuration.data_box))
+    end
+
+    def self.find_by(options = {})
+      ::Nuncium::WebServices::DbSearch::FindDataBox
+        .call(options)
+    end
+
+    def self.owner_info
+      ::Nuncium::WebServices::DbAccess::GetOwnerInfoFromLogin.call
+    end
+
+    def self.credit_info(options = {})
+      ::Nuncium::WebServices::DbSearch::DataBoxCreditInfo
+        .call(options.merge(dbID: ::Nuncium.configuration.data_box))
+    end
+
+    def self.received(options = {})
+      Nuncium::WebServices::DmInfo::GetListOfReceivedMessages
+        .call(options)
+    end
+
+    def self.sent(options = {})
+      Nuncium::WebServices::DmInfo::GetListOfSentMessages
+        .call(options)
+    end
+
+    def self.state_changes(options = {})
+      Nuncium::WebServices::DmInfo::GetMessageStateChanges
+        .call(options)
+    end
+
+    def self.ping
+      Nuncium::WebServices::DmOperations::Ping.call
+    end
+  end
+end

data/lib/nuncium/data_message.rb

@@ -0,0 +1,136 @@
+# rubocop:disable Metrics/ClassLength
+module Nuncium
+  class DataMessage
+    ATTRIBUTES = %w[dmType dmOrdinal dmID dbIDSender dmSender
+                    dmSenderAddress dmSenderType dmRecipient dmRecipientAddress
+                    dmSenderOrgUnit dmSenderOrgUnitNum dbIDRecipient dmRecipientOrgUnit
+                    dmRecipientOrgUnitNum dmToHands dmAnnotation dmRecipientRefNumber
+                    dmSenderRefNumber dmRecipientIdent dmSenderIdent dmLegalTitleLaw
+                    dmLegalTitleYear dmLegalTitleSect dmLegalTitlePar dmLegalTitlePoint
+                    dmPersonalDelivery dmAllowSubstDelivery dmMessageStatus
+                    dmAttachmentSize dmDeliveryTime dmAcceptanceTime dmHash
+                    dmQTimestamp dmAttachments dmAmbiguousRecipient].freeze
+
+    attr_accessor(*ATTRIBUTES)
+
+    def self.find(dmID)
+      Nuncium::WebServices::DmOperations::MessageDownload
+        .call(dmID: dmID)
+    end
+
+    def download(destination = '/tmp')
+      path = "#{destination}/#{dmID}.zfo"
+      File.open(path, 'wb') do |f|
+        f.write(Base64.decode64(signed.body.dmSignature))
+      end
+      path
+    end
+
+    def initialize(params = {})
+      @params = params.dup
+      @status_info = @params.delete('dmDm')
+      @dmAttachments = load_attachments
+      @dmEvents = load_events
+      unified_params = @status_info ? @status_info.merge(@params) : params
+      unified_params.each do |key, value|
+        raise "Not valid attribute of DataMessage #{key}" unless ATTRIBUTES.include?(key)
+        instance_variable_set("@#{key}", parsed_value(value))
+      end
+    end
+
+    def verify
+      Nuncium::WebServices::DmInfo::VerifyMessage
+        .call(dmID: dmID)
+    end
+
+    def authenticate
+      Nuncium::WebServices::DmOperations::AuthenticateMessage
+        .call(dmMessage: signed.body.dmSignature)
+    end
+
+    def signed
+      Nuncium::WebServices::DmOperations::SignedMessageDownload
+        .call(dmID: dmID)
+    end
+
+    def author
+      Nuncium::WebServices::DmInfo::GetMessageAuthor
+        .call(dmID: dmID)
+    end
+
+    def delivery_info
+      Nuncium::WebServices::DmInfo::GetDeliveryInfo
+        .call(dmID: dmID)
+    end
+
+    def signed_delivery_info
+      Nuncium::WebServices::DmInfo::GetSignedDeliveryInfo
+        .call(dmID: dmID)
+    end
+
+    def envelope
+      Nuncium::WebServices::DmInfo::MessageEnvelopeDownload
+        .call(dmID: dmID)
+    end
+
+    def confirm_delivery
+      Nuncium::WebServices::DmInfo::ConfirmDelivery
+        .call(dmID: dmID)
+    end
+
+    def mark_as_downloaded
+      Nuncium::WebServices::DmInfo::MarkMessageAsDownloaded
+        .call(dmID: dmID)
+    end
+
+    def destroy(options = {})
+      Nuncium::WebServices::DmInfo::EraseMessage
+        .call(options.merge(dmID: dmID))
+    end
+
+    def sent?
+      dbIDSender == ::Nuncium.configuration.data_box
+    end
+
+    def received?
+      dbIDSender != ::Nuncium.configuration.data_box
+    end
+
+    private
+
+    def load_events
+      return {} if @params['dmEvents'].blank?
+      events_hash = @params.delete('dmEvents')['dmEvent']
+      if events_hash.is_a?(Array)
+        events_hash.map do |event|
+          ::Nuncium::Responses::Messages::Event.new(event)
+        end
+      else
+        ::Nuncium::Responses::Messages::Event.new(events_hash)
+      end
+    end
+
+    def load_attachments
+      return {} if @status_info&.dig('dmFiles').blank?
+      attachments_hash = @status_info.delete('dmFiles')['dmFile']
+      if attachments_hash.is_a?(Array)
+        attachments_hash.map do |attachment|
+          ::Nuncium::Responses::Messages::Attachment.new(attachment)
+        end
+      else
+        [::Nuncium::Responses::Messages::Attachment.new(attachments_hash)]
+      end
+    end
+
+    def parsed_value(value)
+      return value unless value.is_a?(Hash)
+      raise "Missing parse rule for #{value}" if value.keys.size > 1
+      if value.keys.first == 'xsi:nil' && value.values.first == 'true'
+        nil
+      else
+        false
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/ClassLength

data/lib/nuncium/request.rb

@@ -0,0 +1,120 @@
+module Nuncium
+  class Request
+    def initialize(params = {})
+      params.each do |k, v|
+        instance_variable_set("@#{k}", v)
+      end if params.any?
+    end
+
+    def self.call(params = {})
+      new(params).call
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
+    def call
+      uri = URI(full_url)
+
+      request = Net::HTTP::Post.new(uri)
+      default_headers.each { |k, v| request[k] = v }
+      request.body = to_xml
+
+      https = Net::HTTP.new(uri.hostname, uri.port)
+      https.use_ssl = true
+      https.ssl_version = :TLSv1_2_client
+      if Nuncium.configuration.cert_file
+        https.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        https.cert = Nuncium.configuration.cert_file
+        https.key = Nuncium.configuration.private_key
+        https.verify_depth = 5
+        request.basic_auth(Nuncium.configuration.data_box, '')
+      else
+        request.basic_auth(
+          Nuncium.configuration.username,
+          Nuncium.configuration.password
+        )
+      end
+      response = https.request(request)
+      call_reponse_wrapper(response)
+    end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/AbcSize
+
+    def call_reponse_wrapper(response)
+      response_wrapper.new(response)
+    end
+
+    def default_headers
+      {
+        'Content-Type' => 'text/xml;charset=UTF-8',
+        'Accept-Encoding' => 'gzip,deflate'
+      }
+    end
+
+    def to_xml
+      Nokogiri::XML::Builder.new(encoding: 'utf-8') do |xml|
+        xml[:soapenv].Envelope(envelope_namespaces) do
+          xml[:soapenv].Header
+          xml[:soapenv].Body do
+            body(xml)
+          end
+        end
+      end.to_xml
+    end
+
+    def envelope_namespaces
+      {
+        'xmlns:soapenv' => 'http://schemas.xmlsoap.org/soap/envelope/',
+        'xmlns:v20' => xml_url
+      }
+    end
+
+    def full_url
+      "#{Nuncium.configuration.api_domain}#{api_url}"
+    end
+
+    ##
+    # each subclass needs to have availbale attrs put in constant `ATTRS`
+    #
+    def values(xml)
+      self.class::ATTRS.each do |attribute|
+        value = instance_variable_get("@#{attribute}") || ''
+        xml[:v20].public_send(attribute, value)
+      end
+    end
+
+    ##
+    # Each subclass must implement
+    #   this is whole body of message which differs and also needs to be
+    #   accompanied with att_accessors
+    #
+    def body
+      raise NotImplementedError, "#{self.class} must implement #body!"
+    end
+
+    ##
+    # relative part of url because they differ...
+    #   domain such as https://ws1.czebox.cz is take from config as such:
+    #     `Nuncium.configuration.api_domain`
+    #   it includes `https://` so only ending is supposed to be here
+    #
+    def api_url
+      raise NotImplementedError, "#{self.class} must implement #api_url!"
+    end
+
+    ##
+    # URL will differ based on endpoint that it accesses
+    #
+    def xml_url
+      "https://#{Nuncium.configuration.xml_url}"
+    end
+
+    ##
+    # Here you can change which response object will wrap the reponse
+    #   reponse object has to inherit from `::Nuncium::Response`
+    #
+    def response_wrapper
+      ::Nuncium::Response
+    end
+  end
+end

data/lib/nuncium/response.rb

@@ -0,0 +1,18 @@
+module Nuncium
+  class Response
+    attr_accessor :status, :body
+
+    def initialize(response)
+      @response = Hash.from_xml(response.body)
+    end
+
+    def parsed_body
+      raise HtmlResponseReceived, @response.inspect unless @response['Envelope'].present?
+      @response['Envelope']['Body'][result_key]
+    end
+
+    def result_key
+      @response['Envelope']['Body'].first[0]
+    end
+  end
+end

data/lib/nuncium/responses/body.rb

@@ -0,0 +1,19 @@
+module Nuncium
+  module Responses
+    class Body
+      def initialize(response)
+        (response.keys - self.class::REMOVED_KEYS).each do |key|
+          self.class.send(:attr_accessor, key.to_sym)
+          instance_variable_set("@#{key}", parsed_value(response[key]))
+        end
+      end
+
+      private
+
+      def parsed_value(value)
+        return value unless value.is_a?(Hash)
+        value.keys.first == 'xsi:nil' && value.values.first == 'true' ? nil : false
+      end
+    end
+  end
+end

data/lib/nuncium/responses/data_box.rb

@@ -0,0 +1,14 @@
+module Nuncium
+  module Responses
+    class DataBox < Body
+      REMOVED_KEYS = %w[xmlns:p xmlns:xsi dbStatus].freeze
+
+      def initialize(response)
+        (response.keys - REMOVED_KEYS).each do |key|
+          self.class.send(:attr_accessor, key.to_sym)
+          instance_variable_set("@#{key}", response[key])
+        end
+      end
+    end
+  end
+end

data/lib/nuncium/responses/db/body.rb

@@ -0,0 +1,9 @@
+module Nuncium
+  module Responses
+    module Db
+      class Body < ::Nuncium::Responses::Body
+        REMOVED_KEYS = %w[xmlns:p xmlns:xsi dbStatus].freeze
+      end
+    end
+  end
+end

data/lib/nuncium/responses/db/status.rb

@@ -0,0 +1,13 @@
+module Nuncium
+  module Responses
+    module Db
+      class Status < ::Nuncium::Responses::Status
+        private
+
+        def namespace
+          'db'
+        end
+      end
+    end
+  end
+end

data/lib/nuncium/responses/dm/body.rb

@@ -0,0 +1,9 @@
+module Nuncium
+  module Responses
+    module Dm
+      class Body < ::Nuncium::Responses::Body
+        REMOVED_KEYS = %w[xmlns:q xmlns:p xmlns:xsi dmStatus].freeze
+      end
+    end
+  end
+end

data/lib/nuncium/responses/dm/status.rb

@@ -0,0 +1,13 @@
+module Nuncium
+  module Responses
+    module Dm
+      class Status < ::Nuncium::Responses::Status
+        private
+
+        def namespace
+          'dm'
+        end
+      end
+    end
+  end
+end

data/lib/nuncium/responses/message.rb

@@ -0,0 +1,21 @@
+module Nuncium
+  module Responses
+    class Message < ::Nuncium::Response
+      def initialize(response)
+        super
+      end
+
+      def message
+        ::Nuncium::DataMessage.new(message_hash)
+      end
+
+      private
+
+      def message_hash
+        hash = parsed_body['dmReturnedMessage']
+        hash['dmDm'].delete('xmlns:p')
+        hash
+      end
+    end
+  end
+end

data/lib/nuncium/responses/messages/attachment.rb

@@ -0,0 +1,24 @@
+module Nuncium
+  module Responses
+    module Messages
+      class Attachment
+        attr_accessor :file_type, :file_name, :encoded_content, :decoded_content
+
+        def initialize(hash)
+          @file_type = hash['dmMimeType']
+          @file_name = hash['dmFileDescr']
+          @encoded_content = hash['dmEncodedContent']
+          @decoded_content = Base64.decode64(@encoded_content)
+        end
+
+        def download(destination = '/tmp')
+          file_destination = "#{destination}/#{@file_name}"
+          File.open(file_destination, 'wb') do |f|
+            f.write(@decoded_content)
+          end
+          file_destination
+        end
+      end
+    end
+  end
+end