ribose 0.3.1 → 0.5.0

data/lib/ribose/actions/create.rb

@@ -23,7 +23,7 @@ module Ribose
       end
 
       def request_body(attributes)
-        custom_option.merge(resource_key.to_sym => validate(attributes))
+        custom_option.merge(resource_key.to_sym => validate(**attributes))
       end
 
       def create_resource

data/lib/ribose/client.rb

@@ -1,25 +1,35 @@
 module Ribose
   class Client
-    attr_reader :api_token, :user_email
+    attr_accessor :api_email, :api_token, :access_token, :uid, :client_id
 
     def initialize(options = {})
-      @api_token = options.fetch(:token, configuration.api_token).to_s
-      @user_email = options.fetch(:email, configuration.user_email).to_s
+      initialize_client_details(options)
     end
 
     # Initiate a ribose client
     #
-    # This interface takes email and password and then it will
-    # do all the underlying work to find out the authentication
-    # token and retrun a ribose client.
+    # This interface takes email, password, api_email and api_token
+    # Then it will do all the underlying work to find out client id and uid
+    # Finally it will return a ribose client.
     #
     # @param :email [String] The email for your Ribose account
     # @param :password [String] The password for your account
+    # @param :api_email [String] The email for your API account
+    # @param :api_token [String] The authentication token for your API account
     # @return [Ribose::Client] A new client with your details
     #
     def self.from_login(email:, password:)
-      session = Session.create(username: email, password: password)
-      new(email: email, token: session["authentication_token"])
+      session = Ribose::Session.create(
+        username: email, password: password,
+      )
+
+      new(
+        api_email: email,
+        uid: session.uid,
+        client_id: session.client,
+        api_token: session["access-token"],
+        access_token: session["access-token"],
+      )
     end
 
     private
@@ -27,5 +37,13 @@ module Ribose
     def configuration
       Ribose.configuration
     end
+
+    def initialize_client_details(options)
+      @uid = options.fetch(:uid, nil)
+      @client_id = options.fetch(:client_id, nil)
+      @access_token = options.fetch(:access_token, nil)
+      @api_email = options.fetch(:api_email, configuration.api_email)
+      @api_token = options.fetch(:api_token, configuration.api_token)
+    end
   end
 end

data/lib/ribose/configuration.rb

@@ -2,10 +2,12 @@ require "ribose/response/raise_error"
 
 module Ribose
   class Configuration
-    attr_accessor :api_host, :api_token, :user_email, :debug_mode
+    attr_accessor :api_email, :verify_ssl, :client, :api_host,
+                  :api_token, :user_email, :user_password, :debug_mode
 
     def initialize
       @debug_mode = false
+      @verify_ssl = true
       @api_host ||= "www.ribose.com"
     end
 
@@ -13,13 +15,28 @@ module Ribose
       debug_mode == true
     end
 
-    def web_url
-      ["https", api_host].join("://")
+    def verify_ssl?
+      !!verify_ssl
     end
+
+    def api_email
+      @user_email || @api_email
+    end
+
+    def client
+      @client ||= Ribose::Client.from_login(
+        email: api_email, password: user_password,
+      )
+    end
+
     def add_default_middleware(builder)
       builder.use(Ribose::Response::RaiseError)
       builder.response(:logger, nil, bodies: true) if debug_mode?
       builder.adapter(Faraday.default_adapter)
     end
+
+    def ssl_verification_mode
+      verify_ssl? ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+    end
   end
 end

data/lib/ribose/connection.rb

@@ -1,6 +1,7 @@
 module Ribose
   class Connection < Ribose::Base
     include Ribose::Actions::All
+    include Ribose::Actions::Delete
 
     # List Connections
     #
@@ -26,6 +27,20 @@ module Ribose
         suggested_connection
     end
 
+    # Disconnect
+    #
+    # Disconnect connection / contact with the provided
+    # connection id. This will return nothing for successful
+    # request, but if disconnect fails then it will raise an
+    # Error for the client.
+    #
+    # @params resource_id [Integer] Connection Id
+    # @return nil
+    #
+    def self.disconnect(resource_id, options = {})
+      delete(resource_id, options)
+    end
+
     private
 
     def resource

data/lib/ribose/event.rb

@@ -12,7 +12,7 @@ module Ribose
     # @return [Sawyer::Resource] Calendar Events
     #
     def self.all(calendar_id, options = {})
-      Ribose::Calendar.fetch(calendar_id, options)
+      Ribose::Calendar.fetch(calendar_id, **options)
     end
 
     # Fetch a calendar event

data/lib/ribose/file_uploader.rb

@@ -1,4 +1,6 @@
+require "json"
 require "faraday"
+require "ostruct"
 
 module Ribose
   class FileUploader
@@ -29,7 +31,7 @@ module Ribose
     # @param attributes [Hash] Attributes as a Hash
     # @return [Sawyer::Resource] File upload response.
     def self.upload(space_id, file:, **attributes)
-      new(space_id, attributes.merge(file: file)).create
+      new(space_id, **attributes.merge(file: file)).create
     end
 
     private
@@ -49,7 +51,10 @@ module Ribose
 
     def notify_ribose_file_upload_endpoint(response, key)
       if response.status.to_i == 200
-        Ribose::Request.post(space_file_path, file_attributes.merge(key: key))
+        attributes = notifiable_attributes(file_attributes, key)
+
+        content = Request.post(space_file_path, attributes)
+        content.is_a?(Sawyer::Resource) ? content : parse_to_ribose_os(content)
       end
     end
 
@@ -67,7 +72,16 @@ module Ribose
 
     def content_type_form_file
       require "mime/types"
-      MIME::Types.type_for(file.path).first.content_type
+      mime = MIME::Types.type_for(file.path).first
+      mime ? mime.content_type : "application/octet-stream"
+    end
+
+    def parse_to_ribose_os(content)
+      JSON.parse(content, object_class: Ribose::OpenStruct)
+    end
+
+    def notifiable_attributes(attributes, key)
+      attributes.merge(key: key)
     end
 
     def file_attributes
@@ -90,4 +104,8 @@ module Ribose
       end
     end
   end
+
+  class OpenStruct < ::OpenStruct
+    alias :read_attribute_for_serialization :send
+  end
 end

data/lib/ribose/file_version.rb

@@ -1,7 +1,13 @@
+require "ribose/version_uploader"
+
 module Ribose
   class FileVersion < Ribose::Base
     include Ribose::Actions::Fetch
 
+    def download
+      download_file || raise(Ribose::BadRequest)
+    end
+
     # Fetch file version
     #
     # @params :space_id [UUID] The space Id
@@ -10,23 +16,52 @@ module Ribose
     # @returns [Sawyer::Resource] The file version
     #
     def self.fetch(space_id:, file_id:, version_id:, **options)
-      new(
-        file_id: file_id,
-        space_id: space_id,
-        resource_id: version_id,
-        **options,
-      ).fetch
+      options = options.merge(
+        file_id: file_id, space_id: space_id, resource_id: version_id,
+      )
+
+      new(options).fetch
+    end
+
+    # Download file version
+    #
+    # @param space_id [UUID] The space Id
+    # @param file_id [Integer] The file Id
+    # @param version_id [Hash] The file version Id
+    # @param options [Hash] Options as key and value pair
+    #
+    def self.download(space_id, file_id, version_id:, **options)
+      options = options.merge(
+        file_id: file_id,space_id: space_id, resource_id: version_id,
+      )
+
+      new(options).download
+    end
+
+    # Create a new file version
+    #
+    # @params space_id [UUID] The space UUID
+    # @params file_id [Integer] The space file ID
+    # @params file [File] The new version for file
+    # @params attributes [Hash] Other file attributes
+    # @return [Sawyer::Resource] Newly updated version
+    #
+    def self.create(space_id, file_id, file:, **attributes)
+      attributes = attributes.merge(file: file)
+      upload = VersionUploader.upload(space_id, file_id, **attributes)
+      upload[:attachment]
     end
 
     private
 
-    attr_reader :file_id, :space_id
+    attr_reader :output, :file_id, :space_id
 
     def resource
       nil
     end
 
     def extract_local_attributes
+      @output = attributes.delete(:output)
       @file_id = attributes.delete(:file_id)
       @space_id = attributes.delete(:space_id)
     end
@@ -38,5 +73,21 @@ module Ribose
     def files_path
       ["spaces", space_id, "file", "files"].join("/")
     end
+
+    def download_file
+      data = Ribose::Request.get(
+        resource_path, parse: false, headers: { accept: "text/html" }
+      )
+
+      if data.headers["status"].match?(/^30[12]/)
+        fetch_and_write_to_file(data)
+      end
+    end
+
+    def fetch_and_write_to_file(data)
+      File.open(output || "download", "w") do |file|
+        file << data.agent.call(:get, data.headers["location"]).data
+      end
+    end
   end
 end

data/lib/ribose/request.rb

@@ -1,5 +1,7 @@
 module Ribose
   class Request
+    DEFAULT_CONTENT_TYPE = "application/json"
+
     # Initialize a Request
     #
     # @param http_method [Symbol] HTTP verb as sysmbol
@@ -7,7 +9,7 @@ module Ribose
     # @param data [Hash] Attributes / Options as a Hash
     # @return [Ribose::Request]
     #
-    def initialize(http_method, endpoint, **data)
+    def initialize(http_method, endpoint, data = {})
       @data = data
       @endpoint = endpoint
       @http_method = http_method
@@ -20,8 +22,13 @@ module Ribose
     # @return [Sawyer::Resource]
     #
     def request(options = {})
+      parsable = extract_config_option(:parse) != false
       options[:query] = extract_config_option(:query) || {}
-      agent.call(http_method, api_endpoint, data, options).data
+
+      response = agent.call(http_method, api_endpoint, data, options)
+      update_client_headers(response.headers)
+
+      parsable == true ? response.data : response
     end
 
     # Make a HTTP GET Request
@@ -78,13 +85,16 @@ module Ribose
     end
 
     def find_suitable_client
-      client = extract_config_option(:client) || Ribose::Client.new
-      client.is_a?(Ribose::Client) ? client: raise(Ribose::Unauthorized)
+      client = extract_config_option(:client) || Ribose.configuration.client
+      client.is_a?(Ribose::Client) ? client : raise(Ribose::Unauthorized)
     end
 
     def require_auth_headers?
-      auth_header = extract_config_option(:auth_header)
-      auth_header == false ? false : true
+      extract_config_option(:auth_header) != false
+    end
+
+    def custom_content_headers
+      extract_config_option(:headers) || {}
     end
 
     def api_endpoint
@@ -95,9 +105,16 @@ module Ribose
     end
 
     def sawyer_options
+      faraday_options = { builder: custom_rack_builder }
+      unless Ribose.configuration.verify_ssl?
+        faraday_options.merge!(ssl: Faraday::SSLOptions.new(
+          false, nil, nil, OpenSSL::SSL::VERIFY_NONE
+        ))
+      end
+
       {
+        faraday: Faraday.new(faraday_options),
         links_parser: Sawyer::LinkParsers::Simple.new,
-        faraday: Faraday.new(builder: custom_rack_builder),
       }
     end
 
@@ -109,14 +126,33 @@ module Ribose
 
     def agent
       @agent ||= Sawyer::Agent.new(ribose_host, sawyer_options) do |http|
-        http.headers[:accept] = "application/json"
-        http.headers[:content_type] = "application/json"
+        set_content_type(http.headers)
+        set_devise_specific_headers(http.headers)
 
         if require_auth_headers?
           http.headers["X-Indigo-Token"] = client.api_token
-          http.headers["X-Indigo-Email"] = client.user_email
+          http.headers["X-Indigo-Email"] = client.api_email
         end
       end
     end
+
+    def update_client_headers(headers)
+      client.uid = headers["uid"]
+      client.client_id = headers["client"]
+      client.access_token = headers["access-token"]
+    end
+
+    def set_content_type(headers)
+      headers[:content_type] = DEFAULT_CONTENT_TYPE
+      headers[:accept] = custom_content_headers.fetch(
+        :accept, DEFAULT_CONTENT_TYPE
+      )
+    end
+
+    def set_devise_specific_headers(headers)
+      headers["uid"] = client.uid
+      headers["client"] = client.client_id
+      headers["access-token"] = client.access_token
+    end
   end
 end

data/lib/ribose/response/raise_error.rb

@@ -3,8 +3,6 @@ require "ribose/error"
 module Ribose
   module Response
     class RaiseError < Faraday::Response::Middleware
-      private
-
       def on_complete(response)
         if error = Ribose::Error.from_response(response)
           raise error

data/lib/ribose/session.rb

@@ -1,6 +1,6 @@
-require "json"
-require "mechanize"
-require "ribose/config"
+require "uri"
+require "ostruct"
+require "net/http"
 
 module Ribose
   class Session
@@ -10,7 +10,7 @@ module Ribose
     end
 
     def create
-      JSON.parse(authenticate_user)
+      authenticate_user
     rescue NoMethodError, JSON::ParserError
       raise Ribose::Unauthorized
     end
@@ -24,25 +24,49 @@ module Ribose
     attr_reader :username, :password
 
     def authenticate_user
-      page = agent.get(ribose_url_for("login"))
-      find_and_submit_the_user_login_form(page)
-      agent.get(ribose_url_for(["settings", "general", "info"])).body
+      response = submit_user_login_request
+
+      case response
+      when Net::HTTPSuccess
+        build_session_data(response.each_header.to_h)
+      when Net::HTTPForbidden
+        raise(Ribose::Unauthorized)
+      end
+    end
+
+    def submit_user_login_request
+      Net::HTTP.start(login_uri.host, login_uri.port, http_options) do |http|
+        request = Net::HTTP::Post.new(login_uri)
+
+        request["Content-Type"] = "application/json"
+        request.set_form_data(username: username, password: password)
+
+        http.request(request)
+      end
     end
 
-    def find_and_submit_the_user_login_form(page)
-      login_form = page.form_with(id: "new_user")
-      login_form.field_with(id: "loginEmail").value = username
-      login_form.field_with(id: "loginPassword").value = password
+    def api_host
+      api_host = Ribose.configuration.api_host
 
-      login_form.submit
+      unless api_host[/\Ahttp:\/\//] || api_host[/\Ahttps:\/\//]
+        "https://#{api_host}"
+      end
     end
 
-    def agent
-      @agent ||= Mechanize.new
+    def login_uri
+      @login_uri ||= URI.parse([api_host, "api/v2/auth/sign_in"].join("/"))
     end
 
-    def ribose_url_for(*endpoint)
-      [Ribose.configuration.web_url, *endpoint].join("/")
+    def http_options
+      { use_ssl: true, verify_ssl: Ribose.configuration.ssl_verification_mode }
     end
+
+    def build_session_data(headers)
+      SessionData.new(headers.slice("uid", "expiry", "client", "access-token"))
+    end
+  end
+
+  class SessionData < ::OpenStruct
+    alias :read_attribute_for_serialization :send
   end
 end

data/lib/ribose/space.rb

@@ -15,6 +15,10 @@ module Ribose
       Ribose::Request.post("spaces/#{space_uuid}/freeze", options)
     end
 
+    def self.delete(space_uuid, confirmation:, **options)
+      remove(space_uuid, options.merge(password_confirmation: confirmation))
+    end
+
     private
 
     attr_reader :space

data/lib/ribose/space_file.rb

@@ -34,6 +34,21 @@ module Ribose
       new(space_id: space_id, resource_id: file_id, **options).fetch
     end
 
+    # Download a space file
+    #
+    # @param space_id [UUID] The Space UUID
+    # @param file_id [Integer] The File Id
+    # @param options [Hash] Options as key and value pair.
+    #
+    #   Two important keys are :version_id, and :output and
+    #   if these are provided then it will use those otherwise
+    #   it will do additional request to retirve those details
+    #
+    def self.download(space_id, file_id, options = {})
+      options[:version_id] ||= fetch(space_id, file_id).current_version_id
+      Ribose::FileVersion.download(space_id, file_id, **options)
+    end
+
     # Create a new file upload
     #
     # @param space_id [String] The Space UUID
@@ -42,7 +57,7 @@ module Ribose
     # @return [Sawyer::Resource] The file upload response.
     #
     def self.create(space_id, file:, **attributes)
-      upload = FileUploader.upload(space_id, attributes.merge(file: file))
+      upload = FileUploader.upload(space_id, **attributes.merge(file: file))
       upload[:attachment]
     end
 

data/lib/ribose/user.rb

@@ -8,8 +8,12 @@ module Ribose
 
     def activate
       Ribose::Request.post(
-        "signup.user",
-        custom_option.merge(user: attributes, auth_header: false),
+        "api/v2/auth",
+        custom_option.merge(
+          user: attributes,
+          auth_header: false,
+          client: Ribose::Client.new
+        ),
       )
     end
 
@@ -17,12 +21,12 @@ module Ribose
     #
     # @param email [String] The registering user email
     # @param password [String] A strong password for login
-    # @param otp [String] The OTP received via the email
+    # @param edata [String] The OTP received via the email
     # @param attributes [Hash] The other attributes as Hash.
     # @return [Sawyer::Resoruce] The newly activated user
     #
-    def self.activate(email:, password:, otp:, **attributes)
-      new(attributes.merge(email: email, password: password, otp: otp)).activate
+    def self.activate(email:, password:, edata:, **attributes)
+      new(attributes.merge(email: email, password: password, edata: edata)).activate
     end
 
     private

data/lib/ribose/version.rb

@@ -1,3 +1,3 @@
 module Ribose
-  VERSION = "0.3.1".freeze
+  VERSION = "0.5.0".freeze
 end

data/lib/ribose/version_uploader.rb

@@ -0,0 +1,27 @@
+require "ribose/file_uploader"
+
+module Ribose
+  class VersionUploader < Ribose::FileUploader
+    def initialize(space_id, file_id, file:, **attributes)
+      @file_id = file_id
+      super(space_id, file: file, **attributes)
+    end
+
+    def self.upload(space_id, file_id, file:, **attributes)
+      new(space_id, file_id, **attributes.merge(file: file)).create
+    end
+
+    private
+
+    attr_reader :file_id
+
+    def notifiable_attributes(attributes, key)
+      attributes[:file_info_version] = attributes.delete(:file_info)
+      attributes.merge(key: key)
+    end
+
+    def space_file_path
+      ["spaces", space_id, "file", "files", file_id, "versions"].join("/")
+    end
+  end
+end

data/ribose.gemspec

@@ -21,13 +21,12 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = Gem::Requirement.new(">= 2.1.9")
 
   spec.add_dependency "id_pack", "~> 1.0.1"
-  spec.add_dependency "mechanize", "~> 2.7.5"
   spec.add_dependency "mime-types", "~> 3.1"
   spec.add_dependency "sawyer", "~> 0.8.1"
 
-  spec.add_development_dependency "bundler", "~> 1.14"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "pry", "~> 0.10.4"
-  spec.add_development_dependency "webmock", "~> 2.0"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "webmock", "~> 3.0"
 end