anvil-ruby 0.1.0

data/lib/anvil/resources/pdf.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+module Anvil
+  class PDF < Resources::Base
+    attr_reader :raw_data
+
+    def initialize(raw_data, attributes = {}, client: nil)
+      super(attributes, client: client)
+      @raw_data = raw_data
+    end
+
+    # Save the PDF to a file
+    def save_as(filename, mode = 'wb')
+      raise FileError, 'No PDF data to save' unless raw_data
+
+      File.open(filename, mode) do |file|
+        file.write(raw_data)
+      end
+      filename
+    end
+
+    # Save and raise on error
+    def save_as!(filename, mode = 'wb')
+      save_as(filename, mode)
+    rescue StandardError => e
+      raise FileError, "Failed to save PDF: #{e.message}"
+    end
+
+    # Get the PDF as a base64 encoded string
+    def to_base64
+      return nil unless raw_data
+
+      Base64.strict_encode64(raw_data)
+    end
+
+    # Get the size in bytes
+    def size
+      raw_data&.bytesize || 0
+    end
+
+    def size_human
+      size_in_bytes = size
+      return '0 B' if size_in_bytes.zero?
+
+      units = %w[B KB MB GB]
+      exp = (Math.log(size_in_bytes) / Math.log(1024)).to_i
+      exp = units.size - 1 if exp >= units.size
+
+      format('%.2f %s', size_in_bytes.to_f / (1024**exp), units[exp])
+    end
+
+    class << self
+      # Fill a PDF template with data
+      #
+      # @param template_id [String] The PDF template ID
+      # @param data [Hash] The data to fill the PDF with
+      # @param options [Hash] Additional options
+      # @option options [String] :title Optional document title
+      # @option options [String] :font_family Font family (default: "Noto Sans")
+      # @option options [Integer] :font_size Font size (default: 10)
+      # @option options [String] :text_color Text color (default: "#333333")
+      # @option options [Boolean] :use_interactive_fields Use interactive form fields
+      # @option options [String] :api_key Optional API key override
+      # @return [PDF] The filled PDF
+      def fill(template_id:, data:, **options)
+        api_key = options.delete(:api_key)
+        client = api_key ? Client.new(api_key: api_key) : self.client
+
+        payload = build_fill_payload(data, options)
+        path = "/fill/#{template_id}.pdf"
+
+        response = client.post(path, payload)
+
+        raise APIError, "Expected PDF response but got: #{response.content_type}" unless response.binary?
+
+        new(response.raw_body, { template_id: template_id }, client: client)
+      end
+
+      # Generate a PDF from HTML or Markdown
+      #
+      # @param type [Symbol, String] :html or :markdown
+      # @param data [Hash, Array] Content data
+      # @param options [Hash] Additional options
+      # @option options [String] :title Document title
+      # @option options [Hash] :page Page configuration
+      # @option options [String] :api_key Optional API key override
+      # @return [PDF] The generated PDF
+      def generate(data:, type: :markdown, **options)
+        api_key = options.delete(:api_key)
+        client = api_key ? Client.new(api_key: api_key) : self.client
+
+        type = type.to_s.downcase
+        unless %w[html markdown].include?(type)
+          raise ArgumentError, "Type must be :html or :markdown, got #{type.inspect}"
+        end
+
+        payload = build_generate_payload(type, data, options)
+        path = '/generate-pdf'
+
+        response = client.post(path, payload)
+
+        raise APIError, "Expected PDF response but got: #{response.content_type}" unless response.binary?
+
+        new(response.raw_body, { type: type }, client: client)
+      end
+
+      # Convenience methods for specific generation types
+      def generate_from_html(html:, css: nil, **options)
+        data = { html: html }
+        data[:css] = css if css
+        generate(type: :html, data: data, **options)
+      end
+
+      def generate_from_markdown(content, **options)
+        data = if content.is_a?(String)
+                 [{ content: content }]
+               elsif content.is_a?(Array)
+                 content
+               else
+                 raise ArgumentError, 'Markdown content must be a string or array'
+               end
+
+        generate(type: :markdown, data: data, **options)
+      end
+
+      private
+
+      def build_fill_payload(data, options)
+        payload = { data: data }
+
+        # Add optional parameters if provided
+        payload[:title] = options[:title] if options[:title]
+        payload[:fontSize] = options[:font_size] if options[:font_size]
+        payload[:fontFamily] = options[:font_family] if options[:font_family]
+        payload[:textColor] = options[:text_color] if options[:text_color]
+        payload[:useInteractiveFields] = options[:use_interactive_fields] if options.key?(:use_interactive_fields)
+
+        payload
+      end
+
+      def build_generate_payload(type, data, options)
+        payload = {
+          type: type,
+          data: data
+        }
+
+        # Add optional parameters
+        payload[:title] = options[:title] if options[:title]
+
+        # Page configuration
+        payload[:page] = build_page_config(options[:page]) if options[:page]
+
+        payload
+      end
+
+      def self.build_page_config(page)
+        return nil unless page
+
+        config = {}
+        config[:width] = page[:width] if page[:width]
+        config[:height] = page[:height] if page[:height]
+        config[:marginTop] = page[:margin_top] if page[:margin_top]
+        config[:marginBottom] = page[:margin_bottom] if page[:margin_bottom]
+        config[:marginLeft] = page[:margin_left] if page[:margin_left]
+        config[:marginRight] = page[:margin_right] if page[:margin_right]
+        config[:pageCount] = page[:page_count] if page.key?(:page_count)
+        config
+      end
+    end
+  end
+end

data/lib/anvil/resources/signature.rb

@@ -0,0 +1,517 @@
+# frozen_string_literal: true
+
+module Anvil
+  class Signature < Resources::Base
+    # Etch packet statuses
+    STATUSES = %w[draft sent partial_complete complete].freeze
+
+    def id
+      attributes[:eid] || attributes[:id]
+    end
+
+    def eid
+      attributes[:eid]
+    end
+
+    def status
+      attributes[:status]
+    end
+
+    def name
+      attributes[:name]
+    end
+
+    # Check packet status
+    def draft?
+      status == 'draft'
+    end
+
+    def sent?
+      status == 'sent'
+    end
+
+    def partially_complete?
+      status == 'partial_complete'
+    end
+
+    def complete?
+      status == 'complete'
+    end
+
+    def completed?
+      complete?
+    end
+
+    # Has the packet been sent to signers?
+    def in_progress?
+      sent? || partially_complete?
+    end
+
+    # Get signing URL for a specific signer
+    def signing_url(signer_id:, client_user_id: nil)
+      self.class.generate_signing_url(
+        packet_eid: eid,
+        signer_eid: signer_id,
+        client_user_id: client_user_id,
+        client: client
+      )
+    end
+
+    # Get all signers
+    def signers
+      Array(attributes[:signers]).map do |signer|
+        SignatureSigner.new(signer, packet: self)
+      end
+    end
+
+    # Get documents
+    def documents
+      Array(attributes[:documents])
+    end
+
+    # Reload from API
+    def reload!
+      refreshed = self.class.find(eid, client: client)
+      @attributes = refreshed.attributes
+      self
+    end
+
+    # Update the signature packet
+    #
+    # @param options [Hash] Fields to update (name, signers, email_subject, email_body)
+    # @return [self] The updated signature packet
+    def update(**options)
+      payload = build_update_payload(options)
+
+      data = client.graphql(self.class.send(:update_packet_mutation), variables: { eid: eid, input: payload })
+      raise APIError, "Failed to update signature packet: #{eid}" unless data && data[:updateEtchPacket]
+
+      @attributes = symbolize_keys(data[:updateEtchPacket])
+      self
+    end
+
+    # Send a draft packet to signers
+    #
+    # @return [self] The sent signature packet
+    def send!
+      data = client.graphql(self.class.send(:send_packet_mutation), variables: { eid: eid })
+      raise APIError, "Failed to send signature packet: #{eid}" unless data && data[:sendEtchPacket]
+
+      @attributes = symbolize_keys(data[:sendEtchPacket])
+      self
+    end
+
+    # Delete the signature packet
+    #
+    # @return [Boolean] true if deleted
+    def delete!
+      data = client.graphql(self.class.send(:remove_packet_mutation), variables: { eid: eid })
+      raise APIError, "Failed to delete signature packet: #{eid}" unless data
+
+      true
+    end
+
+    # Skip a signer in the signature flow
+    #
+    # @param signer_eid [String] The EID of the signer to skip
+    # @return [self] The updated signature packet
+    def skip_signer(signer_eid)
+      data = client.graphql(self.class.send(:skip_signer_mutation),
+                            variables: { signerEid: signer_eid, packetEid: eid })
+      raise APIError, "Failed to skip signer: #{signer_eid}" unless data
+
+      reload!
+    end
+
+    # Send a reminder notification to a signer
+    #
+    # @param signer_eid [String] The EID of the signer to notify
+    # @return [Boolean] true if notification sent
+    def notify_signer(signer_eid)
+      data = client.graphql(self.class.send(:notify_signer_mutation),
+                            variables: { signerEid: signer_eid, packetEid: eid })
+      raise APIError, "Failed to notify signer: #{signer_eid}" unless data
+
+      true
+    end
+
+    # Void signed documents
+    #
+    # @return [Boolean] true if voided
+    def void!
+      data = client.graphql(
+        self.class.send(:void_document_group_mutation),
+        variables: { eid: eid }
+      )
+      raise APIError, "Failed to void signature packet: #{eid}" unless data
+
+      reload!
+      true
+    end
+
+    # Expire all active signing sessions
+    #
+    # @return [Boolean] true if tokens expired
+    def expire_tokens!
+      data = client.graphql(
+        self.class.send(:expire_signer_tokens_mutation),
+        variables: { eid: eid }
+      )
+      raise APIError, "Failed to expire signer tokens: #{eid}" unless data
+
+      true
+    end
+
+    private
+
+    def build_update_payload(options)
+      payload = {}
+      payload[:name] = options[:name] if options.key?(:name)
+      payload[:signers] = self.class.send(:build_signers_payload, options[:signers]) if options[:signers]
+      payload[:signatureEmailSubject] = options[:email_subject] if options[:email_subject]
+      payload[:signatureEmailBody] = options[:email_body] if options[:email_body]
+      payload
+    end
+
+    class << self
+      # Create a new signature packet
+      #
+      # @param name [String] Name of the packet
+      # @param signers [Array<Hash>] Array of signer information
+      # @param files [Array<Hash>] Array of files to sign
+      # @param options [Hash] Additional options
+      # @return [Signature] The created signature packet
+      def create(name:, signers:, files: nil, **options)
+        api_key = options.delete(:api_key)
+        client = api_key ? Client.new(api_key: api_key) : self.client
+
+        payload = build_create_payload(name, signers, files, options)
+
+        # Use full GraphQL endpoint URL
+        response = client.post(client.config.graphql_url, {
+                                 query: create_packet_mutation,
+                                 variables: { input: payload }
+                               })
+
+        data = response.data
+        unless data[:data] && data[:data][:createEtchPacket]
+          raise APIError, "Failed to create signature packet: #{data[:errors]}"
+        end
+
+        new(data[:data][:createEtchPacket], client: client)
+      end
+
+      # Find a signature packet by ID
+      def find(packet_eid, client: nil)
+        client ||= self.client
+
+        response = client.post(client.config.graphql_url, {
+                                 query: find_packet_query,
+                                 variables: { eid: packet_eid }
+                               })
+
+        data = response.data
+        raise NotFoundError, "Signature packet not found: #{packet_eid}" unless data[:data] && data[:data][:etchPacket]
+
+        new(data[:data][:etchPacket], client: client)
+      end
+
+      # List all signature packets
+      def list(limit: 10, offset: 0, status: nil, client: nil)
+        client ||= self.client
+
+        variables = { limit: limit, offset: offset }
+        variables[:status] = status if status
+
+        response = client.post(client.config.graphql_url, {
+                                 query: list_packets_query,
+                                 variables: variables
+                               })
+
+        data = response.data
+        if data[:data] && data[:data][:etchPackets]
+          data[:data][:etchPackets].map { |packet| new(packet, client: client) }
+        else
+          []
+        end
+      end
+
+      # Generate a signing URL for a signer
+      def generate_signing_url(packet_eid:, signer_eid:, client_user_id: nil, client: nil)
+        client ||= self.client
+
+        payload = {
+          packetEid: packet_eid,
+          signerEid: signer_eid
+        }
+        payload[:clientUserId] = client_user_id if client_user_id
+
+        response = client.post(client.config.graphql_url, {
+                                 query: generate_url_mutation,
+                                 variables: { input: payload }
+                               })
+
+        data = response.data
+        raise APIError, 'Failed to generate signing URL' unless data[:data] && data[:data][:generateEtchSignURL]
+
+        data[:data][:generateEtchSignURL][:url]
+      end
+
+      private
+
+      def build_create_payload(name, signers, files, options)
+        payload = {
+          name: name,
+          signers: build_signers_payload(signers)
+        }
+
+        payload[:files] = build_files_payload(files) if files
+        payload[:isDraft] = options[:is_draft] if options.key?(:is_draft)
+        payload[:webhookURL] = options[:webhook_url] if options[:webhook_url]
+        payload[:signatureEmailSubject] = options[:email_subject] if options[:email_subject]
+        payload[:signatureEmailBody] = options[:email_body] if options[:email_body]
+
+        payload
+      end
+
+      def build_signers_payload(signers)
+        signers.map do |signer|
+          {
+            name: signer[:name],
+            email: signer[:email],
+            role: signer[:role] || 'signer',
+            signerType: signer[:signer_type] || 'email'
+          }.compact
+        end
+      end
+
+      def build_files_payload(files)
+        files.map do |file|
+          if file[:type] == :pdf && file[:id]
+            # Template ID should be castEid
+            {
+              id: 'file1', # File identifier
+              castEid: file[:id] # Template ID
+            }
+          elsif file[:type] == :upload && file[:data]
+            {
+              type: 'upload',
+              data: Base64.strict_encode64(file[:data]),
+              filename: file[:filename] || 'document.pdf'
+            }
+          else
+            file
+          end
+        end
+      end
+
+      # GraphQL queries and mutations (simplified versions)
+      def create_packet_mutation
+        <<~GRAPHQL
+          mutation CreateEtchPacket($input: JSON) {
+            createEtchPacket(variables: $input) {
+              eid
+              name
+              status
+              createdAt
+              signers {
+                eid
+                name
+                email
+                status
+              }
+            }
+          }
+        GRAPHQL
+      end
+
+      def find_packet_query
+        <<~GRAPHQL
+          query GetEtchPacket($eid: String!) {
+            etchPacket(eid: $eid) {
+              eid
+              name
+              status
+              createdAt
+              completedAt
+              signers {
+                eid
+                name
+                email
+                status
+                completedAt
+              }
+              documents {
+                eid
+                name
+                type
+              }
+            }
+          }
+        GRAPHQL
+      end
+
+      def list_packets_query
+        <<~GRAPHQL
+          query ListEtchPackets($limit: Int, $offset: Int, $status: String) {
+            etchPackets(limit: $limit, offset: $offset, status: $status) {
+              eid
+              name
+              status
+              createdAt
+              completedAt
+            }
+          }
+        GRAPHQL
+      end
+
+      def generate_url_mutation
+        <<~GRAPHQL
+          mutation GenerateEtchSignURL($input: GenerateEtchSignURLInput!) {
+            generateEtchSignURL(input: $input) {
+              url
+            }
+          }
+        GRAPHQL
+      end
+
+      def update_packet_mutation
+        <<~GRAPHQL
+          mutation UpdateEtchPacket($eid: String!, $input: JSON) {
+            updateEtchPacket(eid: $eid, variables: $input) {
+              eid
+              name
+              status
+              createdAt
+              signers {
+                eid
+                name
+                email
+                status
+              }
+            }
+          }
+        GRAPHQL
+      end
+
+      def send_packet_mutation
+        <<~GRAPHQL
+          mutation SendEtchPacket($eid: String!) {
+            sendEtchPacket(eid: $eid) {
+              eid
+              name
+              status
+              createdAt
+              signers {
+                eid
+                name
+                email
+                status
+              }
+            }
+          }
+        GRAPHQL
+      end
+
+      def remove_packet_mutation
+        <<~GRAPHQL
+          mutation RemoveEtchPacket($eid: String!) {
+            removeEtchPacket(eid: $eid)
+          }
+        GRAPHQL
+      end
+
+      def skip_signer_mutation
+        <<~GRAPHQL
+          mutation SkipSigner($signerEid: String!, $packetEid: String!) {
+            skipSigner(signerEid: $signerEid, packetEid: $packetEid)
+          }
+        GRAPHQL
+      end
+
+      def notify_signer_mutation
+        <<~GRAPHQL
+          mutation NotifySigner($signerEid: String!, $packetEid: String!) {
+            notifySigner(signerEid: $signerEid, packetEid: $packetEid)
+          }
+        GRAPHQL
+      end
+
+      def void_document_group_mutation
+        <<~GRAPHQL
+          mutation VoidDocumentGroup($eid: String!) {
+            voidDocumentGroup(eid: $eid)
+          }
+        GRAPHQL
+      end
+
+      def expire_signer_tokens_mutation
+        <<~GRAPHQL
+          mutation ExpireSignerTokens($eid: String!) {
+            expireSignerTokens(eid: $eid)
+          }
+        GRAPHQL
+      end
+    end
+  end
+
+  # Helper class for signature signers
+  class SignatureSigner < Resources::Base
+    attr_reader :packet
+
+    def initialize(attributes, packet: nil)
+      super(attributes)
+      @packet = packet
+    end
+
+    def eid
+      attributes[:eid]
+    end
+
+    def name
+      attributes[:name]
+    end
+
+    def email
+      attributes[:email]
+    end
+
+    def status
+      attributes[:status]
+    end
+
+    def complete?
+      status == 'complete'
+    end
+
+    def completed_at
+      return unless attributes[:completed_at]
+
+      Time.parse(attributes[:completed_at])
+    end
+
+    # Get signing URL for this signer
+    def signing_url(client_user_id: nil)
+      return nil unless packet
+
+      packet.signing_url(
+        signer_id: eid,
+        client_user_id: client_user_id
+      )
+    end
+
+    # Skip this signer
+    def skip!
+      raise Error, 'No packet associated with this signer' unless packet
+
+      packet.skip_signer(eid)
+    end
+
+    # Send a reminder to this signer
+    def send_reminder!
+      raise Error, 'No packet associated with this signer' unless packet
+
+      packet.notify_signer(eid)
+    end
+  end
+end