adobe_doc_api 0.1.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c788e21a963142ba23c04928654534ab9d9641f4ed7863245f7af3f3bda19b3c
-  data.tar.gz: b7392b28f2a5024513687e22c4769c50660525e36290cb6e829c3b8a3e94a81f
+  metadata.gz: 88a17a7824cbc56df0cc3b1a4fe8ce43e51ac80d2f49c8aeb2bf3bd3d3afc4b6
+  data.tar.gz: 4ab99d5fd436027b5a8dfa58610969ec6955cd592474e55ac0285def3c4f62ce
 SHA512:
-  metadata.gz: 1e2e36e5893bc031cb15b97eaa4f0de0c789c09831cb5724c05fbced6c32c3662dcdd4295539391be6ba54cf1fceb51cd1c92a4ed06e49ab2a00697de89c31cd
-  data.tar.gz: 00f64a23bed62d1254ba091bcb5035db6432bc47f3976a31697b5702dd3f58c5fc0c1d1ea9bedd5b3e2c7401cb31bd02bdd8b64380249401679a04ad688fd079
+  metadata.gz: a0298bd962026cc2c072239d0a8dda4fbca883b94389f40daa5efc843a2256b239a52bb3c21b4900c3098338b10f78e47d22c52745527b1df739ea80c46bcd3e
+  data.tar.gz: e8c44532b30fe23d98076fa67f5ce0b49d9def18f5593142fbed19f75410025d5461d7f87604a48f07f0b1a458f19b4f64283b49bfb77f666b288ba2ae6e5122

data/CHANGELOG.md

@@ -1,4 +1,9 @@
-## [Unreleased]
+## [0.3.0] - 2023-06-20
+- Migrated authentication from JWT to OAuth server-to-server
+- Updated configuration to accept OAuth scopes
+
+## [0.2.1] - 2023-06-20
+- Updates to Adobe PDF Services API
 
 ## [0.1.4] - 2021-12-30
 - Fix issue with parsing file boundary that included \r\n

data/README.md

@@ -1,6 +1,6 @@
 # AdobeDocApi
 
-This is still a work in progress. Use at your own risk.
+This is still a work in progress and breaking changes may be made, but I will do my best to update the README when features have been changed.
 
 ## Installation
 
@@ -18,38 +18,39 @@ Or install it yourself as:
 
     $ gem install adobe_doc_api
 
-## Configuration 
-* Configuration can be overridden if you need by passing the values to AdobeDocApi::Client.new
+## Configuration
 ```ruby
 AdobeDocApi.configure do |config|
-  config.client_id = nil
-  config.client_secret = nil
-  config.org_id = nil
-  config.tech_account_id = nil
-  config.private_key_path = nil
+    config.client_id = nil
+    config.client_secret = nil
+    config.scopes = nil
+end
+```
+### Recommended configuration if using Rails 6+
+```ruby
+AdobeDocApi.configure do |config|
+    config.client_id = Rails.application.credentials.dig(:adobe_doc, :client_id)
+    config.client_secret = Rails.application.credentials.dig(:adobe_doc, :client_secret)
+    config.scopes = Rails.application.credentials.dig(:adobe_doc, :scopes)
 end
 ```
-
 ## Usage
 
 ```ruby
-key_path = "../full_path_to/private.key"
 template_path = "../full_path_to/disclosure.docx"
 output_path = "../full_path_to_output/output.docx"
 json_data = { 'DocTag': 'Value', 'DocTag2': 'Value2'}
 
 client = AdobeDocApi::Client.new
-
-# Without configuration you must pass these values
-# client = AdobeDocApi::Client.new(private_key: key_path, client_id: ENV['adobe_client_id'], client_secret: ENV['adobe_client_secret']org_id: ENV['adobe_org_id'], tech_account_id: ENV['adobe_tech_account_id'], access_token: nil)
-
 client.submit(json: json_data, template: template_path, output: output_path)
 # returns true or false if file was saved to output_path
 ```
-
-## Todo
-- [x] Add multipart parsing to improve saving the file from the response
-- [ ] Add documentation
+### Usage without configuration
+```ruby
+client = AdobeDocApi::Client.new(client_id: adobe_client_id,
+                                 client_secret: adobe_client_secret,
+                                 scopes: adobe_scopes)
+```
 
 ## Contributing
 

data/lib/adobe_doc_api/client.rb

@@ -1,136 +1,176 @@
-require "faraday"
-require "faraday_middleware"
-require "jwt"
-require "openssl"
+require "net/http"
+require "json"
 
 module AdobeDocApi
   class Client
-    JWT_URL = "https://ims-na1.adobelogin.com/ims/exchange/jwt/".freeze
-    API_ENDPOINT_URL = "https://cpf-ue1.adobe.io".freeze
+    OAUTH_URL = "https://ims-na1.adobelogin.com/ims/token/v3".freeze
+    API_ENDPOINT_URL = "https://pdf-services-ue1.adobe.io/operation/documentgeneration"
+    attr_reader :location_url, :raw_response, :client_id, :client_secret, :scopes
 
-    attr_reader :access_token, :location_url, :raw_response, :client_id, :client_secret, :org_id, :tech_account_id
-
-    def initialize(private_key: nil, client_id: nil, client_secret: nil, org_id: nil, tech_account_id: nil, access_token: nil)
-      # TODO Need to validate if any params are missing and return error
+    def initialize(client_id: nil, client_secret: nil, scopes: nil)
       @client_id = client_id || AdobeDocApi.configuration.client_id
       @client_secret = client_secret || AdobeDocApi.configuration.client_secret
-      @org_id = org_id || AdobeDocApi.configuration.org_id
-      @tech_account_id = tech_account_id || AdobeDocApi.configuration.tech_account_id
-      @private_key_path = private_key || AdobeDocApi.configuration.private_key_path
+      @scopes = scopes || AdobeDocApi.configuration.scopes
       @location_url = nil
       @output_file_path = nil
       @raw_response = nil
-      @access_token = access_token || get_access_token(@private_key_path)
+      @access_token = get_access_token
     end
 
-    def get_access_token(private_key)
-      jwt_payload = {
-        "iss" => @org_id,
-        "sub" => @tech_account_id,
-        "https://ims-na1.adobelogin.com/s/ent_documentcloud_sdk" => true,
-        "aud" => "https://ims-na1.adobelogin.com/c/#{@client_id}",
-        "exp" => (Time.now.utc + 60).to_i
-      }
+    def submit(json:, template:, output:)
+      @output = output
+      @asset_id, upload_uri = upload_presigned_uri
+      upload_asset(upload_uri, template: template)
+      document_generation(json: json)
+    end
 
-      rsa_private = OpenSSL::PKey::RSA.new File.read(private_key)
+    private
 
-      jwt_token = JWT.encode jwt_payload, rsa_private, "RS256"
+    def get_access_token
+      url = URI(OAUTH_URL)
+      https = Net::HTTP.new(url.host, url.port)
+      https.use_ssl = true
+      request = Net::HTTP::Post.new(url)
+      request["Content-Type"] = "application/x-www-form-urlencoded"
+      request.body = "grant_type=client_credentials&client_id=#{@client_id}&client_secret=#{@client_secret}&scope=#{@scopes}"
+      response = https.request(request)
+      if response.code.to_i != 200
+        raise Error.new(status_code: response.code, msg: "Failed to get access token: #{response.body}")
+      else
+        puts "Access token retrieved successfully"
+        JSON.parse(response.body)["access_token"]
+      end
+    end
 
-      connection = Faraday.new do |conn|
-        conn.response :json, content_type: "application/json"
+    def upload_presigned_uri
+
+      url = URI("https://pdf-services-ue1.adobe.io/assets")
+      https = Net::HTTP.new(url.host, url.port)
+      https.use_ssl = true
+      request = Net::HTTP::Post.new(url)
+      request["Content-Type"] = "application/json"
+      request["X-API-Key"] = @client_id
+      request["Authorization"] = "bearer #{@access_token}"
+      request.body ='{"mediaType": "application/vnd.openxmlformats-officedocument.wordprocessingml.document"}'
+      response = https.request(request)
+
+      if response.code.to_i != 200
+        raise Error.new(status_code: response.code, msg: "Failed to create asset: #{response.body}")
+      else
+        puts "Asset created successfully"
+        response_body = JSON.parse(response.body)
+        asset_id = response_body["assetID"]
+        upload_uri = response_body["uploadUri"]
+        return asset_id, upload_uri
       end
-      response = connection.post JWT_URL do |req|
-        req.params["client_id"] = @client_id
-        req.params["client_secret"] = @client_secret
-        req.params["jwt_token"] = jwt_token
+
+    end
+
+    def upload_asset(upload_uri, template:)
+
+      # Upload the template to the presigned URI
+      url = URI(upload_uri)
+      https = Net::HTTP.new(url.host, url.port)
+      https.use_ssl = true
+      request = Net::HTTP::Put.new(url)
+      request["Content-Type"] = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+      request.body = File.read(template)
+      response = https.request(request)
+      if response.code.to_i != 200
+        raise Error.new(status_code: response.code, msg: "Failed to upload template: #{response.body}")
+      else
+        puts "Template uploaded successfully"
       end
 
-      return response.body["access_token"]
     end
 
-    def submit(json:, template:, output:)
-      @output = output
-      output_format = /docx/.match?(File.extname(@output)) ? "application/vnd.openxmlformats-officedocument.wordprocessingml.document" : "application/pdf"
-
-      content_request = {
-        "cpf:engine": {
-          "repo:assetId": "urn:aaid:cpf:Service-52d5db6097ed436ebb96f13a4c7bf8fb"
-        },
-        "cpf:inputs": {
-          documentIn: {
-            "dc:format": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-            "cpf:location": "InputFile0"
-          },
-          params: {
-            "cpf:inline": {
-              outputFormat: File.extname(@output).delete("."),
-              jsonDataForMerge: json
-            }
-          }
-        },
-        "cpf:outputs": {
-          documentOut: {
-            "dc:format": output_format.to_s,
-            "cpf:location": "multipartLabel"
-          }
-        }
+    def document_generation(json:)
+      # Document Generation
+      url = URI("https://pdf-services-ue1.adobe.io/operation/documentgeneration")
+      https = Net::HTTP.new(url.host, url.port)
+      https.use_ssl = true
+      request = Net::HTTP::Post.new(url)
+      request["Content-Type"] = "application/json"
+      request["X-API-Key"] = @client_id
+      request["Authorization"] = "Bearer #{@access_token}"
+
+      request.body = {"assetID": @asset_id,
+                      "outputFormat": "docx",
+                      "jsonDataForMerge": json
       }.to_json
 
-      connection = Faraday.new API_ENDPOINT_URL do |conn|
-        conn.request :authorization, "Bearer", @access_token
-        conn.headers["x-api-key"] = @client_id
-        conn.request :multipart
-        conn.request :url_encoded
-        conn.response :json, content_type: "application/json"
+      response = https.request(request)
+
+      if response.code.to_i != 201
+        raise Error.new(status_code: response.code, msg: "Failed to submit document generation request: #{response.body}")
+      else
+        status_url = response.header["location"]
+        puts "Document Generation submitted successfully"
       end
 
-      payload = {"contentAnalyzerRequests" => content_request}
-      payload[:InputFile0] = Faraday::FilePart.new(template, "application/vnd.openxmlformats-officedocument.wordprocessingml.document")
-      res = connection.post("/ops/:create", payload)
-      status_code = res.body["cpf:status"]["status"].to_i
-      @location_url = res.headers["location"]
-      raise Error.new(status_code: status_code, msg: res.body["cpf:status"]) unless status_code == 202
-      poll_for_file(@location_url)
+      # Start polling for the status of the document generation
+      poll_status(status_url)
     end
 
-    private
-
-    def poll_for_file(url)
-      connection = Faraday.new do |conn|
-        conn.request :authorization, "Bearer", @access_token
-        conn.headers["x-api-key"] = @client_id
-      end
-      counter = 0
+    def poll_status(status_url, timeout: 30)
+      # Poll for the generated document
+      download_uri = nil
       loop do
-        sleep(6)
-        response = connection.get(url)
-        counter += 1
-        if response.body.include?('"cpf:status":{"completed":true,"type":"","status":200}')
-          @raw_response = response
-          return write_to_file(response.body)
+        timeout -= 1
+        break if timeout <= 0
+
+        # Wait for 5 seconds before checking the status
+        url = URI(status_url)
+        https = Net::HTTP.new(url.host, url.port)
+        https.use_ssl = true
+        request = Net::HTTP::Get.new(url)
+        request["Content-Type"] = "application/json"
+        request["X-API-Key"] = @client_id
+        request["Authorization"] = "Bearer #{@access_token}"
+        response = https.request(request)
+
+        if response.code.to_i != 200
+          raise Error.new(status_code: response.code, msg: "Failed to check document generation status: #{response.body}")
+        end
+
+        response_body = JSON.parse(response.body)
+        puts "Current status: #{response_body['status']}"
+        if response_body["status"] == "done"
+          download_uri = response_body["asset"]["downloadUri"]
+          break
+        elsif response_body["status"] == "failed"
+          raise Error.new(status_code: response.code, msg: "Document generation failed: #{response.body}")
         else
-          status = JSON.parse(response.body)["cpf:status"]
-          raise Error.new(status_code: status["status"], msg: status) if status["status"] != 202
+          puts "Document generation in progress..."
         end
-        break if counter > 10
-      rescue => e
-        # Raise other exceptions
-        raise(e)
+        sleep 1
       end
-    end
 
-    def write_to_file(response_body)
-      line_index = []
-      lines = response_body.split("\r\n")
-      lines.each_with_index do |line, i|
-        next if line.include?("--Boundary_") || line.match?(/^Content-(Type|Disposition):/) || line.empty? || JSON.parse(line.force_encoding("UTF-8").to_s)
-      rescue
-        line_index << i
+      # If the download URI is available, proceed to download the document
+      if download_uri
+        download_output(download_uri: download_uri)
+      else
+        raise Error.new(status_code: response.code, msg: "Document generation not completed: #{response.body}")
       end
 
-      return true if File.open(@output, "wb") { |f| f.write lines.map.with_index { |l, i| lines.at(i) if line_index.include?(i) }.compact.join("\r\n")}
-      false
     end
 
+    def download_output(download_uri:)
+      # Finally, download the generated document
+      url = URI(download_uri)
+      https = Net::HTTP.new(url.host, url.port)
+      https.use_ssl = true
+      request = Net::HTTP::Get.new(url)
+      response = https.request(request)
+      if response.code.to_i != 200
+        raise Error.new(status_code: response.code, msg: "Failed to download document: #{response.body}")
+      else
+        if File.open(@output, "wb") { |f| f.write response.body }
+          puts "Document saved successfully to #{@output}"
+          return true
+        end
+      end
+    end
   end
+
 end

data/lib/adobe_doc_api/configuration.rb

@@ -1,13 +1,11 @@
 module AdobeDocApi
   class Configuration
-    attr_accessor :client_id, :client_secret, :org_id, :tech_account_id, :private_key_path
+    attr_accessor :client_id, :client_secret, :scopes
 
     def initialize
       @client_id = nil
-      @client_sercret = nil
-      @org_id = nil
-      @tech_account_id = nil
-      @private_key_path = nil
+      @client_secret = nil
+      @scopes = nil
     end
   end
 end

data/lib/adobe_doc_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AdobeDocApi
-  VERSION = "0.1.4"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,71 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: adobe_doc_api
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Chris Sonnier
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-01-04 00:00:00.000000000 Z
+date: 2025-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: faraday
+  name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
-- !ruby/object:Gem::Dependency
-  name: faraday_middleware
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
-- !ruby/object:Gem::Dependency
-  name: jwt
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.3.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.3.0
-- !ruby/object:Gem::Dependency
-  name: openssl
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.2.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 2.2.1
+        version: '2.0'
 description: Ruby interface for Adobe PDF Services API Document Generation
 email:
 - christopher.sonnier@gmail.com
@@ -101,14 +59,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Ruby interface for Adobe PDF Services API Document Generation