files.com 1.1.670 → 1.1.671

data/lib/files.com/models/public_inbox.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Files
+  class PublicInbox
+    attr_reader :options, :attributes
+
+    def initialize(attributes = {}, options = {})
+      @attributes = attributes || {}
+      @options = options || {}
+    end
+
+    # string - Page link and button color
+    def color_left
+      @attributes[:color_left]
+    end
+
+    # string - Top bar link color
+    def color_link
+      @attributes[:color_link]
+    end
+
+    # string - Page link and button color
+    def color_text
+      @attributes[:color_text]
+    end
+
+    # string - Top bar background color
+    def color_top
+      @attributes[:color_top]
+    end
+
+    # string - Top bar text color
+    def color_top_text
+      @attributes[:color_top_text]
+    end
+
+    # string - Inbox title
+    def title
+      @attributes[:title]
+    end
+
+    # string - User description
+    def description
+      @attributes[:description]
+    end
+
+    # string - Text that will be shown to the users on the Inbox.  Use this field to provide custom instructions.
+    def help_text
+      @attributes[:help_text]
+    end
+
+    # string - Unique key for inbox
+    def key
+      @attributes[:key]
+    end
+
+    # boolean - Show this inbox on site login page?
+    def show_on_login_page
+      @attributes[:show_on_login_page]
+    end
+
+    # boolean - Is this inbox password protected?
+    def has_password
+      @attributes[:has_password]
+    end
+
+    # boolean - Does this inbox require registration?
+    def require_registration
+      @attributes[:require_registration]
+    end
+
+    # boolean - Should folder uploads be prevented?
+    def dont_allow_folders_in_uploads
+      @attributes[:dont_allow_folders_in_uploads]
+    end
+
+    # string - Legal text that must be agreed to prior to accessing Inbox.
+    def clickwrap_body
+      @attributes[:clickwrap_body]
+    end
+
+    # FormFieldSet - Custom Form to use
+    def form_field_set
+      @attributes[:form_field_set]
+    end
+
+    # boolean - If true, we will hide the 'Remember Me' box on the Inbox registration page, requiring that the user logout and log back in every time they visit the page.
+    def require_logout
+      @attributes[:require_logout]
+    end
+
+    # Image - Custom logo for Inbox folder
+    def logo
+      @attributes[:logo]
+    end
+
+    # string - URL to open when a public visitor clicks the custom logo
+    def logo_click_href
+      @attributes[:logo_click_href]
+    end
+
+    # Image - Custom logo thumbnail for Inbox folder
+    def thumbnail
+      @attributes[:thumbnail]
+    end
+
+    # Parameters:
+    #   cursor - string - Used for pagination.  When a list request has more records available, cursors are provided in the response headers `X-Files-Cursor-Next` and `X-Files-Cursor-Prev`.  Send one of those cursor value here to resume an existing list from the next available record.  Note: many of our SDKs have iterator methods that will automatically handle cursor-based pagination.
+    #   per_page - int64 - Number of records to show per page.  (Max: 10000, 1,000 or less is recommended).
+    def self.list(params = {}, options = {})
+      raise InvalidParameterError.new("Bad parameter: cursor must be an String") if params[:cursor] and !params[:cursor].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: per_page must be an Integer") if params[:per_page] and !params[:per_page].is_a?(Integer)
+
+      List.new(PublicInbox, params) do
+        Api.send_request("/public_inboxes", :get, params, options)
+      end
+    end
+
+    def self.all(params = {}, options = {})
+      list(params, options)
+    end
+
+    # Parameters:
+    #   key (required) - string - Unique key for inbox
+    #   recipient_code - string - Inbox recipient code
+    def self.get_key(key, params = {}, options = {})
+      params ||= {}
+      params[:key] = key
+      raise InvalidParameterError.new("Bad parameter: key must be an String") if params[:key] and !params[:key].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: recipient_code must be an String") if params[:recipient_code] and !params[:recipient_code].is_a?(String)
+      raise MissingParameterError.new("Parameter missing: key") unless params[:key]
+
+      response, options = Api.send_request("/public_inboxes/key/#{params[:key]}", :get, params, options)
+      PublicInbox.new(response.data, options)
+    end
+
+    def self.create_export(params = {}, options = {})
+      response, options = Api.send_request("/public_inboxes/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
+  end
+end

data/lib/files.com/models/public_key.rb

@@ -283,6 +283,27 @@ module Files
       PublicKey.new(response.data, options)
     end
 
+    # Parameters:
+    #   user_id - int64 - User ID.  Provide a value of `0` to operate the current session's user.
+    #   sort_by - object - If set, sort records by the specified field in either `asc` or `desc` direction. Valid fields are `workspace_id`, `user_id`, `title` or `created_at`.
+    #   filter - object - If set, return records where the specified field is equal to the supplied value. Valid fields are `created_at` and `workspace_id`.
+    #   filter_gt - object - If set, return records where the specified field is greater than the supplied value. Valid fields are `created_at`.
+    #   filter_gteq - object - If set, return records where the specified field is greater than or equal the supplied value. Valid fields are `created_at`.
+    #   filter_lt - object - If set, return records where the specified field is less than the supplied value. Valid fields are `created_at`.
+    #   filter_lteq - object - If set, return records where the specified field is less than or equal the supplied value. Valid fields are `created_at`.
+    def self.create_export(params = {}, options = {})
+      raise InvalidParameterError.new("Bad parameter: user_id must be an Integer") if params[:user_id] and !params[:user_id].is_a?(Integer)
+      raise InvalidParameterError.new("Bad parameter: sort_by must be an Hash") if params[:sort_by] and !params[:sort_by].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter must be an Hash") if params[:filter] and !params[:filter].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_gt must be an Hash") if params[:filter_gt] and !params[:filter_gt].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_gteq must be an Hash") if params[:filter_gteq] and !params[:filter_gteq].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_lt must be an Hash") if params[:filter_lt] and !params[:filter_lt].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_lteq must be an Hash") if params[:filter_lteq] and !params[:filter_lteq].is_a?(Hash)
+
+      response, options = Api.send_request("/public_keys/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
+
     # Parameters:
     #   title (required) - string - Internal reference for key.
     def self.update(id, params = {}, options = {})

data/lib/files.com/models/public_url.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+module Files
+  class PublicUrl
+    attr_reader :options, :attributes
+
+    def initialize(attributes = {}, options = {})
+      @attributes = attributes || {}
+      @options = options || {}
+    end
+
+    # int64 - Response HTTP code
+    def http_code
+      @attributes[:http - code]
+    end
+
+    def http_code=(value)
+      @attributes[:http - code] = value
+    end
+
+    # string - A short string representing which error happened, if any
+    def type
+      @attributes[:type]
+    end
+
+    def type=(value)
+      @attributes[:type] = value
+    end
+
+    # object - Headers to include with the response
+    def http_headers
+      @attributes[:http_headers]
+    end
+
+    def http_headers=(value)
+      @attributes[:http_headers] = value
+    end
+
+    # string - Body of the response, if a folder listing was requested
+    def body
+      @attributes[:body]
+    end
+
+    def body=(value)
+      @attributes[:body] = value
+    end
+
+    # string - Signed URL allowing access to the requested file
+    def download_uri
+      @attributes[:download_uri]
+    end
+
+    def download_uri=(value)
+      @attributes[:download_uri] = value
+    end
+
+    # string - For use with internal services and should also be with headers and socks_ips
+    def internal_download_uri
+      @attributes[:internal_download_uri]
+    end
+
+    def internal_download_uri=(value)
+      @attributes[:internal_download_uri] = value
+    end
+
+    # string - URL where this request should be redirected, if necessary
+    def redirect
+      @attributes[:redirect]
+    end
+
+    def redirect=(value)
+      @attributes[:redirect] = value
+    end
+
+    # string - Used for response content-type
+    def mime_type
+      @attributes[:mime_type]
+    end
+
+    def mime_type=(value)
+      @attributes[:mime_type] = value
+    end
+
+    # int64 - Site id
+    def site_id
+      @attributes[:site_id]
+    end
+
+    def site_id=(value)
+      @attributes[:site_id] = value
+    end
+
+    # int64 - Used for internal bandwidth tracking
+    def remote_server_id
+      @attributes[:remote_server_id]
+    end
+
+    def remote_server_id=(value)
+      @attributes[:remote_server_id] = value
+    end
+
+    # object - Used for internal url management
+    def headers
+      @attributes[:headers]
+    end
+
+    def headers=(value)
+      @attributes[:headers] = value
+    end
+
+    # array(string) - Used for internal url management
+    def socks_ips
+      @attributes[:socks_ips]
+    end
+
+    def socks_ips=(value)
+      @attributes[:socks_ips] = value
+    end
+
+    # string - The actual path of the file or folder being accessed. Used for caching.
+    def true_path
+      @attributes[:true_path]
+    end
+
+    def true_path=(value)
+      @attributes[:true_path] = value
+    end
+
+    # int64 - Indicates how long the response should be cached, in seconds.
+    def cache_for_seconds
+      @attributes[:cache_for_seconds]
+    end
+
+    def cache_for_seconds=(value)
+      @attributes[:cache_for_seconds] = value
+    end
+
+    # string - Hostname used to request the publicly shared resource.
+    def hostname
+      @attributes[:hostname]
+    end
+
+    def hostname=(value)
+      @attributes[:hostname] = value
+    end
+
+    # string - Path of the resource being requested.
+    def path
+      @attributes[:path]
+    end
+
+    def path=(value)
+      @attributes[:path] = value
+    end
+
+    def save
+      new_obj = PublicUrl.create(path, @attributes, @options)
+      @attributes = new_obj.attributes
+      true
+    end
+
+    # Parameters:
+    #   hostname (required) - string - Hostname used to request the publicly shared resource.
+    #   path (required) - string - Path of the resource being requested.
+    def self.create(path, params = {}, options = {})
+      params ||= {}
+      params[:path] = path
+      raise InvalidParameterError.new("Bad parameter: hostname must be an String") if params[:hostname] and !params[:hostname].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: path must be an String") if params[:path] and !params[:path].is_a?(String)
+      raise MissingParameterError.new("Parameter missing: hostname") unless params[:hostname]
+      raise MissingParameterError.new("Parameter missing: path") unless params[:path]
+
+      response, options = Api.send_request("/public_urls", :post, params, options)
+      PublicUrl.new(response.data, options)
+    end
+  end
+end

data/lib/files.com/models/regional_migration.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Files
+  class RegionalMigration
+    attr_reader :options, :attributes
+
+    def initialize(attributes = {}, options = {})
+      @attributes = attributes || {}
+      @options = options || {}
+    end
+  end
+end

data/lib/files.com/models/release.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Files
+  class Release
+    attr_reader :options, :attributes
+
+    def initialize(attributes = {}, options = {})
+      @attributes = attributes || {}
+      @options = options || {}
+    end
+
+    # string - Native release version
+    def version
+      @attributes[:version]
+    end
+
+    def version=(value)
+      @attributes[:version] = value
+    end
+
+    # string - Native release description
+    def description
+      @attributes[:description]
+    end
+
+    def description=(value)
+      @attributes[:description] = value
+    end
+
+    # array(object) - A list of native release packages
+    def native_release_packages
+      @attributes[:native_release_packages]
+    end
+
+    def native_release_packages=(value)
+      @attributes[:native_release_packages] = value
+    end
+
+    # string - Native release title
+    def title
+      @attributes[:title]
+    end
+
+    def title=(value)
+      @attributes[:title] = value
+    end
+
+    # string - Native release product
+    def product
+      @attributes[:product]
+    end
+
+    def product=(value)
+      @attributes[:product] = value
+    end
+
+    # int64
+    def version_major
+      @attributes[:version_major]
+    end
+
+    def version_major=(value)
+      @attributes[:version_major] = value
+    end
+
+    # int64
+    def version_minor
+      @attributes[:version_minor]
+    end
+
+    def version_minor=(value)
+      @attributes[:version_minor] = value
+    end
+
+    # int64
+    def version_patch
+      @attributes[:version_patch]
+    end
+
+    def version_patch=(value)
+      @attributes[:version_patch] = value
+    end
+
+    # int64
+    def version_build
+      @attributes[:version_build]
+    end
+
+    def version_build=(value)
+      @attributes[:version_build] = value
+    end
+
+    # string
+    def oem
+      @attributes[:oem]
+    end
+
+    def oem=(value)
+      @attributes[:oem] = value
+    end
+
+    def save
+      if @attributes[:id]
+        raise NotImplementedError.new("The Release object doesn't support updates.")
+      else
+        new_obj = Release.create(@attributes, @options)
+      end
+
+      @attributes = new_obj.attributes
+      true
+    end
+
+    # Parameters:
+    #   product - string
+    #   platform - string
+    #   architecture - string
+    #   ext - string
+    def self.get_latest(params = {}, options = {})
+      raise InvalidParameterError.new("Bad parameter: product must be an String") if params[:product] and !params[:product].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: platform must be an String") if params[:platform] and !params[:platform].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: architecture must be an String") if params[:architecture] and !params[:architecture].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: ext must be an String") if params[:ext] and !params[:ext].is_a?(String)
+
+      response, options = Api.send_request("/releases/latest", :get, params, options)
+      Release.new(response.data, options)
+    end
+
+    # Parameters:
+    #   title - string
+    #   description - string
+    #   version_major - int64
+    #   version_minor - int64
+    #   version_patch - int64
+    #   version_build - int64
+    #   oem - string
+    #   product - string
+    #   native_release_packages - array(object)
+    def self.create(params = {}, options = {})
+      raise InvalidParameterError.new("Bad parameter: title must be an String") if params[:title] and !params[:title].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: description must be an String") if params[:description] and !params[:description].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: version_major must be an Integer") if params[:version_major] and !params[:version_major].is_a?(Integer)
+      raise InvalidParameterError.new("Bad parameter: version_minor must be an Integer") if params[:version_minor] and !params[:version_minor].is_a?(Integer)
+      raise InvalidParameterError.new("Bad parameter: version_patch must be an Integer") if params[:version_patch] and !params[:version_patch].is_a?(Integer)
+      raise InvalidParameterError.new("Bad parameter: version_build must be an Integer") if params[:version_build] and !params[:version_build].is_a?(Integer)
+      raise InvalidParameterError.new("Bad parameter: oem must be an String") if params[:oem] and !params[:oem].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: product must be an String") if params[:product] and !params[:product].is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: native_release_packages must be an Array") if params[:native_release_packages] and !params[:native_release_packages].is_a?(Array)
+
+      response, options = Api.send_request("/releases", :post, params, options)
+      Release.new(response.data, options)
+    end
+  end
+end

data/lib/files.com/models/release_package.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Files
+  class ReleasePackage
+    attr_reader :options, :attributes
+
+    def initialize(attributes = {}, options = {})
+      @attributes = attributes || {}
+      @options = options || {}
+    end
+
+    # string - Link to the package
+    def package_link
+      @attributes[:package_link]
+    end
+
+    # string - Release platform
+    def platform
+      @attributes[:platform]
+    end
+
+    # string - Release architecture
+    def architecture
+      @attributes[:architecture]
+    end
+
+    # string - Package file extension
+    def extension
+      @attributes[:extension]
+    end
+
+    # string - SHA256 hash of the package
+    def sha256
+      @attributes[:sha256]
+    end
+  end
+end

data/lib/files.com/models/remote_bandwidth_snapshot.rb

@@ -61,5 +61,24 @@ module Files
     def self.all(params = {}, options = {})
       list(params, options)
     end
+
+    # Parameters:
+    #   sort_by - object - If set, sort records by the specified field in either `asc` or `desc` direction. Valid fields are `logged_at`.
+    #   filter - object - If set, return records where the specified field is equal to the supplied value. Valid fields are `logged_at`.
+    #   filter_gt - object - If set, return records where the specified field is greater than the supplied value. Valid fields are `logged_at`.
+    #   filter_gteq - object - If set, return records where the specified field is greater than or equal the supplied value. Valid fields are `logged_at`.
+    #   filter_lt - object - If set, return records where the specified field is less than the supplied value. Valid fields are `logged_at`.
+    #   filter_lteq - object - If set, return records where the specified field is less than or equal the supplied value. Valid fields are `logged_at`.
+    def self.create_export(params = {}, options = {})
+      raise InvalidParameterError.new("Bad parameter: sort_by must be an Hash") if params[:sort_by] and !params[:sort_by].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter must be an Hash") if params[:filter] and !params[:filter].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_gt must be an Hash") if params[:filter_gt] and !params[:filter_gt].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_gteq must be an Hash") if params[:filter_gteq] and !params[:filter_gteq].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_lt must be an Hash") if params[:filter_lt] and !params[:filter_lt].is_a?(Hash)
+      raise InvalidParameterError.new("Bad parameter: filter_lteq must be an Hash") if params[:filter_lteq] and !params[:filter_lteq].is_a?(Hash)
+
+      response, options = Api.send_request("/remote_bandwidth_snapshots/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
   end
 end

data/lib/files.com/models/remote_mount_backend.rb

@@ -317,6 +317,15 @@ module Files
       nil
     end
 
+    # Parameters:
+    #   filter - object - If set, return records where the specified field is equal to the supplied value. Valid fields are `remote_server_mount_id`.
+    def self.create_export(params = {}, options = {})
+      raise InvalidParameterError.new("Bad parameter: filter must be an Hash") if params[:filter] and !params[:filter].is_a?(Hash)
+
+      response, options = Api.send_request("/remote_mount_backends/create_export", :post, params, options)
+      Export.new(response.data, options)
+    end
+
     # Parameters:
     #   enabled - boolean - True if this backend is enabled.
     #   fall - int64 - Number of consecutive failures before considering the backend unhealthy.