rest_pki 1.0.0 → 1.1.0

data/lib/rest_pki/pdf_mark_element.rb

@@ -0,0 +1,54 @@
+module RestPki
+  class PdfMarkElement
+    attr_accessor :element_type, :relative_container, :rotation, :opacity
+
+    def initialize(element_type, relative_container = nil)
+      @element_type = element_type
+      @relative_container = relative_container
+      @rotation = 0
+      @opacity = 100
+    end
+
+    def to_model
+      {
+          elementType: @element_type,
+          relativeContainer: @relative_container,
+          rotation: @rotation,
+          opacity: @opacity,
+      }
+    end
+
+    #region FluentApi
+    def on_container(relative_container)
+      @relative_container = relative_container
+      self
+    end
+  
+    def with_rotation(rotation)
+      @rotation = rotation
+      self
+    end
+  
+    def rotate90_clockwise
+      @rotation = 270
+      self
+    end
+  
+    def rotate90_counter_clockwise
+      @rotation = 90
+      self
+    end
+  
+    def rotate180
+      @rotation = 180
+      self
+    end
+  
+    def with_opacity(opacity)
+      @opacity = opacity
+      self
+    end
+  
+    #endregion
+  end
+end

data/lib/rest_pki/pdf_mark_element_type.rb

@@ -0,0 +1,7 @@
+module RestPki
+  class PdfMarkElementType
+    TEXT = 'Text'
+    IMAGE = 'Image'
+    QR_CODE = 'QRCode'
+  end
+end

data/lib/rest_pki/pdf_mark_image.rb

@@ -0,0 +1,25 @@
+module RestPki
+  class PdfMarkImage
+    attr_accessor :resource
+
+    def initialize(image_content=nil, mime_type=nil)
+      @resource = ResourceContentOrReference.new
+      unless image_content.nil?
+        @resource.content = image_content
+      end
+
+      unless mime_type.nil?
+        @resource.mime_type = mime_type
+      end
+    end
+
+    def to_model
+      if @resource.content.nil? && @resource.url.nil?
+        raise 'The image content was not set, neither its URL'
+      end
+      {
+          resource: @resource.to_model
+      }
+    end
+  end
+end

data/lib/rest_pki/pdf_mark_image_element.rb

@@ -0,0 +1,33 @@
+module RestPki
+  class PdfMarkImageElement < PdfMarkElement
+    attr_accessor :image
+
+    def initialize(relative_container = nil, image = nil)
+      super(PdfMarkElementType::IMAGE, relative_container)
+      @image = image
+    end
+
+    def to_model
+      model = super
+      unless @image.nil?
+        model['image'] = @image.to_model
+      end
+      model
+    end
+
+    #region FluentApi
+
+    def with_mark_image(image)
+      @image = image
+      self
+    end
+  
+    def with_image(image_content, mime_type)
+      @image = PdfMarkImage.new(image_content, mime_type)
+      self
+    end
+  
+    #endregion
+  
+  end
+end

data/lib/rest_pki/pdf_mark_page_options.rb

@@ -0,0 +1,8 @@
+module RestPki
+  class PdfMarkPageOptions
+    ALL_PAGES = 'AllPages'
+    SINGLE_PAGE = 'SinglePage'
+    SINGLE_PAGE_FROM_END = 'SinglePageFromEnd'
+    NEW_PAGE = 'NewPage'
+  end
+end

data/lib/rest_pki/pdf_mark_qr_code_element.rb

@@ -0,0 +1,32 @@
+module RestPki
+  class PdfMarkQRCodeElement < PdfMarkElement
+    attr_accessor :qr_code_data, :draw_quiet_zone
+
+    def initialize(relative_container = nil, qr_code_data = nil)
+      super(PdfMarkElementType::QR_CODE, relative_container)
+      @qr_code_data = qr_code_data
+      @draw_quiet_zone = false
+    end
+
+    def to_model
+      model = super
+      model['qrCodeData'] = @qr_code_data
+      model['qrCodeDataDrawQuietZones'] = @draw_quiet_zone
+      model
+    end
+
+    #region FluentApi
+
+    def with_qr_code_data(qr_code_data)
+      @qr_code_data = qr_code_data
+      self
+    end
+  
+    def draw_quiet_zone
+      @draw_quiet_zone = true
+      self
+    end
+  
+    #endregion
+  end
+end

data/lib/rest_pki/pdf_mark_text_element.rb

@@ -0,0 +1,47 @@
+module RestPki
+  class PdfMarkTextElement < PdfMarkElement
+    attr_accessor :text_sections, :align
+
+    def initialize(relative_container=nil, text_sections=[])
+      super(PdfMarkElementType::TEXT, relative_container)
+      @text_sections = text_sections
+      @align = 'Left'
+    end
+
+    def to_model
+      model = super
+      model['textSections'] = @text_sections.map { |s| s.to_model }
+      model['align'] = @align
+      model
+    end
+
+    #region FluentApi
+
+    def align_text_left
+      @align = 'Left'
+      self
+    end
+  
+    def align_text_right
+      @align = 'Right'
+      self
+    end
+  
+    def align_text_center
+      @align = 'Center'
+      self
+    end
+  
+    def add_section(section)
+      @text_sections.push(section)
+      self
+    end
+  
+    def add_section_with_text(text)
+      @text_sections.push(PdfTextSection.new(text))
+      self
+    end
+  
+    #endregion
+  end
+end

data/lib/rest_pki/pdf_marker.rb

@@ -0,0 +1,61 @@
+require 'base64'
+module RestPki
+  class PdfMarker
+    attr_accessor :marks, :measurement_units, :page_optimization, :abort_if_signed
+    attr_reader :file_content
+
+    def initialize(client)
+      @client = client
+      @marks = []
+      @measurement_units = PadesMeasurementUnits::CENTIMETERS
+      @page_optimization = nil
+      @abort_if_signed = nil
+      @file_content = nil
+    end
+
+    def set_file_from_path(path)
+      File.open(path, 'rb') do |f|
+        @file_content = f.read
+      end
+    end
+
+    # region set_file
+
+    def set_file_from_content_raw(content_raw)
+      @file_content = content_raw
+    end
+
+    def set_file_from_content_base64(content_base64)
+      content = nil
+      unless content_base64.nil?
+        content = Base64.decode64(content_base64)
+      end
+      @file_content = content
+    end
+
+    # endregion
+
+    def apply
+      if @file_content.nil?
+        raise 'No file was provided'
+      end
+
+      marks = @marks.map { |m| m.to_model }
+      page_optimization = nil
+      unless @page_optimization.nil?
+        page_optimization = @page_optimization.to_model
+      end
+      request = {
+          marks: marks,
+          measurementUnits: @measurement_units,
+          pageOptimization: page_optimization,
+          abortIfSigned: abort_if_signed
+      }
+      request['file'] = {
+        content: Base64.encode64(@file_content)
+      }
+      model = @client.post('Api/Pdf/AddMarks', request, 'pdf_marker_model')
+      model.file_content
+    end
+  end
+end

data/lib/rest_pki/pdf_text_section.rb

@@ -0,0 +1,57 @@
+module RestPki
+  class PdfTextSection
+    attr_accessor :text, :color, :font_size, :style
+
+    def initialize(text=nil, color=nil, font_size=nil)
+      if color.nil?
+        color = Color.from_rgb_string('#000000') # White
+      end
+      @style = PdfTextStyle::NORMAL
+      @text = text
+      @color = color
+      @font_size = font_size
+    end
+
+    def to_model
+      color = nil
+      unless @color.nil?
+        color = @color
+      end
+      {
+          style: @style,
+          text: @text,
+          color: color,
+          fontSize: @font_size,
+      }
+    end
+
+    #region FluentApi
+
+    def with_font_size(font_size)
+      @font_size = font_size
+      self
+    end
+  
+    def with_text(text)
+      @text = text
+      self
+    end
+  
+    def bold
+      @style = PdfTextStyle::BOLD
+      self
+    end
+  
+    def italic
+      @style = PdfTextStyle::ITALIC
+      self
+    end
+  
+    def with_color(color)
+      @color = color
+      self
+    end
+  
+    #endregion
+  end
+end

data/lib/rest_pki/pdf_text_style.rb

@@ -0,0 +1,7 @@
+module RestPki
+  class PdfTextStyle
+    NORMAL = 'Normal'
+    BOLD = 'Bold'
+    ITALIC = 'Italic'
+  end
+end

data/lib/rest_pki/pk_algorithms.rb

@@ -0,0 +1,173 @@
+module RestPki
+
+    class SignatureAlgorithm
+        attr_reader :name, :oid, :xml_uri, :digest_algorithm, :pk_algorithm
+        def initialize(name, oid, xml_uri, digest_algorithm, pk_algorithm)
+            @name = name
+            @oid = oid
+            @xml_uri = xml_uri
+            @digest_algorithm = digest_algorithm
+            @pk_algorithm = pk_algorithm
+        end
+
+        def self.MD5_WITH_RSA; RSASignatureAlgorithm.new(DigestAlgorithm.MD5) end
+        def self.SHA1_WITH_RSA; RSASignatureAlgorithm.new(DigestAlgorithm.SHA1) end
+        def self.SHA256_WITH_RSA; RSASignatureAlgorithm.new(DigestAlgorithm.SHA256) end
+        def self.SHA384_WITH_RSA; RSASignatureAlgorithm.new(DigestAlgorithm.SHA384) end
+        def self.SHA512_WITH_RSA; RSASignatureAlgorithm.new(DigestAlgorithm.SHA512) end
+      
+        def self.algorithms
+            [
+               SignatureAlgorithm.MD5_WITH_RSA,
+               SignatureAlgorithm.SHA1_WITH_RSA,
+               SignatureAlgorithm.SHA256_WITH_RSA,
+               SignatureAlgorithm.SHA384_WITH_RSA,
+               SignatureAlgorithm.SHA512_WITH_RSA
+            ]
+        end
+      
+        def self.safe_algorithms
+            [
+                SignatureAlgorithm.SHA256_WITH_RSA,
+                SignatureAlgorithm.SHA384_WITH_RSA,
+                SignatureAlgorithm.SHA512_WITH_RSA
+            ]
+        end
+      
+        def self.get_instance_by_name(name)
+            begin
+                sig = SignatureAlgorithm._algorithms.find{ |s| s.name == name}
+            rescue => exception
+                raise "Unrecognized digest algorithm name: #{name}"
+            end
+            sig
+        end
+      
+        def self.get_instance_by_oid(oid)
+            begin
+                sig = SignatureAlgorithm._algorithms.find{ |s| s.oid == oid}
+            rescue => exception
+                raise "Unrecognized digest algorithm oid: #{oid}"
+            end
+            sig
+        end
+      
+        def self.get_instance_by_xml_uri(xml_uri)
+            begin
+                sig = SignatureAlgorithm._algorithms.find{ |s| s.xml_uri == xml_uri}
+            rescue => exception
+                raise "Unrecognized digest algorithm XML URI: #{xml_uri}"
+            end
+            sig
+        end
+      
+        def self.get_instance_by_api_model(model)
+            algorithm = model['algorithm']
+            case algorithm
+            when 'MD5WithRSA'
+                return SignatureAlgorithm.MD5_WITH_RSA
+            when 'SHA1WithRSA'
+                return SignatureAlgorithm.SHA1_WITH_RSA
+            when 'SHA256WithRSA'
+                return SignatureAlgorithm.SHA256_WITH_RSA
+            when 'SHA384WithRSA'
+                return SignatureAlgorithm.SHA384_WITH_RSA
+            when 'SHA512WithRSA'
+                return SignatureAlgorithm.SHA512_WITH_RSA
+            else
+                raise "Unsupported signature algorithm: #{algorithm}"
+            end
+        end
+    end
+    class RSASignatureAlgorithm < SignatureAlgorithm
+        def initialize(digest_algorithm)
+            name = "#{digest_algorithm.name} with RSA"
+            pk_algorithm = PKAlgorithm.RSA
+            oid = nil
+            xml_uri = nil
+            case digest_algorithm
+            when DigestAlgorithm.MD5
+                oid = Oids.oids["MD5_WITH_RSA"]
+                xml_uri = 'http://www.w3.org/2001/04/xmldsig-more#rsa-md5'
+            when DigestAlgorithm.SHA1
+                oid = Oids.oids["SHA1_WITH_RSA"]
+                xml_uri = 'http://www.w3.org/2000/09/xmldsig#rsa-sha1'
+            when DigestAlgorithm.SHA256
+                oid = Oids.oids["SHA256_WITH_RSA"]
+                xml_uri = 'http://www.w3.org/2001/04/xmldsig-more#rsa-sha256'
+            when DigestAlgorithm.SHA384
+                oid = Oids.oids["SHA384_WITH_RSA"]
+                xml_uri = 'http://www.w3.org/2001/04/xmldsig-more#rsa-sha384'
+            when DigestAlgorithm.SHA512
+                oid = Oids.oids["SHA512_WITH_RSA"]
+                xml_uri = 'http://www.w3.org/2001/04/xmldsig-more#rsa-sha512'
+            else
+                raise "Unsupported digest algorithm: #{digest_algorithm}"
+            end
+
+            super(name, oid, xml_uri, digest_algorithm, pk_algorithm)
+        end
+    end
+    class PKAlgorithm
+        attr_reader :name, :oid
+        def initialize(name, oid)
+            @name = name
+            @oid = oid
+        end
+        
+        def ==(comparison_object)
+            if comparison_object.equal?(self)
+                return true
+            end
+            unless comparison_object.instance_of?(self.class)
+                return false
+            end
+            self.oid == comparison_object.oid
+        end
+
+        def self.RSA; RSAPKAlgorithm.new end
+      
+        def self._algorithms
+            [PKAlgorithm.RSA]
+        end
+      
+        def self.get_instance_by_name(name)
+            begin
+                alg = PKAlgorithm.algorithms.find{|a| a.name == name}
+            rescue => exception
+                raise "Unrecognized private key algorithm name: #{name}"
+            end
+            alg
+        end
+      
+        def self.get_instance_by_oid(oid) 
+            begin
+                alg = PKAlgorithm.algorithms.find{|a| a.name == oid}
+            rescue => exception
+                raise "Unrecognized private key algorithm oid: #{oid}"
+            end
+            alg
+        end
+      
+        def self.get_instance_by_api_model(algorithm)
+            case algorithm
+            when 'RSA'
+                return PKAlgorithm.RSA
+            else
+                raise "Unsupported private key algorithms #{algorithm}"
+            end
+        end
+      
+    end
+    class RSAPKAlgorithm < PKAlgorithm
+        def initialize
+            name = 'RSA'
+            oid = Oids.oids["RSA"]
+            super(name, oid)
+        end
+      
+        def self.get_signature_algorithm(digest_algorithm)
+            RSASignatureAlgorithm.new(digest_algorithm)
+        end
+    end
+end