Class: GroupDocs::Document

Inherits:
Api::Entity show all
Extended by:
Api::Helpers::MIME
Includes:
Api::Helpers::AccessMode, Api::Helpers::AccessRights, Api::Helpers::Status
Defined in:
lib/groupdocs/document.rb

Defined Under Namespace

Classes: Annotation, Change, Field, MetaData, Rectangle, TemplateEditorFieldStyle, TemplateEditorFields, View

Constant Summary collapse

ACCESS_MODES = 
{
    :private    => 0,
    :restricted => 1,
    :public     => 2,
    :inherited  => 254,
    :denied     => 255,
}

Constants included from Api::Helpers::AccessRights

Api::Helpers::AccessRights::ACCESS_RIGHTS

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Api::Helpers::ByteFlag

#array_from_byte, #byte_from_array

Methods inherited from Api::Entity

#inspect, #to_hash

Methods included from Api::Helpers::Accessor

#alias_accessor

Constructor Details

#initialize(options = {}, &blk) ⇒ Document

Creates new GroupDocs::Document.

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

Raises:

  • (ArgumentError) —

    If file is not passed or is not an instance of GroupDocs::Storage::File



309
310
311
312
313
 
# File 'lib/groupdocs/document.rb', line 309

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

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method, *args, &blk) ⇒ Object 



1282
1283
1284
 
# File 'lib/groupdocs/document.rb', line 1282

def method_missing(method, *args, &blk)
  file.respond_to?(method) ? file.send(method, *args, &blk) : super
end

Instance Attribute Details

#dependent_questionnaires_count ⇒ Object 



214
215
216
 
# File 'lib/groupdocs/document.rb', line 214

def dependent_questionnaires_count
  @dependent_questionnaires_count
end

#field_count ⇒ Object 



208
209
210
 
# File 'lib/groupdocs/document.rb', line 208

def field_count
  @field_count
end

#fieldType ⇒ Object

added in release 1.6.0



212
213
214
 
# File 'lib/groupdocs/document.rb', line 212

def fieldType
  @fieldType
end

#file ⇒ Object 



196
197
198
 
# File 'lib/groupdocs/document.rb', line 196

def file
  @file
end

#order ⇒ Object 



206
207
208
 
# File 'lib/groupdocs/document.rb', line 206

def order
  @order
end

#output_formats ⇒ Array<Symbol>

Returns output formats in human-readable format.

Returns:

  • (Array<Symbol>) 


202
203
204
 
# File 'lib/groupdocs/document.rb', line 202

def output_formats
  @output_formats
end

#outputs ⇒ Object 



200
201
202
 
# File 'lib/groupdocs/document.rb', line 200

def outputs
  @outputs
end

#process_date ⇒ Time

Converts timestamp which is return by API server to Time object.

Returns:

  • (Time) 


198
199
200
 
# File 'lib/groupdocs/document.rb', line 198

def process_date
  @process_date
end

#status ⇒ Symbol

Converts status to human-readable format.

Returns:

  • (Symbol) 


204
205
206
 
# File 'lib/groupdocs/document.rb', line 204

def status
  @status
end

#upload_time ⇒ Object 



216
217
218
 
# File 'lib/groupdocs/document.rb', line 216

def upload_time
  @upload_time
end

Class Method Details

.metadata!(path, access = {}) ⇒ Array<GroupDocs::Document::View>

Returns a document metadata by given path.

Parameters:

  • path (String) —

    Full path to document

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:



177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
 
# File 'lib/groupdocs/document.rb', line 177

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]
    if json[:last_view]
      metadata.last_view = json[:last_view]
    end
  end
end

.public_fields!(access = {}) ⇒ Array

Changed in release 1.5.8

Get document fields

Parameters:

  • document (String) —

    Document GUID

  • settings (Hash) —

    Settings of the signing document

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:

  • (Array) 


1356
1357
1358
1359
1360
1361
1362
 
# File 'lib/groupdocs/document.rb', line 1356

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 = {}) ⇒ Object

Signs given documents with signatures.

Examples:

# 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 = "[email protected]"
signature_two.position = { top: 0.2, left: 0.2, width: 100, height: 100 }
signature_one.email = "[email protected]"
# 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

Parameters:

  • documents (Array<GroupDocs::Document>) —

    Each document file should have “#name” and “#local_path”

  • signatures (Array<GroupDocs::Signature>) —

    Each signature should have “#name”, “#image_path” and “#position”



101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
# File 'lib/groupdocs/document.rb', line 101

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 = {}) ⇒ Array<GroupDocs::Document>

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

Parameters:

  • options (Hash) (defaults to: {}) —

    Options

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (options):

  • :orderBy (String) —

    Order by column

  • :isAscending (Boolean) —

    Order by ascending or descending

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:



62
63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/groupdocs/document.rb', line 62

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 = {}) ⇒ Array<GroupDocs::Document::View>

Returns an array of views for all documents.

Parameters:

  • options (Hash) (defaults to: {})
  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (options):

  • :page_index (Integer) —

    Page to start with

  • :page_size (Integer) —

    Total number of entries

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:



37
38
39
40
41
42
43
44
45
46
47
48
49
 
# File 'lib/groupdocs/document.rb', line 37

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

Instance Method Details

#access_mode!(access = {}) ⇒ Symbol

Returns access mode of document.

Parameters:

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:

  • (Symbol) —

    One of :private, :restricted or :public access modes



532
533
534
535
536
537
538
539
540
 
# File 'lib/groupdocs/document.rb', line 532

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_set!(mode, access = {}) ⇒ Symbol Also known as: access_mode=

Sets access mode of document.

Parameters:

  • mode (Symbol) —

    One of :private, :restricted or :public access modes

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:

  • (Symbol) —

    Set access mode



551
552
553
554
555
556
557
558
559
560
561
 
# File 'lib/groupdocs/document.rb', line 551

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

#add_collaborator!(collaborator, access = {}) ⇒ Object

Adds document annotations collaborator.

Parameters:

  • collaborator (GroupDocs::User)
  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String) 


1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
 
# File 'lib/groupdocs/document.rb', line 1166

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 = {}) ⇒ Object

Adds questionnaire to document.

Parameters:

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Raises:

  • (ArgumentError) —

    if questionnaire is not GroupDocs::Questionnaire object



887
888
889
890
891
892
893
894
895
896
 
# File 'lib/groupdocs/document.rb', line 887

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 = {}) ⇒ Object

added in release 1.8.0

Add template editor fields to the specific document

@example

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

Parameters:

Options Hash (access):

  • :client_id (String)
  • :private_key (String) 


1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
 
# File 'lib/groupdocs/document.rb', line 1439

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 = {}) ⇒ Array<GroupDocs::Document::Annotation>

Returns an array of annotations.

Parameters:

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:



953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
 
# File 'lib/groupdocs/document.rb', line 953

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 = {}) ⇒ Object

Returns an array of changes in document.

Examples:

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!

Parameters:

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String) 


1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
 
# File 'lib/groupdocs/document.rb', line 1062

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 = {}) ⇒ Array<GroupDocs::User>

Returns document annotations collaborators.

Parameters:

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:



1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
 
# File 'lib/groupdocs/document.rb', line 1123

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 = {}) ⇒ GroupDocs::Job

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

Parameters:

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:

Raises:

  • (ArgumentError) —

    if document is not GroupDocs::Document object



1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
 
# File 'lib/groupdocs/document.rb', line 1001

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 = {}) ⇒ String

Returns document content

Parameters:

  • content_type (String) —

    Content type

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:

  • (String) 


481
482
483
484
485
486
487
488
489
 
# File 'lib/groupdocs/document.rb', line 481

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 = {}) ⇒ GroupDocs::Job

Converts document to given format.

Examples:

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__))

Parameters:

  • format (Symbol)
  • options (Hash) (defaults to: {})
  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (options):

  • :email_results (Boolean)
  • :new_description (String)
  • :print_script (String)
  • :callback (String)

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:



781
782
783
784
785
786
787
788
789
790
791
792
793
 
# File 'lib/groupdocs/document.rb', line 781

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 = {}) ⇒ GroupDocs::Questionnaire

Creates questionnaire and adds it to document.

Parameters:

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:

Raises:

  • (ArgumentError) —

    if questionnaire is not GroupDocs::Questionnaire object



909
910
911
912
913
914
915
916
917
918
919
920
921
922
 
# File 'lib/groupdocs/document.rb', line 909

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 = {}) ⇒ GroupDocs::Job

Creates new job to merge datasource into document.

Parameters:

  • datasource (GroupDocs::DataSource)
  • options (Hash) (defaults to: {})
  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (options):

  • :new_type (Boolean) —

    New file format type

  • :email_results (Boolean) —

    Set to true if converted document should be emailed

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:

Raises:

  • (ArgumentError) —

    if datasource is not GroupDocs::DataSource object



809
810
811
812
813
814
815
816
817
818
819
820
821
822
 
# File 'lib/groupdocs/document.rb', line 809

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 = {}) ⇒ GroupDocs::Job

Creates new job to merge datasource fields into document.

Parameters:

  • datasource (GroupDocs::DataSource)
  • options (Hash) (defaults to: {})
  • datasourceFields (Array) —

    (:name [String], :value [String], :contentType [String], :type [String], :nested_fields [<Array> datasourceFields])

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (options):

  • :new_type (Boolean) —

    New file format type

  • :email_results (Boolean) —

    Set to true if converted document should be emailed

  • :assembly_name (Boolean)

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:

Raises:

  • (ArgumentError) —

    if datasource is not GroupDocs::DataSource object



840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
 
# File 'lib/groupdocs/document.rb', line 840

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 = {}) ⇒ Object

added in release 1.8.0

Delete template’s fields

@example

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

Parameters:

Options Hash (access):

  • :client_id (String)
  • :private_key (String) 


1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
 
# File 'lib/groupdocs/document.rb', line 1511

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 = {}) ⇒ Hash

Changed in release 1.5.8 Returns document details.

Parameters:

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:

  • (Hash) 


979
980
981
982
983
984
985
986
987
 
# File 'lib/groupdocs/document.rb', line 979

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 = {}) ⇒ Object

Get sign documents status

Parameters:

  • job_guid (String)
  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String) 


158
159
160
161
162
163
164
165
166
 
# File 'lib/groupdocs/document.rb', line 158

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 = {}) ⇒ Object

Changed in release 1.5.8 Download comparison result file.

Examples:

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'})

Parameters:

  • options (Hash) (defaults to: {})
  • access (Hash) (defaults to: {}) —

    Access credentials

  • format (Hash) —

    a customizable set of options

Options Hash (access):

  • :client_id (String)
  • :private_key (String) 


1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
 
# File 'lib/groupdocs/document.rb', line 1094

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 = {}) ⇒ Object

Returns editing metadata.

Parameters:

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String) 


397
398
399
400
401
402
403
 
# File 'lib/groupdocs/document.rb', line 397

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 = {}) ⇒ Integer

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

Parameters:

  • options (Hash) (defaults to: {})
  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (options):

  • :lockId (String) —

    Start page to return image for (starting with 0)

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:

  • (Integer) 


415
416
417
418
419
420
421
422
 
# File 'lib/groupdocs/document.rb', line 415

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 = {}) ⇒ Object

added in release 1.7.0

Get template fields.

Parameters:

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String) 


1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
 
# File 'lib/groupdocs/document.rb', line 1372

def editor_fields!(access = {})
  json = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = "/doc/{{client_id}}/files/#{file.guid}/editor_fields"
  end.execute!
  json[:fields].map do |field|
    TemplateEditorFields.new(field)
  end
end

#fields!(access = {}) ⇒ Array<GroupDocs::Document::Field>

Returns an array of document fields.

Parameters:

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:



619
620
621
622
623
624
625
626
627
628
629
630
631
 
# File 'lib/groupdocs/document.rb', line 619

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 = {}) ⇒ Array<Symbol>

Returns array of file formats document can be converted to.

Parameters:

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:

  • (Array<Symbol>) 


573
574
575
576
577
578
579
580
581
582
583
 
# File 'lib/groupdocs/document.rb', line 573

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

#hyperlinks!(access = {}) ⇒ Object

added in release 1.5.8

Returns document hyperlinks

Parameters:

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String) 


1300
1301
1302
1303
1304
1305
1306
1307
1308
 
# File 'lib/groupdocs/document.rb', line 1300

def hyperlinks!(access = {})
  json = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = "/doc/{{client_id}}/files/#{file.guid}/hyperlinks"
  end.execute!

  json[:links]
end

#metadata!(access = {}) ⇒ GroupDocs::Document::MetaData

Returns document metadata.

Parameters:

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:



593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
 
# File 'lib/groupdocs/document.rb', line 593

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]
    if json[:last_view]
      metadata.last_view = json[:last_view]
    end
  end
end

#page_image!(path, name, page_number, dimension, options = {}, access = {}) ⇒ Object

Returns a stream of bytes representing a particular document page image.

Examples:

path = “#File.dirname(__FILE__)”

name = "test.jpg"

Parameters:

  • path (String) —

    Document path

  • name (String) —

    Name document (format - jpg)

  • page_number (Integer) —

    Document page number to get image for

  • dimension (Integer) —

    Image dimension “<width>x<height>”(500x600)

  • options (Hash) (defaults to: {})
  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (options):

  • :quality (Integer) —

    Image quality in range 1-100.

  • :use_pdf (Boolean) —

    A flag indicating whether a document should be converted to PDF format before generating the image.

  • :expires (Boolean) —

    The date and time in milliseconds since epoch the URL expires.

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:



333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
 
# File 'lib/groupdocs/document.rb', line 333

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 = {}) ⇒ Array<String>

Returns array of URLs to images representing document pages.

Examples:

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

Parameters:

  • width (Integer) —

    Image width

  • height (Integer) —

    Image height

  • options (Hash) (defaults to: {})
  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (options):

  • :first_page (Integer) —

    Start page to return image for (starting with 0)

  • :page_count (Integer) —

    Number of pages to return image for

  • :quality (Integer)
  • :use_pdf (Boolean)
  • :token (Boolean)

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:

  • (Array<String>) 


377
378
379
380
381
382
383
384
385
386
387
 
# File 'lib/groupdocs/document.rb', line 377

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 = {}) ⇒ Array<GroupDocs::User>

Sets document password.

Parameters:

  • password (String) —

    New password for document

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:



713
714
715
716
717
718
719
720
721
 
# File 'lib/groupdocs/document.rb', line 713

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 = {}) ⇒ Array

Changed in release 1.5.8

Public Sign document

Parameters:

  • document (String) —

    Document GUID

  • settings (Hash) —

    Settings of the signing document

  • settings (String) —

    waterMarkText

  • settings (String) —

    waterMarkImage

  • settings (String) —

    name (required)

  • settings (Double) —

    top (required)

  • settings (Double) —

    left (required)

  • settings (Double) —

    width (required)

  • settings (Double) —

    height (required)

  • settings (String) —

    placeSignatureOn (required)

  • settings (String) —

    data

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:

  • (Array) 


1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
 
# File 'lib/groupdocs/document.rb', line 1332

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 = {}) ⇒ Object

added in release 1.7.0

Create questionnaire template from file.

@example

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

Parameters:

Options Hash (access):

  • :client_id (String)
  • :private_key (String) 


1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
 
# File 'lib/groupdocs/document.rb', line 1402

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 = {}) ⇒ Array<GroupDocs::Questionnaire>

Returns an array of questionnaires.

Parameters:

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:



865
866
867
868
869
870
871
872
873
874
875
 
# File 'lib/groupdocs/document.rb', line 865

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 = {}) ⇒ Object

Delete document reviewer

Parameters:

  • reviewerId (String) —

    Reviewer Id

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String) 


1187
1188
1189
1190
1191
1192
1193
1194
 
# File 'lib/groupdocs/document.rb', line 1187

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 = {}) ⇒ Object

Detaches questionnaire from document.

Parameters:

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Raises:

  • (ArgumentError) —

    if questionnaire is not GroupDocs::Questionnaire object



934
935
936
937
938
939
940
941
942
943
 
# File 'lib/groupdocs/document.rb', line 934

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) ⇒ Boolean

Returns:

  • (Boolean) 


1286
1287
1288
 
# File 'lib/groupdocs/document.rb', line 1286

def respond_to?(method)
  super or file.respond_to?(method)
end

#set_collaborators!(emails, version = 1, access = {}) ⇒ Array<GroupDocs::User>

Sets document annotations collaborators to given emails.

Parameters:

  • emails (Array<String>) —

    List of collaborators’ email addresses

  • version (Integer) (defaults to: 1) —

    Annotation version

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:



1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
 
# File 'lib/groupdocs/document.rb', line 1145

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 = {}) ⇒ Object

Sets reviewers for document.

Examples:

Change reviewer rights

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

Parameters:

  • reviewers (Array<GroupDocs::User>)
  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String) 


1211
1212
1213
1214
1215
1216
1217
1218
 
# File 'lib/groupdocs/document.rb', line 1211

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 = {}) ⇒ Object

Sets session callback URL.

Parameters:

  • url (String) —

    Callback URL

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String) 


1268
1269
1270
1271
1272
1273
1274
1275
 
# File 'lib/groupdocs/document.rb', line 1268

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

#set_shared_link_access_rights!(rights, access = {}) ⇒ Array<Symbol>

Sets access rights for shared link.

Parameters:

  • rights (Array<Symbol>)
  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:

  • (Array<Symbol>) 


1251
1252
1253
1254
1255
1256
1257
1258
 
# File 'lib/groupdocs/document.rb', line 1251

def set_shared_link_access_rights!(rights, access = {})
  Api::Request.new do |request|
    request[:access] = access
    request[:method] = :PUT
    request[:path] = "/ant/{{client_id}}/files/#{file.guid}/sharedLinkAccessRights"
    request[:request_body] = convert_access_rights_to_byte(rights)
  end.execute!
end

#shared_documents!(sharers_types, options = {}, access = {}) ⇒ Array<GroupDocs::User>

Returns an array of users a document is shared with.

Parameters:

  • sharers_types (String)
  • options (Hash) (defaults to: {})
  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (options):

  • :page_index (String)
  • :page_size (String)
  • :order_by (String)
  • :order_ask (Boolean)

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:



666
667
668
669
670
671
672
673
674
 
# File 'lib/groupdocs/document.rb', line 666

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

#shared_link_access_rights!(access = {}) ⇒ Array<Symbol>

Returns an array of access rights for shared link.

Parameters:

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:

  • (Array<Symbol>) 


1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
 
# File 'lib/groupdocs/document.rb', line 1228

def shared_link_access_rights!(access = {})
  json = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :GET
    request[:path] = "/ant/{{client_id}}/files/#{file.guid}/sharedLinkAccessRights"
  end.execute!

  if json[:accessRights]
    convert_byte_to_access_rights json[:accessRights]
  else
    []
  end
end

#sharers!(access = {}) ⇒ Array<GroupDocs::User>

Returns an array of users a document is shared with.

Parameters:

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:



641
642
643
644
645
646
647
648
649
650
651
 
# File 'lib/groupdocs/document.rb', line 641

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 = {}) ⇒ Object

Clears sharers list.

Parameters:

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:

  • nil



750
751
752
753
754
755
756
757
 
# File 'lib/groupdocs/document.rb', line 750

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 = {}) ⇒ Array<GroupDocs::User>

Sets document sharers to given emails.

If empty array or nil passed, clears sharers.

Parameters:

  • emails (Array) —

    List of email addresses to share with

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:



687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
 
# File 'lib/groupdocs/document.rb', line 687

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 = {}) ⇒ Array<String>

Returns tags assigned to the document

Parameters:

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:

  • (Array<String>) 


432
433
434
435
436
437
438
 
# File 'lib/groupdocs/document.rb', line 432

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 = {}) ⇒ String

Removes tags assigned to the document

Parameters:

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:

  • (String) 


464
465
466
467
468
469
470
 
# File 'lib/groupdocs/document.rb', line 464

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 = {}) ⇒ String

Assign tags to the document.

Parameters:

  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:

  • (String) 


448
449
450
451
452
453
454
 
# File 'lib/groupdocs/document.rb', line 448

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 = {}) ⇒ Array<String>

Returns array of URLs to images representing document pages thumbnails.

Examples:

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

Parameters:

  • options (Hash) (defaults to: {})
  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (options):

  • :page_number (Integer) —

    Start page to return image for (starting with 0)

  • :page_count (Integer) —

    Number of pages to return image for

  • :width (Integer)
  • :quality (Integer)
  • :use_pdf (Boolean)

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:

  • (Array<String>) 


510
511
512
513
514
515
516
517
518
519
520
 
# File 'lib/groupdocs/document.rb', line 510

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 = {}) ⇒ GroupDocs::Change

Schedules a job for comparing document with given.

Parameters:

  • changes (Array) —

    Comparison changes to update (accept or reject)

  • access (Hash) (defaults to: {}) —

    Access credentials

  • id (Hash) —

    a customizable set of options

  • type (Hash) —

    a customizable set of options

  • action (Hash) —

    a customizable set of options

  • Page (Hash) —

    a customizable set of options

  • box (Hash) —

    a customizable set of options

  • text (Hash) —

    a customizable set of options

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:

  • (GroupDocs::Change) 


1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
 
# File 'lib/groupdocs/document.rb', line 1031

def update_changes!(changes, access = {})

  api = Api::Request.new do |request|
    request[:access] = access
    request[:method] = :PUT
    request[:path] = "/comparison/public/#{file.guid}/changes"
    request[:request_body] = changes
  end
  json = api.execute!

  json[:changes].map do |change|
    Document::Change.new(change)
  end
end

#update_questionnaire_template!(fields, access = {}) ⇒ Object

added in release 1.8.0

Update template’s fields

@example

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

Parameters:

Options Hash (access):

  • :client_id (String)
  • :private_key (String) 


1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
 
# File 'lib/groupdocs/document.rb', line 1477

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 = {}) ⇒ String

Sets document user status.

Parameters:

  • status (String)
  • access (Hash) (defaults to: {}) —

    Access credentials

Options Hash (access):

  • :client_id (String)
  • :private_key (String)

Returns:

  • (String) 


732
733
734
735
736
737
738
739
740
 
# File 'lib/groupdocs/document.rb', line 732

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