class GroupDocs::Document

Constants

ACCESS_MODES

Attributes

dependent_questionnaires_count[RW]
documentDescription[RW]

added in release 2.0.0

@attr [String] documentDescription
fieldType[RW]

added in release 1.6.0

@attr [String] fieldType
field_count[RW]

@attr [Integer] field_count

file[RW]

@attr [GroupDocs::Storage::File] file

order[RW]

@attr [Integer] order

output_formats[RW]

@attr [Array<Symbol>] output_formats

outputs[RW]

@attr [Array<GroupDocs::Storage::File>] outputs

proc_date=[RW]

@attr [Time] process_date

process_date[RW]

@attr [Time] process_date

status[RW]

@attr [Symbol] status

upload_time[RW]

@attr [Long] upload_time

Public Class Methods

metadata!(path, access = {}) click to toggle source

Cnanged in release 2.0.0

Returns a document metadata by given path.

@param [String] path Full path to document @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [Array<GroupDocs::Document::View>]

# File lib/groupdocs/document.rb, line 181
def self.metadata!(path, access = {})
  json = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = "/doc/{{client_id}}/files/#{path}"
  end.execute!

  Document::MetaData.new do |metadata|
    metadata.id = json[:id]
    metadata.guid = json[:guid]
    metadata.page_count = json[:page_count]
    metadata.views_count = json[:views_count]
    metadata.type = json[:type]
    metadata.url = json[:url]
    if json[:last_view]
      metadata.last_view = json[:last_view]
    end
  end
end
new(options = {}, &blk) click to toggle source

Creates new GroupDocs::Document.

You should avoid creating documents directly. Instead, use to_document instance method of GroupDocs::Storage::File.

@raise [ArgumentError] If file is not passed or is not an instance of GroupDocs::Storage::File

Calls superclass method GroupDocs::Api::Entity::new
# File lib/groupdocs/document.rb, line 322
def initialize(options = {}, &blk)
  super(options, &blk)
  file.is_a?(GroupDocs::Storage::File) or raise ArgumentError,
                                                "You have to pass GroupDocs::Storage::File object: #{file.inspect}."
end
public_fields!(access = {}) click to toggle source

Changed in release 1.5.8

Get document fields

@param [String] document Document GUID @param [Hash] settings Settings of the signing document @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [Array]

# File lib/groupdocs/document.rb, line 1379
def self.public_fields!(access = {})
  Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = "/signature/public/documents/#{file.guid}/fields"
  end.execute!
end
sign_documents!(documents, signatures, options = {}, access = {}) click to toggle source

Signs given documents with signatures.

@example

# prepare documents
file_one = GroupDocs::Storage::File.new(name: 'document_one.doc', local_path: '~/Documents/document_one.doc')
file_two = GroupDocs::Storage::File.new(name: 'document_one.pdf', local_path: '~/Documents/document_one.pdf')
document_one = file_one.to_document
document_two = file_two.to_document
# prepare signatures
signature_one = GroupDocs::Signature.new(name: 'John Smith', image_path: '~/Documents/signature_one.png')
signature_two = GroupDocs::Signature.new(name: 'Sara Smith', image_path: '~/Documents/signature_two.png')
signature_one.position = { top: 0.1, left: 0.07, width: 50, height: 50 }
signature_one.email = "test1@mail.com"
signature_two.position = { top: 0.2, left: 0.2, width: 100, height: 100 }
signature_one.email = "test1@mail.com"
# sign documents and download results
signed_documents = GroupDocs::Document.sign_documents!([document_one, document_two], [signature_one, signature_two])
signed_documents.each do |document|
  document.file.download! '~/Documents'
end

@param [Array<GroupDocs::Document>] documents Each document file should have “#name” and “#local_path” @param [Array<GroupDocs::Signature>] signatures Each signature should have “#name”, “#image_path” and “#position”

# File lib/groupdocs/document.rb, line 103
def self.sign_documents!(documents, signatures, options = {}, access = {})
  documents.each do |document|
    document.is_a?(Document) or raise ArgumentError, "Each document should be GroupDocs::Document object, received: #{document.inspect}"
    document.file.name       or raise ArgumentError, "Each document file should have name, received: #{document.file.name.inspect}"
    document.file.local_path or raise ArgumentError, "Each document file should have local_path, received: #{document.file.local_path.inspect}"
  end
  signatures.each do |signature|
    signature.is_a?(Signature) or raise ArgumentError, "Each signature should be GroupDocs::Signature object, received: #{signature.inspect}"
    signature.name             or raise ArgumentError, "Each signature should have name, received: #{signature.name.inspect}"
    signature.image_path       or raise ArgumentError, "Each signature should have image_path, received: #{signature.image_path.inspect}"
    signature.position         or raise ArgumentError, "Each signature should have position, received: #{signature.position.inspect}"
  end

  documents_to_sign = []
  documents.map(&:file).each do |file|
    document = { :name => file.name }
    contents = File.open(file.local_path, 'rb').read
    contents = Base64.strict_encode64(contents)
    document.merge!(:data => "data:#{mime_type(file.local_path)};base64,#{contents}")

    documents_to_sign << document

  end

  signers = []
  signatures.each do |signature|
    contents = File.open(signature.image_path, 'rb').read
    contents = Base64.strict_encode64(contents)
    signer = { :name => signature.name, :data => "data:#{mime_type(signature.image_path)};base64,#{contents}" }
    signer.merge!(signature.position)
    # place signature on is not implemented yet
    signer.merge!(:placeSignatureOn => nil)
    signer.merge!(:email => signature.email)

    signers << signer


  end

  json = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :POST
    request[:path] = '/signature/{{client_id}}/sign'
    request[:request_body] = { :documents => documents_to_sign, :signers => signers }
  end.execute!
  json[:jobId]

end
templates!(options = {}, access = {}) click to toggle source

Returns an array of all templates (documents in “Templates” directory).

@param [Hash] options Options @option options [String] :orderBy Order by column @option options [Boolean] :isAscending Order by ascending or descending @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [Array<GroupDocs::Document>]

# File lib/groupdocs/document.rb, line 64
def self.templates!(options = {}, access = {})
  api = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = '/merge/{{client_id}}/templates'
  end
  api.add_params(options)
  json = api.execute!
  json[:templates].map do |template|
    template.merge!(:file => Storage::File.new(template))
    Document.new(template)
  end
end
views!(options = {}, access = {}) click to toggle source

Returns an array of views for all documents.

@param [Hash] options @option options [Integer] :page_index Page to start with @option options [Integer] :page_size Total number of entries @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [Array<GroupDocs::Document::View>]

# File lib/groupdocs/document.rb, line 39
def self.views!(options = {}, access = {})
  api = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = '/doc/{{client_id}}/views'
  end
  api.add_params(options)
  json = api.execute!

  json[:views].map do |view|
    Document::View.new(view)
  end
end

Public Instance Methods

access_mode!(access = {}) click to toggle source

Returns access mode of document.

@param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [Symbol] One of :private, :restricted or :public access modes

# File lib/groupdocs/document.rb, line 545
def access_mode!(access = {})
  json = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = "/doc/{{client_id}}/files/#{file.guid}/accessinfo"
  end.execute!

  parse_access_mode(json[:access])
end
access_mode=(mode, access = {})

note that aliased version cannot accept access credentials hash

Alias for: access_mode_set!
access_mode_set!(mode, access = {}) click to toggle source

Sets access mode of document.

@param [Symbol] mode One of :private, :restricted or :public access modes @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [Symbol] Set access mode

# File lib/groupdocs/document.rb, line 564
def access_mode_set!(mode, access = {})
  api = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :PUT
    request[:path] = "/doc/{{client_id}}/files/#{file.id}/accessinfo"
  end
  api.add_params(:mode => ACCESS_MODES[mode])
  json = api.execute!

  parse_access_mode(json[:access])
end
Also aliased as: access_mode=
add_collaborator!(collaborator, access = {}) click to toggle source

Adds document annotations collaborator.

@param [GroupDocs::User] collaborator @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key

# File lib/groupdocs/document.rb, line 1188
def add_collaborator!(collaborator, access = {})
  collaborator.is_a?(GroupDocs::User) or raise ArgumentError,
                                               "Collaborator should be GroupDocs::User object, received: #{collaborator.inspect}"

  Api::Request.new do |request|
    request[:access] = access
    request[:method] = :POST
    request[:path] = "/ant/{{client_id}}/files/#{file.guid}/collaborators"
    request[:request_body] = collaborator.to_hash
  end.execute!
end
add_questionnaire!(questionnaire, access = {}) click to toggle source

Adds questionnaire to document.

@param [GroupDocs::Questionnaire] questionnaire @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key

@raise [ArgumentError] if questionnaire is not GroupDocs::Questionnaire object

# File lib/groupdocs/document.rb, line 904
def add_questionnaire!(questionnaire, access = {})
  questionnaire.is_a?(GroupDocs::Questionnaire) or raise ArgumentError,
                                                         "Questionnaire should be GroupDocs::Questionnaire object, received: #{questionnaire.inspect}"

  Api::Request.new do |request|
    request[:access] = access
    request[:method] = :PUT
    request[:path] = "/merge/{{client_id}}/files/#{file.guid}/questionnaires/#{questionnaire.id}"
  end.execute!
end
add_questionnaire_template!(fields, access = {}) click to toggle source

added in release 1.8.0

Add template editor fields to the specific document

@example

file = GroupDocs::Storage::File.new({:guid => ‘3be4e06494caed131d912c75e17d5f22592e3044032e0f81b35f13a8c9fefb49’}).to_document field = GroupDocs::Document::TemplateEditorFields.new field.name = ‘test’ field.fieldtype = ‘TextBox’ field.page = 1 file.add_questionnaire_template!( )

@param List fields @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key

# File lib/groupdocs/document.rb, line 1459
def add_questionnaire_template!(fields, access = {})

  fields.each do |field|
    field.is_a?(GroupDocs::Document::TemplateEditorFields) or raise ArgumentError,
                                                                    "Fields should be List GroupDocs::Document::TemplateEditorFields objects, received: #{fields.inspect}"
  end

  json = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :POST
    request[:path] = "/merge/{{client_id}}/files/#{file.guid}/templates/add"
    request[:request_body] = fields
  end.execute!
  json[:templateFields].map do |field|
    Document::Field.new(field)
  end
end
annotations!(access = {}) click to toggle source

Returns an array of annotations.

@param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [Array<GroupDocs::Document::Annotation>]

# File lib/groupdocs/document.rb, line 970
def annotations!(access = {})
  json = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = "/ant/{{client_id}}/files/#{file.guid}/annotations"
  end.execute!

  if json[:annotations]
    json[:annotations].map do |annotation|
      annotation.merge!(:document => self)
      Document::Annotation.new(annotation)
    end
  else
    []
  end
end
changes!(access = {}) click to toggle source

@Changed in release 1.5.9 Returns an array of changes in document.

@example

document_one = GroupDocs::Storage::Folder.list![0].to_document
document_two = GroupDocs::Storage::Folder.list![1].to_document
job = document_one.compare!(document_two)
sleep(5) # wait for server to finish comparing
result = job.documents![:outputs].first
result.changes!

@param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key

# File lib/groupdocs/document.rb, line 1084
def changes!(access = {})
  api = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = "/comparison/public/#{file.guid}/changes"
  end
  json = api.execute!

  json[:changes].map do |change|
    Document::Change.new(change)
  end
end
collaborators!(access = {}) click to toggle source

Returns document annotations collaborators.

@param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [Array<GroupDocs::User>]

# File lib/groupdocs/document.rb, line 1145
def collaborators!(access = {})
  json = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = "/ant/{{client_id}}/files/#{file.guid}/collaborators"
  end.execute!

  json[:collaborators].map do |collaborator|
    User.new(collaborator)
  end
end
compare!(document, callback, access = {}) click to toggle source

Changed in release 1.5.8 Schedules a job for comparing document with given.

@param [GroupDocs::Document] document @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [GroupDocs::Job]

@raise [ArgumentError] if document is not GroupDocs::Document object

# File lib/groupdocs/document.rb, line 1018
def compare!(document, callback, access = {})
  document.is_a?(GroupDocs::Document) or raise ArgumentError,
                                               "Document should be GroupDocs::Document object, received: #{document.inspect}"

  api = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = "/comparison/{{client_id}}/compare"
  end
  api.add_params(:source => file.guid, :target => document.file.guid, :callback => callback)
  json = api.execute!

  Job.new(:id => json[:job_id])
end
content!(content_type, access = {}) click to toggle source

Returns document content

@param [String] content_type Content type @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [String]

# File lib/groupdocs/document.rb, line 494
def content!(content_type, access = {})
  json = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = "/doc/{{client_id}}/files/#{file.guid}/content/#{content_type}"
  end.execute!

  json[:content]
end
convert!(format, options = {}, access = {}) click to toggle source

Converts document to given format.

@example

document = GroupDocs::Storage::Folder.list!.first.to_document
job = document.convert!(:docx)
sleep(5) # wait for server to finish converting
original_document = job.documents![:inputs].first
converted_file = original_file.outputs.first
converted_file.download!(File.dirname(__FILE__))

@param [Symbol] format @param [Hash] options @option options [Boolean] :email_results @option options [String] :new_description @option options [String] :print_script @option options [String] :callback @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [GroupDocs::Job] Created job

# File lib/groupdocs/document.rb, line 798
def convert!(format, options = {}, access = {})
  options.merge!(:new_type => format)

  api = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :POST
    request[:path] = "/async/{{client_id}}/files/#{file.guid}"
  end
  api.add_params(options)
  json = api.execute!

  Job.new(:id => json[:job_id])
end
create_questionnaire!(questionnaire, access = {}) click to toggle source

Creates questionnaire and adds it to document.

@param [GroupDocs::Questionnaire] questionnaire @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [GroupDocs::Questionnaire]

@raise [ArgumentError] if questionnaire is not GroupDocs::Questionnaire object

# File lib/groupdocs/document.rb, line 926
def create_questionnaire!(questionnaire, access = {})
  questionnaire.is_a?(GroupDocs::Questionnaire) or raise ArgumentError,
                                                         "Questionnaire should be GroupDocs::Questionnaire object, received: #{questionnaire.inspect}"

  json = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :POST
    request[:path] = "/merge/{{client_id}}/files/#{file.guid}/questionnaires"
    request[:request_body] = questionnaire.to_hash
  end.execute!

  questionnaire.id = json[:questionnaire_id]
  questionnaire
end
datasource!(datasource, options = {}, access = {}) click to toggle source

Creates new job to merge datasource into document.

@param [GroupDocs::DataSource] datasource @param [Hash] options @option options [Boolean] :new_type New file format type @option options [Boolean] :email_results Set to true if converted document should be emailed @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [GroupDocs::Job]

@raise [ArgumentError] if datasource is not GroupDocs::DataSource object

# File lib/groupdocs/document.rb, line 826
def datasource!(datasource, options = {}, access = {})
  datasource.is_a?(GroupDocs::DataSource) or raise ArgumentError,
                                                   "Datasource should be GroupDocs::DataSource object, received: #{datasource.inspect}"

  api = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :POST
    request[:path] = "/merge/{{client_id}}/files/#{file.guid}/datasources/#{datasource.id}"
  end
  api.add_params(options)
  json = api.execute!

  Job.new(:id => json[:job_id])
end
datasource_fields!(datasource, options = {}, access = {}) click to toggle source

Creates new job to merge datasource fields into document.

@param [GroupDocs::DataSource] datasource @param [Hash] options @option options [Boolean] :new_type New file format type @option options [Boolean] :email_results Set to true if converted document should be emailed @option options [Boolean] :assembly_name @param [Array] datasourceFields (:name [String], :value [String], :contentType [String], :type [String], :nested_fields [<Array> datasourceFields]) @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [GroupDocs::Job]

@raise [ArgumentError] if datasource is not GroupDocs::DataSource object

# File lib/groupdocs/document.rb, line 857
def datasource_fields!(datasource, options = {}, access = {})
  datasource.is_a?(GroupDocs::DataSource) or raise ArgumentError,
                                                   "Datasource should be GroupDocs::DataSource object, received: #{datasource.inspect}"

  api = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :POST
    request[:path] = "/merge/{{client_id}}/files/#{file.guid}/datasources"
    request[:request_body] = datasource.fields
  end
  api.add_params(options)
  json = api.execute!

  Job.new(:id => json[:job_id])
end
delete_questionnaire_template!(fields, access = {}) click to toggle source

added in release 1.8.0

Delete template’s fields

@example

file = GroupDocs::Storage::File.new({:guid => ‘3be4e06494caed131d912c75e17d5f22592e3044032e0f81b35f13a8c9fefb49’}).to_document field = file.editor_fields! file.delete_questionnaire_template!( )

@param List fields @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key

# File lib/groupdocs/document.rb, line 1531
def delete_questionnaire_template!(fields, access = {})

  fields.each do |field|
    field.is_a?(GroupDocs::Document::TemplateEditorFields) or raise ArgumentError,
                                                                    "Fields should be List GroupDocs::Document::TemplateEditorFields objects, received: #{fields.inspect}"
  end

  json = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :DELETE
    request[:path] = "/merge/{{client_id}}/files/#{file.guid}/templates/delete"
    request[:request_body] = fields
  end.execute!
  json[:templateFields].map do |field|
    Document::Field.new(field)
  end
end
details!(access = {}) click to toggle source

Changed in release 1.5.8 Returns document details.

@param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [Hash]

# File lib/groupdocs/document.rb, line 996
def details!(access = {})
  api = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = "/comparison/{{client_id}}document"
  end
  api.add_params(:guid => file.guid)
  api.execute!
end
document_status!(job_guid, access = {}) click to toggle source
Get sign documents status

@param [String] job_guid @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key

# File lib/groupdocs/document.rb, line 160
def document_status!(job_guid,  access = {})
  json = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :PUT
    request[:path] = "/signature/{{client_id}}/documents/#{job_guid}"
  end.execute!

   json[:documents]
end
download!( path, options = {}, access = {}) click to toggle source

Changed in release 1.5.8 Download comparison result file.

@example

document_one = GroupDocs::Storage::Folder.list![0].to_document
document_two = GroupDocs::Storage::Folder.list![1].to_document
job = document_one.compare!(document_two)
sleep(5) # wait for server to finish comparing
result = job.documents![:outputs].first
result.download!("#{File.dirname(__FILE__)}", {:format => 'pdf'})

@param [Hash] options @option format [String] :format Comparison result file GUID # @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key

# File lib/groupdocs/document.rb, line 1116
def download!( path, options = {}, access = {})
  api = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :DOWNLOAD
    request[:path] = "/comparison/public/#{file.guid}/download"
  end
  api.add_params(options)
  response = api.execute!

  if file.name.split('.').last != options[:format]
    file_name = file.name.delete!(file.name.split('.').last) +  options[:format]
  else
    file_name = file.name
  end
  filepath = "#{path}/#{file_name}"
  Object::File.open(filepath, 'wb') do |file|
    file.write(response)
  end

end
editlock!(access = {}) click to toggle source

Returns editing metadata.

@param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key

# File lib/groupdocs/document.rb, line 410
def editlock!(access = {})
  Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = "/doc/{{client_id}}/files/#{file.guid}/editlock"
  end.execute!
end
editlock_clear!(options = {}, access = {}) click to toggle source

Removes edit lock for a document and replaces the document with its edited copy

@param [Hash] options @option options [String] :lockId Start page to return image for (starting with 0) @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [Integer]

# File lib/groupdocs/document.rb, line 428
def editlock_clear!(options = {}, access = {})
  api = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :DELETE
    request[:path] = "/doc/{{client_id}}/files/#{file.guid}/editlock"
  end
  api.add_params(options).execute!
end
editor_fields!(access = {}) click to toggle source

changed in release 2.1.0

Get template fields.

@param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key

# File lib/groupdocs/document.rb, line 1395
def editor_fields!(access = {})
  Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = "/doc/{{client_id}}/files/#{file.guid}/editor_fields"
  end.execute!
end
fields!(access = {}) click to toggle source

Returns an array of document fields.

@param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [Array<GroupDocs::Document::Field>]

# File lib/groupdocs/document.rb, line 636
def fields!(access = {})
  api = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = "/doc/{{client_id}}/files/#{file.guid}/fields"
  end
  api.add_params(:include_geometry => true)
  json = api.execute!

  json[:fields].map do |field|
    Document::Field.new(field)
  end
end
formats!(access = {}) click to toggle source

Returns array of file formats document can be converted to.

@param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [Array<Symbol>]

# File lib/groupdocs/document.rb, line 586
def formats!(access = {})
  json = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = "/doc/{{client_id}}/files/#{file.id}/formats"
  end.execute!

  json[:types].map do |format|
    format.downcase.to_sym
  end
end
metadata!(access = {}) click to toggle source

Cnanged in release 2.0.0

Returns document metadata.

@param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [GroupDocs::Document::MetaData]

# File lib/groupdocs/document.rb, line 608
def metadata!(access = {})
  json = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = "/doc/{{client_id}}/files/#{file.guid}/metadata"
  end.execute!

  Document::MetaData.new do |metadata|
    metadata.id = json[:id]
    metadata.guid = json[:guid]
    metadata.page_count = json[:page_count]
    metadata.views_count = json[:views_count]
    metadata.type = json[:type]
    metadata.url = json[:url]
    if json[:last_view]
      metadata.last_view = json[:last_view]
    end
  end
end
method_missing(method, *args, &blk) click to toggle source

Pass all unknown methods to file.

Calls superclass method
# File lib/groupdocs/document.rb, line 1305
def method_missing(method, *args, &blk)
  file.respond_to?(method) ? file.send(method, *args, &blk) : super
end
outputs=(outputs) click to toggle source

Coverts passed array of attributes hash to array of GroupDocs::Storage::File.

@param [Array<Hash>] outputs Array of file attributes hashes

# File lib/groupdocs/document.rb, line 276
def outputs=(outputs)
  if outputs
    @outputs = outputs.map do |output|
      GroupDocs::Storage::File.new(output)
    end
  end
end
page_image!(path, name, page_number, dimension, options = {}, access = {}) click to toggle source
Returns a stream of bytes representing a particular document page image.

@param [String] path Document path @param [String] name Name document (format - jpg) @example path = “#{File.dirname(__FILE__)}”

name = "test.jpg"

@param [Integer] page_number Document page number to get image for @param [Integer] dimension Image dimension “<width>x<height>”(500x600) @param [Hash] options @option options [Integer] :quality Image quality in range 1-100. @option options [Boolean] :use_pdf A flag indicating whether a document should be converted to PDF format before generating the image. @option options [Boolean] :expires The date and time in milliseconds since epoch the URL expires. @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return []

# File lib/groupdocs/document.rb, line 346
def page_image!(path, name, page_number, dimension, options = {}, access = {})
  api = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :DOWNLOAD
    request[:path] = "/doc/{{client_id}}/files/#{file.guid}/pages/#{page_number}/images/#{dimension}"
  end
  api.add_params(options)
  response = api.execute!

  filepath = "#{path}/#{name}"
  Object::File.open(filepath, 'wb') do |file|
    file.write(response)
  end

  filepath

end
page_images!(width, height, options = {}, access = {}) click to toggle source

Returns array of URLs to images representing document pages.

@example

file = GroupDocs::Storage::Folder.list!.last
document = file.to_document
document.page_images! 1024, 768, first_page: 0, page_count: 1

@param [Integer] width Image width @param [Integer] height Image height @param [Hash] options @option options [Integer] :first_page Start page to return image for (starting with 0) @option options [Integer] :page_count Number of pages to return image for @option options [Integer] :quality @option options [Boolean] :use_pdf @option options [Boolean] :token @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [Array<String>]

# File lib/groupdocs/document.rb, line 390
def page_images!(width, height, options = {}, access = {})
  api = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = "/doc/{{client_id}}/files/#{file.guid}/pages/images/#{width}x#{height}/urls"
  end
  api.add_params(options)
  json = api.execute!

  json[:url]
end
password_set!(password, access = {}) click to toggle source

Sets document password.

@param [String] password New password for document @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [Array<GroupDocs::User>]

# File lib/groupdocs/document.rb, line 730
def password_set!(password, access = {})
  Api::Request.new do |request|
    request[:access] = access
    request[:method] = :PUT
    request[:path] = "/doc/{{client_id}}/files/#{file.guid}/password"
    request[:request_body] = password
  end.execute!

end
public_sign_document!(options = {}, access = {}) click to toggle source

Changed in release 1.5.8

Public Sign document

@param [String] document Document GUID @param [Hash] settings Settings of the signing document @param settings [String] waterMarkText @param settings [String] waterMarkImage @param settings [String] name (required) @param settings [Double] top (required) @param settings [Double] left (required) @param settings [Double] width (required) @param settings [Double] height (required) @param settings [String] placeSignatureOn (required) @param settings [String] data @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [Array]

# File lib/groupdocs/document.rb, line 1355
def public_sign_document!(options = {}, access = {})
  json = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :POST
    request[:path] = "/signature/public/documents/#{file.guid}/sign"
    request[:request_body] = options
  end.execute!

  json[:jobId]
end
questionnaire_template!(fields, access = {}) click to toggle source

added in release 1.7.0

Create questionnaire template from file.

@example

file = GroupDocs::Storage::File.new({:guid => ‘3be4e06494caed131d912c75e17d5f22592e3044032e0f81b35f13a8c9fefb49’}).to_document field = GroupDocs::Document::TemplateEditorFields.new field.name = ‘test’ field.fieldtype = ‘TextBox’ field.page = 1 file.questionnaire_template!( )

@param List fields @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key

# File lib/groupdocs/document.rb, line 1422
def questionnaire_template!(fields, access = {})

  fields.each do |field|
    field.is_a?(GroupDocs::Document::TemplateEditorFields) or raise ArgumentError,
                                                                    "Fields should be List GroupDocs::Document::TemplateEditorFields objects, received: #{fields.inspect}"
  end

  json = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :POST
    request[:path] = "/merge/{{client_id}}/files/#{file.guid}/templates"
    request[:request_body] = fields
  end.execute!
  json[:templateFields].map do |field|
    Document::Field.new(field)
  end
end
questionnaires!(access = {}) click to toggle source

Returns an array of questionnaires.

@param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [Array<GroupDocs::Questionnaire>]

# File lib/groupdocs/document.rb, line 882
def questionnaires!(access = {})
  json = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = "/merge/{{client_id}}/files/#{file.guid}/questionnaires"
  end.execute!

  json[:questionnaires].map do |questionnaire|
    Questionnaire.new(questionnaire)
  end
end
remove_collaborators!(reviewerId, access = {}) click to toggle source
Delete document reviewer

@param [String] reviewerId Reviewer Id @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key

# File lib/groupdocs/document.rb, line 1209
def remove_collaborators!(reviewerId, access = {})
  Api::Request.new do |request|
    request[:access] = access
    request[:method] = :DELETE
    request[:path] = "/ant/{{client_id}}/files/#{file.guid}/collaborators/#{reviewerId}"
  end.execute!

end
remove_questionnaire!(questionnaire, access = {}) click to toggle source

Detaches questionnaire from document.

@param [GroupDocs::Questionnaire] questionnaire @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key

@raise [ArgumentError] if questionnaire is not GroupDocs::Questionnaire object

# File lib/groupdocs/document.rb, line 951
def remove_questionnaire!(questionnaire, access = {})
  questionnaire.is_a?(GroupDocs::Questionnaire) or raise ArgumentError,
                                                         "Questionnaire should be GroupDocs::Questionnaire object, received: #{questionnaire.inspect}"

  Api::Request.new do |request|
    request[:access] = access
    request[:method] = :DELETE
    request[:path] = "/merge/{{client_id}}/files/#{file.guid}/questionnaires/#{questionnaire.id}"
  end.execute!
end
respond_to?(method) click to toggle source
Calls superclass method
# File lib/groupdocs/document.rb, line 1309
def respond_to?(method)
  super or file.respond_to?(method)
end
set_collaborators!(emails, version = 1, access = {}) click to toggle source

Sets document annotations collaborators to given emails.

@param [Array<String>] emails List of collaborators’ email addresses @param [Integer] version Annotation version @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [Array<GroupDocs::User>]

# File lib/groupdocs/document.rb, line 1167
def set_collaborators!(emails, version = 1, access = {})
  json = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :PUT
    request[:path] = "/ant/{{client_id}}/files/#{file.guid}/version/#{version}/collaborators"
    request[:request_body] = emails
  end.execute!

  json[:collaborators].map do |collaborator|
    User.new(collaborator)
  end
end
set_reviewers!(reviewers, access = {}) click to toggle source

Sets reviewers for document.

@example Change reviewer rights

reviewers = document.collaborators!
reviewers.each do |reviewer|
  reviewer.access_rights = %w(view)
end
document.set_reviewers! reviewers

@param [Array<GroupDocs::User>] reviewers @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key

# File lib/groupdocs/document.rb, line 1233
def set_reviewers!(reviewers, access = {})
  Api::Request.new do |request|
    request[:access] = access
    request[:method] = :PUT
    request[:path] = "/ant/{{client_id}}/files/#{file.guid}/reviewerRights"
    request[:request_body] = reviewers.map(&:to_hash)
  end.execute!
end
set_session_callback!(url, access = {}) click to toggle source

Sets session callback URL.

@param [String] url Callback URL @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key

# File lib/groupdocs/document.rb, line 1291
def set_session_callback!(url, access = {})
  Api::Request.new do |request|
    request[:access] = access
    request[:method] = :PUT
    request[:path] = "/ant/{{client_id}}/files/#{file.guid}/sessionCallbackUrl"
    request[:request_body] = url
  end.execute!
end
shared_documents!(sharers_types, options = {}, access = {}) click to toggle source

Returns an array of users a document is shared with. @param [String] sharers_types @param [Hash] options @option options [String] :page_index @option options [String] :page_size @option options [String] :order_by @option options [Boolean] :order_ask @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [Array<GroupDocs::User>]

# File lib/groupdocs/document.rb, line 683
def shared_documents!(sharers_types, options = {}, access = {})
  api = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = "/doc/{{client_id}}/shares/#{sharers_types}"
  end
  api.add_params(options).execute!

end
sharers!(access = {}) click to toggle source

Returns an array of users a document is shared with.

@param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [Array<GroupDocs::User>]

# File lib/groupdocs/document.rb, line 658
def sharers!(access = {})
  json = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = "/doc/{{client_id}}/files/#{file.id}/accessinfo"
  end.execute!

  json[:sharers].map do |user|
    User.new(user)
  end
end
sharers_clear!(access = {}) click to toggle source

Clears sharers list.

@param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return nil

# File lib/groupdocs/document.rb, line 767
def sharers_clear!(access = {})
  Api::Request.new do |request|
    request[:access] = access
    request[:method] = :DELETE
    request[:path] = "/doc/{{client_id}}/files/#{file.id}/sharers"
  end.execute![:shared_users]

end
sharers_set!(emails, access = {}) click to toggle source

Sets document sharers to given emails.

If empty array or nil passed, clears sharers.

@param [Array] emails List of email addresses to share with @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [Array<GroupDocs::User>]

# File lib/groupdocs/document.rb, line 704
def sharers_set!(emails, access = {})
  if emails.nil? || emails.empty?
    sharers_clear!(access)
  else
    json = Api::Request.new do |request|
      request[:access] = access
      request[:method] = :PUT
      request[:path] = "/doc/{{client_id}}/files/#{file.id}/sharers"
      request[:request_body] = emails
    end.execute!

    json[:shared_users].map do |user|
      User.new(user)
    end
  end
end
tags!(access = {}) click to toggle source

Returns tags assigned to the document

@param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [Array<String>]

# File lib/groupdocs/document.rb, line 445
def tags!(access = {})
  Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = "/doc/{{client_id}}/files/#{file.guid}/tags"
  end.execute!
end
tags_clear!(access = {}) click to toggle source
Removes tags assigned to the document

@param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [String]

# File lib/groupdocs/document.rb, line 477
def tags_clear!(access = {})
  Api::Request.new do |request|
    request[:access] = access
    request[:method] = :DELETE
    request[:path] = "/doc/{{client_id}}/files/#{file.guid}/tags"
  end.execute!
end
tags_set!(access = {}) click to toggle source
Assign tags to the document.

@param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [String]

# File lib/groupdocs/document.rb, line 461
def tags_set!(access = {})
  Api::Request.new do |request|
    request[:access] = access
    request[:method] = :PUT
    request[:path] = "/doc/{{client_id}}/files/#{file.guid}/tags"
  end.execute!
end
thumbnails!(options = {}, access = {}) click to toggle source

Returns array of URLs to images representing document pages thumbnails.

@example

file = GroupDocs::Storage::Folder.list!.last
document = file.to_document
document.thumbnails! first_page: 0, page_count: 1, width: 1024

@param [Hash] options @option options [Integer] :page_number Start page to return image for (starting with 0) @option options [Integer] :page_count Number of pages to return image for @option options [Integer] :width @option options [Integer] :quality @option options [Boolean] :use_pdf @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [Array<String>]

# File lib/groupdocs/document.rb, line 523
def thumbnails!(options = {}, access = {})
  api = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :POST
    request[:path] = "/doc/{{client_id}}/files/#{file.guid}/thumbnails"
  end
  api.add_params(options)
  json = api.execute!

  json[:image_urls]
end
update_changes!(changes, access = {}) click to toggle source

Updated in release 2.1.0

Schedules a job for comparing document with given.

@param [Array] changes Comparison changes to update (accept or reject) @option id [Float] :id @option type [String] :type @option action [String] :action @option Page [Array] :page @option box [Array] :box @option text [String] :text @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [GroupDocs::Change]

# File lib/groupdocs/document.rb, line 1050
def update_changes!(changes, access = {})
  if changes.is_a?(Array)
    changes.each do |e|
      e.is_a?(GroupDocs::Document::Change) or raise ArgumentError,
                                               "Change should be GroupDocs::Document::Change object, received: #{e.inspect}"
    end
  else
    raise ArgumentError, "Changes should be Array , received: #{changes.inspect}"
  end
  api = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :PUT
    request[:path] = "/comparison/public/#{file.guid}/changes"
    request[:request_body] = changes
  end
  api.execute!
end
update_questionnaire_template!(fields, access = {}) click to toggle source

added in release 1.8.0

Update template’s fields

@example

file = GroupDocs::Storage::File.new({:guid => ‘3be4e06494caed131d912c75e17d5f22592e3044032e0f81b35f13a8c9fefb49’}).to_document field = GroupDocs::Document::TemplateEditorFields.new field.name = ‘test’ field.fieldtype = ‘TextBox’ field.page = 1 file.update_questionnaire_template!( )

@param List fields @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key

# File lib/groupdocs/document.rb, line 1497
def update_questionnaire_template!(fields, access = {})

  fields.each do |field|
    field.is_a?(GroupDocs::Document::TemplateEditorFields) or raise ArgumentError,
                                                                    "Fields should be List GroupDocs::Document::TemplateEditorFields objects, received: #{fields.inspect}"
  end

  json = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :PUT
    request[:path] = "/merge/{{client_id}}/files/#{file.guid}/templates/update"
    request[:request_body] = fields
  end.execute!
  json[:templateFields].map do |field|
    Document::Field.new(field)
  end
end
user_status_set!(status, access = {}) click to toggle source

Sets document user status.

@param [String] status (Pending = 0, Accepted = 1, Declined = 2) @param [Hash] access Access credentials @option access [String] :client_id @option access [String] :private_key @return [String]

# File lib/groupdocs/document.rb, line 749
def user_status_set!(status, access = {})
  Api::Request.new do |request|
    request[:access] = access
    request[:method] = :PUT
    request[:path] = "/doc/{{client_id}}/files/#{file.guid}/sharer"
    request[:request_body] = status
  end.execute!

end