files.com 1.0.92

data/docs/user_cipher_use.md

@@ -0,0 +1,41 @@
+# UserCipherUse
+
+## Example UserCipherUse Object
+
+```
+{
+  "id": 1,
+  "protocol_cipher": "TLSv1.2; ECDHE-RSA-AES256-GCM-SHA384",
+  "created_at": "2000-01-01T01:00:00Z",
+  "interface": "restapi",
+  "updated_at": "2000-01-01T01:00:00Z",
+  "user_id": 1
+}
+```
+
+* `id` (int64): UserCipherUse ID
+* `protocol_cipher` (string): The protocol and cipher employed
+* `created_at` (date-time): The earliest recorded use of this combination of interface and protocol and cipher (for this user)
+* `interface` (string): The interface accessed
+* `updated_at` (date-time): The most recent use of this combination of interface and protocol and cipher (for this user)
+* `user_id` (int64): ID of the user who performed this access
+
+
+---
+
+## List User Cipher Uses
+
+```
+Files::UserCipherUse.list(
+  user_id: 1, 
+  page: 1, 
+  per_page: 1
+)
+```
+
+### Parameters
+
+* `user_id` (int64): User ID.  Provide a value of `0` to operate the current session's user.
+* `page` (int64): Current page number.
+* `per_page` (int64): Number of records to show per page.  (Max: 10,000, 1,000 or less is recommended).
+* `action` (string): Deprecated: If set to `count` returns a count of matching records rather than the records themselves.

data/docs/user_request.md

@@ -0,0 +1,93 @@
+# UserRequest
+
+## Example UserRequest Object
+
+```
+{
+  "name": "John Doe",
+  "email": "john.doe@files.com",
+  "details": "Changed Departments"
+}
+```
+
+* `name` (string): User's full name
+* `email` (email): User email address
+* `details` (string): Details of the user's request
+
+
+---
+
+## List User Requests
+
+```
+Files::UserRequest.list(
+  page: 1, 
+  per_page: 1
+)
+```
+
+### Parameters
+
+* `page` (int64): Current page number.
+* `per_page` (int64): Number of records to show per page.  (Max: 10,000, 1,000 or less is recommended).
+* `action` (string): Deprecated: If set to `count` returns a count of matching records rather than the records themselves.
+
+
+---
+
+## Show User Request
+
+```
+Files::UserRequest.find(id)
+```
+
+### Parameters
+
+* `id` (int64): Required - User Request ID.
+
+
+---
+
+## Create User Request
+
+```
+Files::UserRequest.create(
+  name: "name", 
+  email: "email", 
+  details: "details"
+)
+```
+
+### Parameters
+
+* `name` (string): Required - Name of user requested
+* `email` (string): Required - Email of user requested
+* `details` (string): Required - Details of the user request
+
+
+---
+
+## Delete User Request
+
+```
+Files::UserRequest.delete(id)
+```
+
+### Parameters
+
+* `id` (int64): Required - User Request ID.
+
+
+---
+
+## Delete User Request
+
+```
+user_request = Files::UserRequest.list_for(path).first
+
+user_request.delete
+```
+
+### Parameters
+
+* `id` (int64): Required - User Request ID.

data/files.com.gemspec

@@ -0,0 +1,22 @@
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+
+Gem::Specification.new do |s|
+  s.name        = "files.com"
+  s.version     = File.open(File.expand_path('_VERSION', __dir__)).read
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = [ "files.com" ]
+  s.email       = [ "support@files.com" ]
+  s.homepage    = "https://www.files.com"
+  s.summary     = "Files.com Ruby client."
+  s.description = "The Files.com Ruby client."
+  s.license     = "MIT"
+  s.required_ruby_version = ">= 2.5"
+  s.add_dependency 'addressable', ">= 2.7.0"
+  s.add_dependency 'concurrent-ruby', ">= 1.1.3"
+  s.add_dependency 'faraday', ">= 1.0.1"
+  s.add_dependency 'net-http-persistent'
+
+  s.files         = `find *`.split("\n").uniq.sort.reject(&:empty?)
+  s.executables   = [ "files", "files-console" ]
+  s.require_paths = [ "lib" ]
+end

data/lib/files.com.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "cgi"
+require "faraday"
+require "json"
+require "logger"
+require "openssl"
+require "rbconfig"
+require "securerandom"
+require "set"
+require "socket"
+require "uri"
+require "addressable/uri"
+require "concurrent/promise"
+
+$LOAD_PATH.push __dir__
+
+require "files.com/version"
+
+require "files.com/sizable_io"
+require "files.com/api"
+require "files.com/api_client"
+require "files.com/errors"
+require "files.com/response"
+require "files.com/system_profiler"
+require "files.com/util"
+require "files.com/list"
+
+require "files.com/models/account_line_item"
+require "files.com/models/action"
+require "files.com/models/api_key"
+require "files.com/models/app"
+require "files.com/models/as2_key"
+require "files.com/models/auto"
+require "files.com/models/automation"
+require "files.com/models/behavior"
+require "files.com/models/bundle"
+require "files.com/models/bundle_download"
+require "files.com/models/clickwrap"
+require "files.com/models/dns_record"
+require "files.com/models/errors"
+require "files.com/models/file"
+require "files.com/models/file_action"
+require "files.com/models/file_comment"
+require "files.com/models/file_comment_reaction"
+require "files.com/models/file_part_upload"
+require "files.com/models/folder"
+require "files.com/models/group"
+require "files.com/models/group_user"
+require "files.com/models/history"
+require "files.com/models/history_export"
+require "files.com/models/image"
+require "files.com/models/invoice"
+require "files.com/models/invoice_line_item"
+require "files.com/models/ip_address"
+require "files.com/models/lock"
+require "files.com/models/message"
+require "files.com/models/message_comment"
+require "files.com/models/message_comment_reaction"
+require "files.com/models/message_reaction"
+require "files.com/models/notification"
+require "files.com/models/payment"
+require "files.com/models/payment_line_item"
+require "files.com/models/permission"
+require "files.com/models/preview"
+require "files.com/models/project"
+require "files.com/models/public_ip_address"
+require "files.com/models/public_key"
+require "files.com/models/remote_server"
+require "files.com/models/request"
+require "files.com/models/session"
+require "files.com/models/site"
+require "files.com/models/sso_strategy"
+require "files.com/models/status"
+require "files.com/models/style"
+require "files.com/models/usage_daily_snapshot"
+require "files.com/models/usage_snapshot"
+require "files.com/models/user"
+require "files.com/models/user_cipher_use"
+require "files.com/models/user_request"
+
+require "files.com/models/dir"
+require "files.com/models/file_utils"
+
+module Files
+  @api_key = nil
+  @app_info = nil
+  @base_url = "https://app.files.com"
+  @log_level = nil
+  @logger = nil
+  @proxy = nil
+  @session_id = nil
+
+  @max_network_retries = 3
+  @max_network_retry_delay = 2
+  @initial_network_retry_delay = 0.5
+
+  @open_timeout = 30
+  @read_timeout = 80
+
+  class << self
+    attr_accessor :api_key, :base_url, :initial_network_retry_delay, :max_network_retry_delay, :open_timeout, :read_timeout, :proxy, :session_id
+  end
+
+  # map to the same values as the standard library's logger
+  LEVEL_DEBUG = Logger::DEBUG
+  LEVEL_ERROR = Logger::ERROR
+  LEVEL_INFO = Logger::INFO
+
+  # When set prompts the library to log some extra information to $stdout and
+  # $stderr about what it's doing. For example, it'll produce information about
+  # requests, responses, and errors that are received. Valid log levels are
+  # `debug` and `info`, with `debug` being a little more verbose in places.
+  #
+  # Use of this configuration is only useful when `.logger` is _not_ set. When
+  # it is, the decision what levels to print is entirely deferred to the logger.
+  def self.log_level
+    @log_level
+  end
+
+  def self.log_level=(val)
+    # Backwards compatibility for values that we briefly allowed
+    if val == "debug"
+      val = LEVEL_DEBUG
+    elsif val == "info"
+      val = LEVEL_INFO
+    end
+
+    if !val.nil? && ![ LEVEL_DEBUG, LEVEL_ERROR, LEVEL_INFO ].include?(val)
+      raise ArgumentError,
+            "log_level should only be set to `nil`, `debug` or `info`"
+    end
+    @log_level = val
+  end
+
+  # Sets a logger to which logging output will be sent. The logger should
+  # support the same interface as the `Logger` class that's part of Ruby's
+  # standard library (hint, anything in `Rails.logger` will likely be
+  # suitable).
+  #
+  # If `.logger` is set, the value of `.log_level` is ignored. The decision on
+  # what levels to print is entirely deferred to the logger.
+  def self.logger
+    @logger
+  end
+
+  def self.logger=(val)
+    @logger = val
+  end
+
+  def self.max_network_retries
+    @max_network_retries
+  end
+
+  def self.max_network_retries=(val)
+    @max_network_retries = val.to_i
+  end
+
+  def self.session=(session)
+    session.save unless session.id
+    self.session_id = session.id
+  end
+
+  # Sets some basic information about the running application that's sent along
+  # with API requests.
+  #
+  # Takes a name and optional  partner program ID, plugin URL, and version.
+  def self.set_app_info(name, partner_id: nil, url: nil, version: nil)
+    @app_info = {
+      name: name,
+      partner_id: partner_id,
+      url: url,
+      version: version,
+    }
+  end
+
+  def self.app_info
+    @app_info
+  end
+
+  def self.app_info=(info)
+    @app_info = info
+  end
+end

data/lib/files.com/api.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Files
+  class Api
+    def self.send_request(path, verb, params, options)
+      warn_on_options_in_params(params)
+
+      options[:client] ||= ApiClient.active_client
+
+      headers = options.clone
+      api_key = headers.delete(:api_key)
+      client = headers.delete(:client)
+      session_id = headers.delete(:session_id)
+      if session = headers.delete(:session)
+        session.save unless session.id
+        session_id = session.id
+      end
+
+      resp, options[:api_key], options[:session_id] = client.execute_request(
+        verb, path, api_key: api_key, headers: headers, params: params, session_id: session_id
+      )
+
+      # Hash#select returns an array before 1.9
+      options_to_persist = {}
+      options.each do |k, v|
+        options_to_persist[k] = v if Util::OPTS.include?(k)
+      end
+
+      [ resp, options_to_persist ]
+    end
+
+    def self.warn_on_options_in_params(params)
+      Util::OPTS.each do |opt|
+        warn("WARNING: #{opt} should be in the options hash, not the params hash.  You may need to create a second hash that goes after params.)") if params.key?(opt)
+      end
+    end
+  end
+end

data/lib/files.com/api_client.rb

@@ -0,0 +1,340 @@
+# frozen_string_literal: true
+
+module Files
+  class ApiClient
+    attr_accessor :conn
+
+    def initialize(conn = nil)
+      self.conn = conn || self.class.default_conn
+      @system_profiler = SystemProfiler.new
+      @last_request_metrics = nil
+    end
+
+    def self.active_client
+      Thread.current[:files_api_client] || default_client
+    end
+
+    # net_http_persistent does not support streaming downloads with faraday when directly downloading from S3
+    # falling back to net_http.
+    def self.download_client
+      Thread.current[:files_api_client_download_client] ||= ApiClient.new(download_conn)
+    end
+
+    def self.download_conn
+      Thread.current[:files_api_client_download_conn] ||= build_default_conn(force_net_http: true)
+    end
+
+    def self.default_client
+      Thread.current[:files_api_client_default_client] ||= ApiClient.new(default_conn)
+    end
+
+    def self.default_conn
+      Thread.current[:files_api_client_default_conn] ||= build_default_conn
+    end
+
+    def self.build_default_conn(force_net_http: false)
+      conn = Faraday.new do |builder|
+        builder.use Faraday::Request::Multipart
+        builder.use Faraday::Request::UrlEncoded
+        builder.use Faraday::Response::RaiseError
+
+        if Gem.win_platform? || RUBY_PLATFORM == "java" || force_net_http
+          builder.adapter :net_http
+        else
+          builder.adapter :net_http_persistent
+        end
+      end
+
+      conn.proxy = Files.proxy if Files.proxy
+      conn.ssl.verify = true
+
+      conn
+    end
+
+    def self.should_retry?(error, num_retries)
+      return false if num_retries >= Files.max_network_retries
+      return true if error.is_a?(Faraday::TimeoutError)
+      return true if error.is_a?(Faraday::ConnectionFailed)
+
+      false
+    end
+
+    def self.sleep_time(num_retries)
+      sleep_seconds = [
+        Files.initial_network_retry_delay * (2**(num_retries - 1)),
+        Files.max_network_retry_delay
+      ].min
+      sleep_seconds *= (0.5 * (1 + rand))
+      [ Files.initial_network_retry_delay, sleep_seconds ].max
+    end
+
+    def request
+      @last_response = nil
+      old_files_api_client = Thread.current[:files_api_client]
+      Thread.current[:files_api_client] = self
+
+      begin
+        res = yield
+        [ res, @last_response ]
+      ensure
+        Thread.current[:files_api_client] = old_files_api_client
+      end
+    end
+
+    def execute_request(method, path, base_url: nil, api_key: nil, session_id: nil, headers: {}, params: {})
+      base_url ||= Files.base_url
+      session_id ||= Files.session_id
+
+      if session_id and session_id != ""
+        check_session_id!(session_id)
+      elsif path !~ /^\/sessions/ # TODO: automate this to refer to any unauthenticated endpoint
+        api_key ||= Files.api_key
+        check_api_key!(api_key)
+      end
+
+      body = nil
+      query_params = nil
+      case method.to_s.downcase.to_sym
+      when :get, :head, :delete
+        query_params = params
+      else
+        body = params
+      end
+
+      headers = request_headers(api_key, session_id, method).update(headers)
+      url = api_url(path, base_url)
+
+      context = RequestLogContext.new
+      context.api_key      = api_key
+      context.body         = body
+      context.method       = method
+      context.path         = path
+      context.query_params = query_params if query_params
+      context.session_id   = session_id
+
+      http_resp = execute_request_with_rescues(base_url, context) do
+        conn.run_request(method, url, body, headers) do |req|
+          req.options.open_timeout = Files.open_timeout
+          req.options.timeout = Files.read_timeout
+          req.params = query_params unless query_params.nil?
+        end
+      end
+
+      begin
+        resp = Response.from_faraday_response(http_resp)
+      rescue JSON::ParserError
+        raise general_api_error(http_resp.status, http_resp.body)
+      end
+
+      @last_response = resp
+      [ resp, api_key, session_id ]
+    end
+
+    def remote_request(method, url, headers = {}, body = nil)
+      context = RequestLogContext.new
+      context.method       = method
+      context.path         = url
+
+      execute_request_with_rescues(Files.base_url, context, true) do
+        conn.run_request(method, url, body, headers) do |req|
+          req.options.open_timeout = Files.open_timeout
+          req.options.timeout = Files.read_timeout
+          yield(req) if block_given?
+        end
+      end
+    end
+
+    def stream_download(uri, io)
+      if conn.adapter == Faraday::Adapter::NetHttp
+        uri = URI(uri)
+        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+          request = Net::HTTP::Get.new uri
+          http.request request do |response|
+            io.fulfill_content_length(response.content_length) if io.respond_to?(:fulfill_content_length)
+            response.read_body do |chunk|
+              io << chunk.encode!
+            end
+          end
+        end
+      else
+        response = remote_request(:get, uri)
+        io.fulfill_content_length(response.content_length) if io.respond_to?(:fulfill_content_length)
+        io.write(response.body)
+      end
+    end
+
+    def cursor
+      @last_response.http_headers["x-files-cursor"]
+    end
+
+    private def api_url(url = "", base_url = nil)
+      (base_url || Files.base_url) + "/api/rest/v1" + url
+    end
+
+    private def check_api_key!(api_key)
+      unless api_key
+        raise AuthenticationError, "No Files.com API key provided. " \
+          'Set your API key using "Files.api_key = <API-KEY>". ' \
+          "You can generate API keys from the Files.com's web interface. "
+      end
+
+      return unless api_key =~ /\s/
+
+      raise AuthenticationError, "Your API key is invalid (it contains whitespace)"
+    end
+
+    private def check_session_id!(session_id)
+      return unless session_id =~ /\s/
+
+      raise AuthenticationError, "The provided Session ID is invalid (it contains whitespace)"
+    end
+
+    def execute_request_with_rescues(base_url, context, skip_body_logging = false)
+      num_retries = 0
+      begin
+        request_start = Time.now
+        log_request(context, num_retries, skip_body_logging)
+        resp = yield
+        log_response(context, request_start, resp.status, resp.body, skip_body_logging)
+      rescue StandardError => e
+        error_context = context
+
+        if e.respond_to?(:response) && e.response
+          error_context = context
+          log_response(error_context, request_start,
+                       e.response[:status], e.response[:body], skip_body_logging
+          )
+        else
+          log_response_error(error_context, request_start, e)
+        end
+
+        if self.class.should_retry?(e, num_retries)
+          num_retries += 1
+          sleep self.class.sleep_time(num_retries)
+          retry
+        end
+
+        case e
+        when Faraday::ClientError
+          if e.response
+            handle_error_response(e.response, error_context)
+          else
+            handle_network_error(e, error_context, num_retries, base_url)
+          end
+
+        else
+          raise
+        end
+      end
+
+      resp
+    end
+
+    private def general_api_error(status, body)
+      APIError.new("Unexpected response object from API: #{body.inspect} (HTTP response code was #{status})", http_status: status, http_body: body)
+    end
+
+    private def format_app_info(info)
+      str = info[:name]
+      str = "#{str}/#{info[:version]}" unless info[:version].nil?
+      str = "#{str} (#{info[:url]})" unless info[:url].nil?
+      str
+    end
+
+    private def handle_error_response(http_resp, context)
+      begin
+        resp = Response.from_faraday_hash(http_resp)
+        error_data = resp.data[:error] || resp.data[:errors]
+        error_data = error_data.first if error_data.is_a?(Array)
+        error_data = { message: error_data } if error_data.is_a?(String)
+
+        raise Error, "Unknown error" unless error_data
+      rescue JSON::ParserError, Error
+        raise general_api_error(http_resp[:status], http_resp[:body])
+      end
+
+      error = specific_api_error(resp, error_data, context)
+
+      error.response = resp
+      raise(error)
+    end
+
+    private def specific_api_error(resp, error_data, _context)
+      Util.log_error("API error", status: resp.http_status, error_message: error_data[:message])
+
+      opts = {
+        http_body: resp.http_body,
+        http_headers: resp.http_headers,
+        http_status: resp.http_status,
+        json_body: resp.data,
+        code: error_data[:code] || resp.http_status,
+      }
+
+      case resp.http_status
+      when 400, 404
+        InvalidRequestError.new(error_data[:message], opts)
+      when 401
+        AuthenticationError.new(error_data[:message], opts)
+      when 403
+        PermissionError.new(error_data[:message], opts)
+      when 429
+        RateLimitError.new(error_data[:message], opts)
+      else
+        APIError.new(error_data[:message], opts)
+      end
+    end
+
+    private def handle_network_error(error, context, num_retries, base_url = nil)
+      base_url ||= Files.base_url
+
+      Util.log_error("Network error", error_message: error.message, request_id: context.request_id)
+      message = "Could not connect to Files.com at URL #{base_url}. Please check your internet connection and try again. If this problem persists, you should check Files.com's service status at https://status.files.com, or contact your primary account representative."
+      message += " Request was retried #{num_retries} times." if num_retries > 0
+      message += "\n\n(Network error: #{error.message})"
+
+      raise APIConnectionError, message
+    end
+
+    private def request_headers(api_key, session_id, _method)
+      user_agent = "Files.com Ruby SDK v#{Files::VERSION}"
+      user_agent += " " + format_app_info(Files.app_info) unless Files.app_info.nil?
+
+      headers = {
+        "User-Agent" => user_agent,
+        "Content-Type" => "application/x-www-form-urlencoded",
+      }
+      headers["X-FilesAPI-Key"] = api_key if api_key
+      headers["X-FilesAPI-Auth"] = session_id if session_id
+
+      user_agent = @system_profiler.user_agent
+      begin
+        headers.update("X-Files-Client-User-Agent" => JSON.generate(user_agent))
+      rescue StandardError => e
+        headers.update(
+          "X-Files-Client-Raw-User-Agent" => user_agent.inspect,
+          error: "#{e} (#{e.class})"
+        )
+      end
+
+      headers
+    end
+
+    private def log_request(context, num_retries, no_body = false)
+      Util.log_info("Request", method: context.method, num_retries: num_retries, path: context.path)
+      Util.log_debug("Request details", body: context.body, query_params: context.query_params) unless no_body
+    end
+
+    private def log_response(context, request_start, status, body, no_body = false)
+      Util.log_info("Response", elapsed: Time.now - request_start, method: context.method, path: context.path, status: status)
+      Util.log_debug("Response details", body: body) unless no_body
+    end
+
+    private def log_response_error(context, request_start, error)
+      Util.log_error("Error", elapsed: Time.now - request_start, error_message: error.message, method: context.method, path: context.path)
+    end
+
+    class RequestLogContext
+      attr_accessor :body, :api_key, :method, :path, :query_params, :session_id
+    end
+  end
+end