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



311
312
313
314
315
 
# File 'lib/groupdocs/document.rb', line 311

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 



1395
1396
1397
 
# File 'lib/groupdocs/document.rb', line 1395

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

Instance Attribute Details

#dependent_questionnaires_count ⇒ Object 



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

def dependent_questionnaires_count
  @dependent_questionnaires_count
end

#field_count ⇒ Object 



210
211
212
 
# File 'lib/groupdocs/document.rb', line 210

def field_count
  @field_count
end

#fieldType ⇒ Object

added in release 1.6.0



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

def fieldType
  @fieldType
end

#file ⇒ Object 



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

def file
  @file
end

#order ⇒ Object 



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

def order
  @order
end

#output_formats ⇒ Array<Symbol>

Returns output formats in human-readable format.

Returns:

  • (Array<Symbol>) 


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

def output_formats
  @output_formats
end

#outputs ⇒ Object 



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

def outputs
  @outputs
end

#process_date ⇒ Time

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

Returns:

  • (Time) 


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

def process_date
  @process_date
end

#status ⇒ Symbol

Converts status to human-readable format.

Returns:

  • (Symbol) 


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

def status
  @status
end

#upload_time ⇒ Object 



218
219
220
 
# File 'lib/groupdocs/document.rb', line 218

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:



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

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) 


1469
1470
1471
1472
1473
1474
1475
 
# File 'lib/groupdocs/document.rb', line 1469

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

# 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”



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
149
150
 
# 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 = {}) ⇒ 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



645
646
647
648
649
650
651
652
653
 
# File 'lib/groupdocs/document.rb', line 645

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



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

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) 


1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
 
# File 'lib/groupdocs/document.rb', line 1279

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



1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
 
# File 'lib/groupdocs/document.rb', line 1000

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) 


1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
 
# File 'lib/groupdocs/document.rb', line 1552

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:



1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
 
# File 'lib/groupdocs/document.rb', line 1066

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) 


1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
 
# File 'lib/groupdocs/document.rb', line 1175

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:



1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
 
# File 'lib/groupdocs/document.rb', line 1236

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



1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
 
# File 'lib/groupdocs/document.rb', line 1114

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) 


566
567
568
569
570
571
572
573
574
 
# File 'lib/groupdocs/document.rb', line 566

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:



894
895
896
897
898
899
900
901
902
903
904
905
906
 
# File 'lib/groupdocs/document.rb', line 894

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



1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
 
# File 'lib/groupdocs/document.rb', line 1022

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



922
923
924
925
926
927
928
929
930
931
932
933
934
935
 
# File 'lib/groupdocs/document.rb', line 922

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



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

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) 


1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
 
# File 'lib/groupdocs/document.rb', line 1624

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) 


1092
1093
1094
1095
1096
1097
1098
1099
1100
 
# File 'lib/groupdocs/document.rb', line 1092

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) 


160
161
162
163
164
165
166
167
168
 
# 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 = {}) ⇒ 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) 


1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
 
# File 'lib/groupdocs/document.rb', line 1207

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) 


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

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) 


500
501
502
503
504
505
506
507
 
# File 'lib/groupdocs/document.rb', line 500

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) 


1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
 
# File 'lib/groupdocs/document.rb', line 1485

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:



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

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


686
687
688
689
690
691
692
693
694
695
696
 
# File 'lib/groupdocs/document.rb', line 686

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) 


1413
1414
1415
1416
1417
1418
1419
1420
1421
 
# File 'lib/groupdocs/document.rb', line 1413

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:



706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
 
# File 'lib/groupdocs/document.rb', line 706

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_fixed_html!(path, name, page_number, options = {}, access = {}) ⇒ Object

Returns an HTML Fixed representation of a particular document page

Parameters:

  • page_number (Integer) —

    Document page number to get html for

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

    Access credentials

Options Hash (options):

  • :expires (Boolean) —

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

Options Hash (access):

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

Returns:



366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
 
# File 'lib/groupdocs/document.rb', line 366

def page_fixed_html!(path, name, page_number,  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}/htmlFixed"
  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_html!(path, name, page_number, options = {}, access = {}) ⇒ Object

Returns an HTML representation of a particular document page

Parameters:

  • page_number (Integer) —

    Document page number to get html for

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

    Access credentials

Options Hash (options):

  • :expires (Boolean) —

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

Options Hash (access):

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

Returns:



396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
 
# File 'lib/groupdocs/document.rb', line 396

def page_html!(path, name, page_number,  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}/htmlRepresentations"
  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_html_urls!(options = {}, access = {}) ⇒ Array<String>

Returns array of URLs to html representing document pages.

Examples:

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

Parameters:

  • 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

Options Hash (access):

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

Returns:

  • (Array<String>) 


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

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

  json[:url]
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:



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

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


435
436
437
438
439
440
441
442
443
444
445
 
# File 'lib/groupdocs/document.rb', line 435

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:



826
827
828
829
830
831
832
833
834
 
# File 'lib/groupdocs/document.rb', line 826

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) 


1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
 
# File 'lib/groupdocs/document.rb', line 1445

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) 


1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
 
# File 'lib/groupdocs/document.rb', line 1515

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:



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

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) 


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

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



1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
 
# File 'lib/groupdocs/document.rb', line 1047

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

#representations!(options = {}, access = {}) ⇒ Array<String>

Returns array of URLs to images representing document pages htmlRepresentations.

Examples:

file = GroupDocs::Storage::Folder.list!.last
document = file.to_document
document.representations! first_page: 0, page_count: 1, passwordSalt: ***

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

  • :passwordSalt (Integer)

Options Hash (access):

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

Returns:

  • (Array<String>) 


624
625
626
627
628
629
630
631
632
633
634
 
# File 'lib/groupdocs/document.rb', line 624

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

  json[:pageHtml]
end

#respond_to?(method) ⇒ Boolean

Returns:

  • (Boolean) 


1399
1400
1401
 
# File 'lib/groupdocs/document.rb', line 1399

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:



1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
 
# File 'lib/groupdocs/document.rb', line 1258

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) 


1324
1325
1326
1327
1328
1329
1330
1331
 
# File 'lib/groupdocs/document.rb', line 1324

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) 


1381
1382
1383
1384
1385
1386
1387
1388
 
# File 'lib/groupdocs/document.rb', line 1381

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


1364
1365
1366
1367
1368
1369
1370
1371
 
# File 'lib/groupdocs/document.rb', line 1364

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:



779
780
781
782
783
784
785
786
787
 
# File 'lib/groupdocs/document.rb', line 779

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


1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
 
# File 'lib/groupdocs/document.rb', line 1341

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:



754
755
756
757
758
759
760
761
762
763
764
 
# File 'lib/groupdocs/document.rb', line 754

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



863
864
865
866
867
868
869
870
 
# File 'lib/groupdocs/document.rb', line 863

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:



800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
 
# File 'lib/groupdocs/document.rb', line 800

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


517
518
519
520
521
522
523
 
# File 'lib/groupdocs/document.rb', line 517

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) 


549
550
551
552
553
554
555
 
# File 'lib/groupdocs/document.rb', line 549

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) 


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

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


595
596
597
598
599
600
601
602
603
604
605
 
# File 'lib/groupdocs/document.rb', line 595

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) 


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

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) 


1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
 
# File 'lib/groupdocs/document.rb', line 1590

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) 


845
846
847
848
849
850
851
852
853
 
# File 'lib/groupdocs/document.rb', line 845

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