adobe_pdfservices_ruby 0.1.1

data/lib/pdfservices/operations/base.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module PdfServices
+  module Base
+    class Operation
+      BASE_ENDPOINT = 'https://pdf-services-ue1.adobe.io/operation/'
+      ASSETS_ENDPOINT = 'https://pdf-services-ue1.adobe.io/assets/'
+      STATUS = {
+        in_progress: 'in progress',
+        done: 'done',
+        failed: 'failed'
+      }.freeze
+
+      def initialize(api)
+        @api = api
+      end
+
+      def upload_asset(asset)
+        asset = File.open(asset, 'rb') if asset.is_a?(String)
+        Asset.new(@api).upload(asset)
+      end
+
+      def poll_document_result(url, original_asset, &block)
+        response = @api.get(url)
+        json_response = JSON.parse(response.body.to_s)
+        handle_polling_result(url, json_response, original_asset, &block)
+      end
+
+      private
+
+      def handle_polling_result(url, json_response, original_asset, &block)
+        case json_response['status']
+        when STATUS[:in_progress]
+          handle_in_progress(url, json_response, original_asset, &block)
+        when STATUS[:done]
+          handle_done(json_response, original_asset, &block)
+        when STATUS[:failed]
+          handle_failed(json_response, original_asset, &block)
+        else
+          handle_unexpected_status(json_response, original_asset, &block)
+        end
+      end
+
+      def handle_in_progress(url, json_response, original_asset, &block)
+        block.call(json_response['status'], nil) if block_given?
+        sleep(1) # Consider a more sophisticated retry strategy
+        poll_document_result(url, original_asset, &block)
+      end
+
+      def handle_done(json_response, original_asset, &block)
+        return block.call(json_response['status'], handle_polling_done(json_response, original_asset)) if block_given?
+
+        handle_polling_done(json_response, original_asset)
+      end
+
+      def handle_failed(json_response, original_asset, &block)
+        block.call(json_response['status'], nil) if block_given?
+        handle_polling_failed(json_response, original_asset)
+      end
+
+      def handle_unexpected_status(json_response, original_asset, &block)
+        block.call(json_response['status'], nil) if block_given?
+        handle_polling_unexpected_status(json_response, original_asset)
+      end
+
+      def handle_polling_done(_json_response, original_asset)
+        original_asset.delete
+      end
+
+      def handle_polling_failed(json_response, original_asset)
+        original_asset.delete
+        raise PollingError, "Document extraction failed: #{json_response['error']}"
+      end
+
+      def handle_polling_unexpected_status(json_response, original_asset)
+        original_asset.delete
+        raise PollingError, "Unexpected status: #{json_response['status']}"
+      end
+    end
+  end
+end

data/lib/pdfservices/operations/document_generation/external.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module PdfServices
+  module DocumentGeneration
+    class External < Operation
+      EXTERNAL_OPTIONS = %i[input output params download_from_external].freeze
+      INPUT_KEYS = %i[uri storage].freeze
+      OUTPUT_KEYS = %i[uri storage].freeze
+      PARAMS_KEYS = %i[output_format json_data_for_merge fragments].freeze
+      STORAGE_OPTIONS = %i[S3 SHAREPOINT DROPBOX BLOB].freeze
+
+      def initialize(api)
+        super
+        @download_from_external = false
+        @download_uri = nil
+      end
+
+      def execute(template_path, options = {})
+        validate_options(options)
+        asset = upload_asset(template_path)
+
+        @download_from_external = options[:download_from_external] || false
+
+        @download_uri = options[:output][:uri] if @download_from_external
+
+        response = @api.post(OPERATION_ENDPOINT,
+                             body: request_body(asset.id, options),
+                             headers: request_headers)
+        handle_response(response, asset.id)
+      end
+
+      private
+
+      def request_body(asset_id, options)
+        {
+          assetID: asset_id,
+          input: camelize_keys(options[:input]),
+          output: camelize_keys(options[:output]),
+          params: camelize_keys(options[:params])
+        }
+      end
+
+      def handle_polling_done(response, original_asset)
+        file = @api.get(@download_uri).body if @download_from_external
+        super
+        file || true
+      end
+
+      def validate_options(options)
+        raise ArgumentError, 'Options must be a hash' unless options.is_a?(Hash)
+
+        validate_required_keys(options)
+        validate_input_options(options[:input])
+        validate_output_options(options[:output])
+        validate_params_options(options[:params])
+      end
+
+      def validate_required_keys(options)
+        required_keys = EXTERNAL_OPTIONS - %i[download_from_external]
+        required_keys.each do |key|
+          raise ArgumentError, "Missing required key: #{key}" unless options.key?(key)
+        end
+      end
+
+      def validate_input_options(input_options)
+        raise ArgumentError, 'Input options must be a hash' unless input_options.is_a?(Hash)
+
+        required_input_keys = INPUT_KEYS
+        required_input_keys.each do |key|
+          raise ArgumentError, "Missing required input key: #{key}" unless input_options.key?(key)
+        end
+        validate_storage_options(input_options[:storage])
+      end
+
+      def validate_output_options(output_options)
+        raise ArgumentError, 'Output options must be a hash' unless output_options.is_a?(Hash)
+
+        required_output_keys = OUTPUT_KEYS - %i[uri]
+        required_output_keys.each do |key|
+          raise ArgumentError, "Missing required output key: #{key}" unless output_options.key?(key)
+        end
+        validate_storage_options(output_options[:storage])
+      end
+
+      def validate_storage_option(storage_option)
+        raise ArgumentError, "Invalid storage option: #{storage_option}" unless STORAGE_OPTIONS.include?(storage_option)
+      end
+
+      def validate_params_options(params_options)
+        raise ArgumentError, 'Params options must be a hash' unless params_options.is_a?(Hash)
+
+        required_params_keys = PARAMS_KEYS - %i[output_format fragments]
+        required_params_keys.each do |key|
+          raise ArgumentError, "Missing required params key: #{key}" unless params_options.key?(key)
+        end
+      end
+    end
+  end
+end

data/lib/pdfservices/operations/document_generation/internal.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module PdfServices
+  module DocumentGeneration
+    class Internal < Operation
+      INTERNAL_OPTIONS = %i[output_format json_data_for_merge fragments notifiers].freeze
+
+      def execute(template_path, options = {})
+        validate_options(options)
+        asset = upload_asset(template_path)
+
+        response = @api.post(OPERATION_ENDPOINT,
+                             body: request_body(asset.id, options),
+                             headers: request_headers)
+
+        handle_response(response, asset.id)
+      end
+
+      private
+
+      def request_body(asset_id, options)
+        body = {
+          assetID: asset_id,
+          outputFormat: options.fetch(:output_format, 'pdf'),
+          jsonDataForMerge: options.fetch(:json_data_for_merge, {})
+        }
+        body[:fragments] = options[:fragments] if options[:fragments]
+        body[:notifiers] = options[:notifiers] if options[:notifiers]
+        body
+      end
+
+      def validate_options(options)
+        raise ArgumentError, 'Invalid options' unless options.is_a?(Hash)
+
+        validate_output_format(options[:output_format])
+        validate_fragments(options[:fragments])
+        validate_notifiers(options[:notifiers])
+        validate_keys(options)
+        validate_json_data_for_merge(options[:json_data_for_merge])
+      end
+
+      def validate_output_format(output_format)
+        raise ArgumentError, "Invalid output format: #{output_format}" unless %w[pdf docx].include?(output_format)
+      end
+
+      def validate_fragments(fragments)
+        raise ArgumentError, 'Invalid fragments, must be a hash' unless fragments.is_a?(Hash) || fragments.nil?
+      end
+
+      def validate_notifiers(notifiers)
+        return if notifiers.is_a?(Array) || notifiers.nil?
+
+        raise ArgumentError,
+              'Invalid notifiers, must be an array of hashes'
+      end
+
+      def validate_json_data_for_merge(json_data_for_merge)
+        raise ArgumentError, 'Invalid json_data_for_merge, must be a hash' unless json_data_for_merge.is_a?(Hash)
+      end
+
+      def validate_keys(options)
+        valid_keys = INTERNAL_OPTIONS
+        invalid_keys = options.keys - valid_keys
+        raise ArgumentError, "Invalid options: #{invalid_keys}" unless invalid_keys.empty?
+      end
+
+      def handle_polling_done(json_response, original_asset)
+        asset_id = json_response['asset']['assetID']
+        file = Asset.new(@api).download(asset_id).body
+        super
+        file
+      end
+    end
+  end
+end

data/lib/pdfservices/operations/document_generation.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module PdfServices
+  module DocumentGeneration
+    class Operation < InternalExternalOperation::Operation
+      OPERATION_ENDPOINT = "#{BASE_ENDPOINT}documentgeneration".freeze
+
+      def request_headers
+        { 'Content-Type' => 'application/json' }
+      end
+
+      def handle_response(response, asset_id)
+        unless response.status == 201
+          raise "Unexpected response status from document merge endpoint: #{response.status}, asset_id: #{asset_id}"
+        end
+
+        document_url = response.headers['location']
+        poll_document_result document_url, asset_id
+      end
+
+      def internal_class
+        Internal
+      end
+
+      def external_class
+        External
+      end
+    end
+  end
+end

data/lib/pdfservices/operations/extract_pdf.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module PdfServices
+  module ExtractPdf
+    class Operation < Base::Operation
+      OPERATION_ENDPOINT = "#{BASE_ENDPOINT}extractpdf".freeze
+      VALID_EXTRACT_ELEMENTS = %w[tables text].freeze
+      TABLE_OUTPUT_FORMATS = %w[csv xlsx].freeze
+      RENDITIONS_EXTRACTS = %w[tables figures].freeze
+
+      def execute(source_pdf_path = nil, options = {})
+        validate_options(options)
+        @download_zip = options.delete(:download_zip) || false
+        asset = upload_asset(source_pdf_path)
+
+        response = @api.post(OPERATION_ENDPOINT,
+                             body: extract_pdf_request_body(asset.id, options),
+                             headers: extract_pdf_request_headers)
+        handle_extract_pdf_response(response, asset)
+      end
+
+      private
+
+      def extract_pdf_request_body(asset_id, options)
+        {
+          assetID: asset_id,
+          includeStyling: options.fetch(:include_styling, false),
+          getCharBounds: options.fetch(:get_char_bounds, false),
+          renditionsToExtract: options.fetch(:renditions_to_extract, RENDITIONS_EXTRACTS),
+          tableOutputFormat: options.fetch(:table_output_format, TABLE_OUTPUT_FORMATS.first),
+          elementsToExtract: options.fetch(:extract_elements, VALID_EXTRACT_ELEMENTS)
+        }
+      end
+
+      def extract_pdf_request_headers
+        { 'Content-Type' => 'application/json' }
+      end
+
+      def handle_extract_pdf_response(response, asset)
+        raise OperationError, "Extract PDF operation failed: #{response.body}" unless response.status == 201
+
+        polling_url = response.headers['location']
+        poll_document_result polling_url, asset
+      end
+
+      def handle_polling_done(json_response, original_asset)
+        file_key = @download_zip ? 'resource' : 'content'
+        asset_id = json_response[file_key]['assetID']
+        file = Asset.new(@api).download(asset_id).body
+        super
+        file
+      end
+
+      def validate_options(options)
+        validate_renditions_to_extract(options[:renditions_to_extract])
+        validate_table_output_format(options[:table_output_format])
+        validate_extract_elements(options[:extract_elements])
+      end
+
+      def validate_renditions_to_extract(renditions_to_extract)
+        renditions_to_extract ||= RENDITIONS_EXTRACTS
+        return if (renditions_to_extract - RENDITIONS_EXTRACTS).empty?
+
+        raise ArgumentError, "Invalid renditions_to_extract: #{renditions_to_extract}"
+      end
+
+      def validate_table_output_format(table_output_format)
+        table_output_format ||= TABLE_OUTPUT_FORMATS.first
+        return if TABLE_OUTPUT_FORMATS.include?(table_output_format)
+
+        raise ArgumentError, "Invalid table_output_format: #{table_output_format}"
+      end
+
+      def validate_extract_elements(extract_elements)
+        extract_elements ||= VALID_EXTRACT_ELEMENTS
+        invalid_elements = extract_elements - VALID_EXTRACT_ELEMENTS
+        return if invalid_elements.empty?
+
+        raise ArgumentError, "Invalid extract_elements: #{invalid_elements}"
+      end
+    end
+  end
+end

data/lib/pdfservices/operations/html_to_pdf/external.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module PdfServices
+  module HtmlToPdf
+    class External < Operation
+      EXTERNAL_OPTIONS = %i[input output params download_from_external].freeze
+      INPUT_KEYS = %i[uri storage].freeze
+      OUTPUT_KEYS = %i[uri storage].freeze
+      PARAMS_KEYS = %i[include_header_footer json page_layout].freeze
+      STORAGE_OPTIONS = %i[S3 SHAREPOINT DROPBOX BLOB].freeze
+
+      def initialize(api)
+        super
+        @download_from_external = false
+        @download_uri = nil
+      end
+
+      def execute(url, options = {})
+        @download_from_external = options[:download_from_external] || false
+        options[:input][:uri] = options[:input][:uri] || url
+        validate_options(options)
+
+        @download_uri = options[:output][:uri] if @download_from_external
+
+        response = @api.post(OPERATION_ENDPOINT,
+                             body: request_body(asset.id, options),
+                             headers: request_headers)
+        handle_response(response, asset.id)
+      end
+
+      private
+
+      def request_body(asset_id, options)
+        {
+          assetID: asset_id,
+          input: camelize_keys(options[:input]),
+          output: camelize_keys(options[:output]),
+          params: camelize_keys(options[:params])
+        }
+      end
+
+      def handle_polling_done(_json_response, original_asset)
+        file = @api.get(@download_uri).body if @download_from_external
+        super
+        file || true
+      end
+
+      def validate_options(options)
+        raise ArgumentError, 'Options must be a hash' unless options.is_a?(Hash)
+
+        validate_required_keys(options)
+        validate_input_options(options[:input])
+        validate_output_options(options[:output])
+      end
+
+      def validate_required_keys(options)
+        required_keys = EXTERNAL_OPTIONS - %i[download_from_external]
+        required_keys.each do |key|
+          raise ArgumentError, "Missing required key: #{key}" unless options.key?(key)
+        end
+      end
+
+      def validate_input_options(input_options)
+        raise ArgumentError, 'Input options must be a hash' unless input_options.is_a?(Hash)
+
+        required_input_keys = INPUT_KEYS
+        required_input_keys.each do |key|
+          raise ArgumentError, "Missing required input key: #{key}" unless input_options.key?(key)
+        end
+        validate_storage_options(input_options[:storage])
+      end
+
+      def validate_output_options(output_options)
+        raise ArgumentError, 'Output options must be a hash' unless output_options.is_a?(Hash)
+
+        unless output_options.key?(:uri) && @download_from_external
+          raise ArgumentError,
+                'Output options must contain uri when downloading from external storage'
+        end
+
+        required_output_keys = OUTPUT_KEYS - %i[uri]
+        required_output_keys.each do |key|
+          raise ArgumentError, "Missing required output key: #{key}" unless output_options.key?(key)
+        end
+        validate_storage_options(output_options[:storage])
+      end
+
+      def validate_storage_option(storage_option)
+        return if STORAGE_OPTIONS.include?(storage_option)
+
+        raise ArgumentError,
+              "Invalid storage option: #{storage_option}"
+      end
+    end
+  end
+end

data/lib/pdfservices/operations/html_to_pdf/internal.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module PdfServices
+  module HtmlToPdf
+    class Internal < Operation
+      INTERNAL_OPTIONS = %i[input_url json include_header_footer page_layout notifiers].freeze
+      PAGE_LAYOUT_OPTIONS = %i[page_width page_height].freeze
+
+      def execute(html_file_path, options = {})
+        validate_options(options)
+        asset = upload_asset(html_file_path)
+
+        response = @api.post(OPERATION_ENDPOINT,
+                             body: request_body(asset.id, options),
+                             headers: request_headers)
+
+        handle_response(response, asset.id)
+      end
+
+      private
+
+      def handle_polling_done(json_response, _original_asset_id)
+        asset_id = json_response['asset']['assetID']
+        Asset.new(@api).download(asset_id).body
+      end
+
+      def request_body(asset_id, options)
+        body = {
+          assetID: asset_id,
+          inputUrl: options.fetch(:input_url, ''),
+          pageLayout: camelize_keys(options.fetch(:page_layout, {})),
+          json: transform_json(options.fetch(:json, ''))
+        }
+        body[:notifiers] = options[:notifiers] if options[:notifiers]
+        body
+      end
+
+      def transform_json(json)
+        json.is_a?(String) ? json : json.to_json
+      end
+
+      def validate_options(options)
+        raise ArgumentError, 'Invalid options' unless options.is_a?(Hash)
+
+        options.each_key do |key|
+          raise ArgumentError, "Invalid option: #{key}" unless INTERNAL_OPTIONS.include?(key)
+        end
+
+        validate_required_keys(options)
+        validate_page_layout_options(options[:page_layout]) if options[:page_layout]
+      end
+
+      def validate_required_keys(options)
+        required_keys = INTERNAL_OPTIONS - %i[page_layout notifiers]
+        required_keys.each do |key|
+          raise ArgumentError, "Missing required option: #{key}" unless options.key?(key)
+        end
+      end
+
+      def validate_page_layout_options(options)
+        raise ArgumentError, 'Invalid page layout options' unless options.is_a?(Hash)
+
+        options.each_key do |key|
+          raise ArgumentError, "Invalid page layout option: #{key}" unless PAGE_LAYOUT_OPTIONS.include?(key)
+        end
+      end
+    end
+  end
+end

data/lib/pdfservices/operations/html_to_pdf.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module PdfServices
+  module HtmlToPdf
+    class Operation < InternalExternalOperation::Operation
+      OPERATION_ENDPOINT = "#{BASE_ENDPOINT}htmltopdf".freeze
+
+      def request_headers
+        { 'Content-Type' => 'application/json' }
+      end
+
+      def handle_response(response, asset_id)
+        unless response.status == 201
+          raise "Unexpected response status from document merge endpoint: #{response.status}, asset_id: #{asset_id}"
+        end
+
+        document_url = response.headers['location']
+        poll_document_result document_url, asset_id
+      end
+
+      def internal_class
+        Internal
+      end
+
+      def external_class
+        External
+      end
+    end
+  end
+end

data/lib/pdfservices/operations/internal_external_operation.rb

@@ -0,0 +1,40 @@
+module PdfServices
+  module InternalExternalOperation
+    class Operation < Base::Operation
+      def execute(source_file_path, options = {})
+        operation_class = switch_on_type(options)
+        operation_class.new(@api).execute(source_file_path, options)
+      end
+
+      private
+
+      def switch_on_type(options)
+        type = options[:type] || :internal
+        case type
+        when :internal
+          internal_class
+        when :external
+          external_class
+        end
+      end
+
+      def internal_class
+        raise NotImplementedError, 'Subclasses must implement this method'
+      end
+
+      def external_class
+        raise NotImplementedError, 'Subclasses must implement this method'
+      end
+
+      def camelize_keys(hash)
+        hash.transform_keys { |key| camelize(key.to_s) }
+      end
+
+      def camelize(str)
+        caps = str.split('_').map(&:capitalize)
+        caps[0].downcase!
+        caps.join
+      end
+    end
+  end
+end