rest_pki 1.0.0

data/lib/rest_pki/object.rb

@@ -0,0 +1,126 @@
+module RestPki
+  class RestPkiObject
+    attr_reader :attributes
+
+    RESOURCES = Dir[File.expand_path('../resources/*.rb', __FILE__)].map do |path|
+      File.basename(path, '.rb').to_sym
+    end
+
+    def initialize(response = {}, object)
+      @attributes         = Hash.new
+      @unsaved_attributes = Set.new
+      update(response, object)
+    end
+
+    def []=(key,value)
+      @attributes[key] = value
+      @unsaved_attributes.add key
+    end
+
+    def unsaved_attributes
+      Hash[@unsaved_attributes.map do |key|
+        [ key, to_hash_value(self[key], :unsaved_attributes) ]
+      end]
+    end
+
+    def empty?
+      @attributes.empty?
+    end
+
+    def ==(other)
+      self.class == other.class && id == other.id
+    end
+
+    def to_hash
+      Hash[@attributes.map do |key, value|
+        [ key, to_hash_value(value, :to_hash) ]
+      end]
+    end
+
+    def respond_to?(name, include_all = false)
+      return true if name.to_s.end_with? '='
+
+      @attributes.has_key?(name.to_s) || super
+    end
+
+    protected
+    def update(attributes, object)
+      removed_attributes = @attributes.keys - attributes.keys
+
+      removed_attributes.each do |key|
+        @attributes.delete key
+      end
+
+      attributes.each do |key, value|
+        key = key.to_s
+
+        @attributes[key] = RestPkiObject.convert(value, object)
+        @unsaved_attributes.delete key
+      end
+    end
+
+    def to_hash_value(value, type)
+      case value
+      when RestPkiObject
+        value.send type
+      when Array
+        value.map do |v|
+          to_hash_value v, type
+        end
+      else
+        value
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      name = name.to_s
+
+      unless block_given?
+        if name.end_with?('=') && args.size == 1
+          attribute_name = name[0...-1]
+          return self[attribute_name] = args[0]
+        end
+
+        if args.size == 0
+          return self[name]
+        end
+      end
+
+      if attributes.respond_to? name
+        return attributes.public_send name, *args, &block
+      end
+
+      super name, *args, &block
+    end
+
+    class << self
+
+      def convert(response, object)
+        case response
+        when Array
+          response.map{ |i| convert(i, object) }
+        when Hash
+          resource_class_for(object).new(response, object)     #response['object']).new(response)
+        else
+          response
+        end
+      end
+
+      protected
+      def resource_class_for(resource_name)
+        return RestPki::RestPkiObject if resource_name.nil?
+
+        if RESOURCES.include? resource_name.to_sym
+          Object.const_get "RestPki::#{capitalize_name resource_name}"
+        else
+          RestPki::RestPkiObject
+        end
+      end
+
+      def capitalize_name(name)
+        name.gsub(/(\A\w|\_\w)/){ |str| str.gsub('_', '').upcase }
+      end
+
+    end
+  end
+end

data/lib/rest_pki/pades_signature_finisher.rb

@@ -0,0 +1,50 @@
+
+module RestPki
+    class PadesSignatureFinisher < SignatureFinisher
+
+        def initialize(restpki_client)
+            super(restpki_client)
+            @signed_pdf_content = nil
+        end
+
+        def finish
+            if @token.to_s.blank?
+                raise 'The token was not set'
+            end
+
+            if @signature.to_s.blank?
+                response = @restpki_client.post("Api/PadesSignatures/#{@token}/Finalize", nil, 'pades_model')
+            else
+                request = { signature: @signature }
+                response = @restpki_client.post("Api/PadesSignatures/#{@token}/SignedBytes", request, 'pades_model')
+            end
+
+            @signed_pdf_content = Base64.decode64(response['signedPdf'])
+            @callback_argument = response['callbackArgument']
+            @certificate_info = response['certificate']
+            @done = true
+
+            @signed_pdf_content
+        end
+
+        def signed_pdf_content
+            unless @done
+                raise 'The field "signed_pdf_content" can only be accessed after calling the finish method'
+            end
+
+            @signed_pdf_content
+        end
+
+        def write_signed_pdf(pdf_path)
+            unless @done
+                raise 'The method write_signed_pdf can only be called after calling the finish method'
+            end
+
+            file = File.open(pdf_path, 'wb')
+            file.write(@signed_pdf_content)
+            file.close
+
+            nil # No value is returned.
+        end
+    end
+end

data/lib/rest_pki/pades_signature_starter.rb

@@ -0,0 +1,110 @@
+require 'base64'
+
+module RestPki
+    class PadesSignatureStarter < SignatureStarter
+        attr_accessor :visual_representation
+
+        def initialize(restpki_client)
+            super(restpki_client)
+            @pdf_content_base64 = nil
+            @visual_representation = nil
+        end
+
+        #region set_pdf_tosign
+
+        def set_pdf_tosign_from_path(pdf_path)
+            file = File.open(pdf_path, 'rb')
+            @pdf_content_base64 = Base64.encode64(file.read)
+            file.close
+
+            @pdf_content_base64
+        end
+
+        def set_pdf_tosign_from_raw(content_raw)
+            @pdf_content_base64 = Base64.encode64(content_raw)
+        end
+
+        def set_pdf_tosign_from_base64(content_base64)
+            @pdf_content_base64 = content_base64
+        end
+
+        def set_pdf_content_tosign(content_raw)
+            set_pdf_tosign_from_raw(content_raw)
+        end
+
+        def set_pdf_file_tosign(pdf_path)
+            set_pdf_tosign_from_path(pdf_path)
+        end
+
+        #endregion
+
+        def start_with_webpki
+            if @pdf_content_base64.to_s.blank?
+                raise 'The PDF to sign was not set'
+            end
+            if @signature_policy_id.to_s.blank?
+                raise 'The signature policy was not set'
+            end
+
+            request = {
+                securityContextId: @security_context_id,
+                pdfToSign: @pdf_content_base64,
+                signaturePolicyId: @signature_policy_id,
+                callbackArgument: @callback_argument,
+                visualRepresentation: @visual_representation,
+                ignoreRevocationStatusUnknown: @ignore_revocation_status_unknown
+            }
+            unless @signer_certificate_base64.to_s.blank?
+                request['certificate'] = Base64.encode64(@signer_certificate_base64)
+            end
+
+            response = @restpki_client.post('Api/PadesSignatures', request, 'pades_model')
+
+            unless response['certificate'].nil?
+                @certificate = response['certificate']
+            end
+            @done = true
+
+            response['token']
+        end
+
+        def start
+            if @pdf_content_base64.to_s.blank?
+                raise 'The PDF to sign was not set'
+            end
+            if @signature_policy_id.to_s.blank?
+                raise 'The signature policy was not set'
+            end
+            if @signer_certificate_base64.to_s.blank?
+                raise 'The signer certificate was not set'
+            end
+
+            request = {
+                securityContextId: @security_context_id,
+                pdfToSign: @pdf_content_base64,
+                signaturePolicyId: @signature_policy_id,
+                callbackArgument: @callback_argument,
+                visualRepresentation: @visual_representation,
+                ignoreRevocationStatusUnknown: @ignore_revocation_status_unknown
+            }
+            unless @signer_certificate_base64.to_s.blank?
+                request['certificate'] = Base64.encode64(@signer_certificate_base64)
+            end
+
+            response = @restpki_client.post('Api/PadesSignatures', request, 'pades_model')
+
+            unless response['certificate'].nil?
+                @certificate = response['certificate']
+            end
+            @done = true
+
+            {
+                :token => response['token'],
+                :to_sign_data => response['toSignData'],
+                :to_sign_hash => response['toSignHash'],
+                :digest_algorithm_oid => response['digestAlgorithmOid'],
+                :signature_algorithm => get_signature_algorithm(response['digestAlgorithmOid'])
+            }
+        end
+    end
+end

data/lib/rest_pki/pades_visual_positioning_presets.rb

@@ -0,0 +1,32 @@
+
+module RestPki
+    class PadesVisualPositioningPresets
+        @@cached_presets = Hash.new
+
+        def self.get_footnote(restpki_client, page_number=nil, rows=nil)
+            url_segment = 'Footnote'
+            unless page_number.to_s.blank?
+                url_segment += '?pageNumber=' + page_number
+            end
+            unless rows.to_s.blank?
+                url_segment += '?rows=' + rows
+            end
+            get_preset(restpki_client, url_segment)
+        end
+
+        def self.get_new_page(restpki_client)
+            get_preset(restpki_client, 'NewPage')
+        end
+
+
+        private
+        def self.get_preset(restpki_client, url_segment)
+            if @@cached_presets.to_hash.has_key? url_segment
+                return @@cached_presets[url_segment]
+            end
+            preset = restpki_client.get("Api/PadesVisualPositioningPresets/#{url_segment}", 'pades_model')
+            @@cached_presets[url_segment] = preset
+            preset
+        end
+    end
+end

data/lib/rest_pki/resources/authentication_model.rb

@@ -0,0 +1,5 @@
+module RestPki
+  class AuthenticationModel < RestPkiObject
+
+  end
+end

data/lib/rest_pki/resources/cades_model.rb

@@ -0,0 +1,5 @@
+module RestPki
+    class CadesModel < RestPkiObject
+
+    end
+end

data/lib/rest_pki/resources/pades_model.rb

@@ -0,0 +1,5 @@
+module RestPki
+  class PadesModel < RestPkiObject
+
+  end
+end

data/lib/rest_pki/resources/response_model.rb

@@ -0,0 +1,5 @@
+module RestPki
+    class ResponseModel < RestPkiObject
+
+    end
+end

data/lib/rest_pki/resources/xml_model.rb

@@ -0,0 +1,5 @@
+
+module RestPki
+  class XmlModel < RestPkiObject
+  end
+end

data/lib/rest_pki/rest_base_error.rb

@@ -0,0 +1,12 @@
+
+module RestPki
+    class RestBaseError < StandardError
+        attr_reader :verb, :url
+
+        def initialize(message, verb, url)
+            super(message)
+            @verb = verb
+            @url = url
+        end
+    end
+end

data/lib/rest_pki/rest_error.rb

@@ -0,0 +1,16 @@
+
+module RestPki
+    class RestError < RestBaseError
+        attr_reader :status_code, :error_message
+
+        def initialize(verb, url, status_code, error_message=nil)
+            message = "REST action #{verb} #{url} returned HTTP error #{status_code}"
+            unless error_message.to_s.blank?
+                message += ": #{error_message}"
+            end
+            super(message, verb, url)
+            @status_code = status_code
+            @error_message = error_message
+        end
+    end
+end

data/lib/rest_pki/rest_unreachable_error.rb

@@ -0,0 +1,13 @@
+
+module RestPki
+    class RestUnreachableError < RestBaseError
+
+        def initialize(verb, url, error_message=nil)
+            message = "REST action #{verb} #{url} unreachable"
+            unless error_message.to_s.blank?
+                message += ": #{error_message}"
+            end
+            super(message, verb, url)
+        end
+    end
+end

data/lib/rest_pki/restpki_client.rb

@@ -0,0 +1,95 @@
+require 'uri'
+require 'rest_client'
+require 'multi_json'
+
+module RestPki
+    class RestPkiClient
+
+        def initialize(endpoint_url, access_token)
+            @endpoint_url = endpoint_url
+            @access_token = access_token
+        end
+
+        def get(url, object_model)
+            verb = 'GET'
+            params = get_rest_params(verb, url)
+
+            begin
+                response = RestClient::Request.execute params
+            rescue RestClient::Exception => ex
+                response = RestPkiObject.convert({
+                    :code => ex.http_code,
+                    :body => ex.response
+                }, 'response_model')
+            rescue Exception => ex
+                raise RestUnreachableError.new(verb, url, ex.message)
+            end
+            check_response(verb, url, response)
+
+            RestPkiObject.convert(MultiJson.decode(response.body), object_model)
+        end
+
+        def post(url, data, object_model)
+            verb = 'POST'
+            params = get_rest_params(verb, url, data)
+
+            begin
+                response = RestClient::Request.execute params
+            rescue RestClient::Exception => ex
+                response = RestPkiObject.convert({
+                    :code => ex.http_code,
+                    :body => ex.response
+                }, 'response_model')
+            rescue Exception => ex
+                raise RestUnreachableError.new(verb, url, ex.message)
+            end
+            check_response(verb, url, response)
+
+            RestPkiObject.convert(MultiJson.decode(response.body), object_model)
+        end
+
+        def get_authentication
+            Authentication.new(self)
+        end
+
+        private
+        def get_rest_params(method, url, params=nil)
+            {
+                method: method,
+                url: @endpoint_url + url,
+                payload: params ? MultiJson.encode(params) : nil,
+                open_timeout: 30,
+                timeout: 90,
+                headers: {
+                    'Content-Type': 'application/json; charset=utf8',
+                    Accept: 'application/json',
+                    Authorization: "Bearer #{@access_token}",
+                    'X-RestPki-Client': "Ruby #{RestPki::VERSION}"
+                }
+            }
+        end
+
+        def check_response(verb, url, http_response)
+            status_code = http_response.code
+            if status_code < 200 || status_code > 299
+                ex = nil
+                begin
+                    response = MultiJson.decode http_response.body
+                    if status_code == 422 && response['code'].to_s.blank?
+                        if response['code'] == 'ValidationError'
+                            vr = ValidationResults.new(response['validationResults'])
+                            ex = ValidationError.new(verb, url, vr)
+                        else
+                            ex = RestPkiError.new(verb, url, response['code'], response['detail'])
+                        end
+                    else
+                        ex = RestError.new(verb, url, status_code, response['message'])
+                    end
+                rescue => e
+                    ex = RestError.new(verb, url, status_code)
+                end
+                raise ex
+            end
+        end
+    end
+end