Class: Uploadcare::Api::Upload::Files

Inherits:
Object
  • Object
show all
Defined in:
lib/uploadcare/api/upload/files.rb

Overview

Upload API endpoint for file upload operations. rubocop:disable Metrics/ClassLength

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(upload:) ⇒ Files

Returns a new instance of Files.

Parameters:



10
11
12
 
# File 'lib/uploadcare/api/upload/files.rb', line 10

def initialize(upload:)
  @upload = upload
end

Instance Attribute Details

#upload ⇒ Uploadcare::Api::Upload (readonly)

Returns Parent Upload client.

Returns:



7
8
9
 
# File 'lib/uploadcare/api/upload/files.rb', line 7

def upload
  @upload
end

Instance Method Details

#direct(file:, request_options: {}, **options) ⇒ Uploadcare::Result

Upload a file directly (POST /base/).

Parameters:

  • file (File, IO) —

    File object to upload

  • options (Hash) —

    Upload options (:store, :metadata, :signature, :expire)

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

    Request options

Returns:

Raises:

  • (ArgumentError) —

    if file is not a valid IO object

See Also:



22
23
24
25
26
27
28
29
30
 
# File 'lib/uploadcare/api/upload/files.rb', line 22

def direct(file:, request_options: {}, **options)
  Uploadcare::Result.capture do
    prepared_file = Uploadcare::Internal::UploadIo.wrap(file)
    params = build_upload_params(prepared_file, options)
    Uploadcare::Result.unwrap(upload.post(path: 'base/', params: params, request_options: request_options))
  ensure
    prepared_file&.close!
  end
end

#direct_many(files:, request_options: {}, **options) ⇒ Uploadcare::Result

Upload multiple files directly (POST /base/).

Parameters:

  • files (Array<File, IO>) —

    Files to upload

  • options (Hash) —

    Upload options (:store, :metadata)

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

    Request options

Returns:

See Also:



39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/uploadcare/api/upload/files.rb', line 39

def direct_many(files:, request_options: {}, **options)
  Uploadcare::Result.capture do
    raise ArgumentError, 'files must be an array' unless files.is_a?(Array)
    raise ArgumentError, 'files cannot be empty' if files.empty?

    prepared_files = []
    params = Uploadcare::Internal::UploadParamsGenerator.call(
      options: options, config: upload.config
    )
    files.each do |file|
      prepared_file = Uploadcare::Internal::UploadIo.wrap(file)
      prepared_files << prepared_file
      form_data_for(prepared_file, params, field_index: prepared_files.length - 1)
    end
    Uploadcare::Result.unwrap(upload.post(path: '/base/', params: params, request_options: request_options))
  ensure
    prepared_files&.each(&:close!)
  end
end

#from_url(source_url:, request_options: {}, **options) ⇒ Uploadcare::Result

Upload a file from URL (POST /from_url/).

Parameters:

  • source_url (String) —

    URL of the file to upload

  • options (Hash) —

    Upload options

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

    Request options

Options Hash (**options):

  • :async (Boolean) —

    Return immediately with token (default: false)

  • :store (String, Boolean) —

    Whether to store the file

  • :metadata (Hash) —

    Custom metadata

  • :poll_interval (Integer) —

    Polling interval in seconds (default: 1)

  • :poll_timeout (Integer) —

    Max polling time in seconds (default: 300)

Returns:

See Also:



71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/uploadcare/api/upload/files.rb', line 71

def from_url(source_url:, request_options: {}, **options)
  Uploadcare::Result.capture do
    validate_url(source_url)
    async_mode = options.fetch(:async, false)
    params = build_from_url_params(source_url, options)
    response = Uploadcare::Result.unwrap(
      upload.post(path: 'from_url/', params: params, request_options: request_options)
    )
    if async_mode
      response
    else
      poll_upload_status(token: response['token'], options: options, request_options: request_options)
    end
  end
end

#from_url_status(token:, request_options: {}) ⇒ Uploadcare::Result

Get upload-from-URL status (GET /from_url/status/).

Parameters:

  • token (String) —

    Upload token from async upload

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

    Request options

Returns:

See Also:



93
94
95
96
97
98
99
100
101
 
# File 'lib/uploadcare/api/upload/files.rb', line 93

def from_url_status(token:, request_options: {})
  Uploadcare::Result.capture do
    raise ArgumentError, 'token cannot be empty' if token.to_s.strip.empty?

    Uploadcare::Result.unwrap(
      upload.get(path: 'from_url/status/', params: { token: token }, request_options: request_options)
    )
  end
end

#info(file_id:, request_options: {}) ⇒ Uploadcare::Result

Get file info from Upload API (GET /info/).

Parameters:

  • file_id (String) —

    File UUID

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

    Request options

Returns:

See Also:



151
152
153
154
155
156
157
158
159
160
 
# File 'lib/uploadcare/api/upload/files.rb', line 151

def info(file_id:, request_options: {})
  Uploadcare::Result.capture do
    raise ArgumentError, 'file_id cannot be empty' if file_id.to_s.strip.empty?

    Uploadcare::Result.unwrap(
      upload.get(path: 'info/', params: { pub_key: upload.config.public_key, file_id: file_id },
                 request_options: request_options)
    )
  end
end

#multipart_complete(uuid:, request_options: {}) ⇒ Uploadcare::Result

Complete a multipart upload (POST /multipart/complete/).

Parameters:

  • uuid (String) —

    Upload UUID from multipart_start

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

    Request options

Returns:

See Also:



131
132
133
134
135
136
137
138
139
140
141
142
143
 
# File 'lib/uploadcare/api/upload/files.rb', line 131

def multipart_complete(uuid:, request_options: {})
  Uploadcare::Result.capture do
    raise ArgumentError, 'uuid cannot be empty' if uuid.to_s.strip.empty?

    params = {
      'UPLOADCARE_PUB_KEY' => upload.config.public_key,
      'uuid' => uuid
    }
    Uploadcare::Result.unwrap(
      upload.post(path: 'multipart/complete/', params: params, request_options: request_options)
    )
  end
end

#multipart_start(filename:, size:, content_type:, request_options: {}, **options) ⇒ Uploadcare::Result

Start a multipart upload (POST /multipart/start/).

Parameters:

  • filename (String) —

    Original filename

  • size (Integer) —

    File size in bytes

  • content_type (String) —

    MIME type

  • options (Hash) —

    Upload options (:store, :metadata)

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

    Request options

Returns:

See Also:



112
113
114
115
116
117
118
119
120
121
122
123
 
# File 'lib/uploadcare/api/upload/files.rb', line 112

def multipart_start(filename:, size:, content_type:, request_options: {}, **options)
  Uploadcare::Result.capture do
    raise ArgumentError, 'filename cannot be empty' if filename.to_s.strip.empty?
    raise ArgumentError, 'size must be a positive integer' unless size.is_a?(Integer) && size.positive?
    raise ArgumentError, 'content_type cannot be empty' if content_type.to_s.strip.empty?

    params = build_multipart_start_params(filename, size, content_type, options)
    Uploadcare::Result.unwrap(
      upload.post(path: 'multipart/start/', params: params, request_options: request_options)
    )
  end
end