ruby-egnyte 0.1.6

data/lib/egnyte/item.rb

@@ -0,0 +1,43 @@
+module Egnyte
+  class Item
+
+    attr_accessor :session
+
+    def initialize(data, session)
+      @data = data
+      @session = session
+    end
+
+    def method_missing(method, *args, &block)
+      @data[method.to_s]
+    end
+
+    def update_data(data)
+      @data = @data.update(data)
+      self
+    end
+
+    # mode can be either fs, or fs-content.
+    def fs_path(mode='fs')
+      Egnyte::Item.fs_path(@session, mode)
+    end
+
+    def self.fs_path(session, mode='fs')
+      "https://#{session.domain}.#{EGNYTE_DOMAIN}/#{session.api}/v1/#{mode}/"
+    end
+
+    def move_or_copy(destination_path, action)
+      item_path = "#{fs_path}#{Egnyte::Helper.normalize_path(path)}"
+      @session.post(item_path, { action: action, destination: destination_path }.to_json, return_parsed_response=true)
+    end
+
+    def move(destination_path)
+      move_or_copy(destination_path, 'move')
+    end
+
+    def copy(destination_path)
+      move_or_copy(destination_path, 'copy')
+    end
+
+  end
+end

data/lib/egnyte/link.rb

@@ -0,0 +1,109 @@
+module Egnyte
+
+  class Client
+
+    def links
+      Link::all(@session)
+    end
+
+    def links_where(params)
+      Link::where(@session, params)
+    end
+
+    def link(id)
+      Link::find(@session, id)
+    end
+
+    def create_link(params)
+      Link::create(@session, params)
+    end
+
+    def delete_link(id)
+      Link::delete(@session, id)
+    end
+
+  end
+
+  class Link
+
+    @@required_attributes = ['path', 'type', 'accessibility']
+    attr_accessor :path, :type, :accessibility, :send_email, :recipients, :messages, :copy_me, :notify, :link_to_current, :expiry_date, :expiry_clicks, :add_filename, :creation_date
+    attr_reader :id
+
+    def initialize(session, params)
+      @session = session
+      params.each do |k,v|
+        instance_variable_set("@#{k}", v)
+      end
+    end
+
+    def self.all(session)
+      self.where(session)
+    end
+
+    def self.create(session, params)
+      link = self.new(session, params)
+      link.save
+    end
+
+    def self.find(session, id)
+      response = session.get("#{self.link_path(session)}/#{id}", return_parsed_response=true)
+      self.new(session, response)
+    end
+
+    def self.where(session, params=nil)
+      url = self.link_path(session)
+      url += Egnyte::Helper.params_to_s(params) if params
+      parsed_body = session.get(url)
+      parsed_body["ids"].nil? ? [] : parsed_body["ids"]
+    end
+
+    def save
+      raise Egnyte::MissingAttribute.new(missing_attributes) unless valid?
+      response = @session.post(link_path, to_json, return_parsed_response=true)
+      link = Egnyte::Link.find(@session, response['links'].first['id'])
+      link.instance_variables.each do |ivar|
+        instance_variable_set(ivar, link.instance_variable_get(ivar))
+      end
+      self
+    end
+
+    def delete
+      Egnyte::Link.delete(@session, @id)
+    end
+
+    def self.delete(session, id)
+      session.delete("#{self.link_path(session)}/#{id}", return_parsed_response=false)
+    end
+
+    def valid?
+      return missing_attributes.size < 1
+    end
+
+    def missing_attributes
+      missing = @@required_attributes.collect do |param|
+        param unless instance_variable_get("@#{param}")
+      end
+      missing.compact
+    end
+
+    def to_json
+      hash = {}
+      instance_variables.each do |iv|
+        next if [:@session, :@client].include? iv
+        next if instance_variable_get(iv) == nil
+        hash[iv.to_s[1..-1]] = instance_variable_get(iv)
+      end
+      hash.to_json
+    end
+
+    def link_path
+      Egnyte::Link.link_path(@session)
+    end
+
+    def self.link_path(session)
+      "https://#{session.domain}.#{EGNYTE_DOMAIN}/#{session.api}/v1/links"
+    end
+
+  end
+end

data/lib/egnyte/permission.rb

@@ -0,0 +1,181 @@
+module Egnyte
+
+  class Permission
+
+    attr_accessor :data
+    ### Representative Structure of @data
+    # {
+    #   'users': {
+    #     'jsmith': 'Full',
+    #     'jdoe': 'Editor'
+    #   },
+    #   'groups': {
+    #     'employees': 'Full',
+    #     'partners': 'Viewer'
+    #   }
+    # }
+    @@valid_perm_levels = ["None", "Viewer", "Editor", "Full", "Owner"]
+
+    def initialize(permissions_hash={})
+      raise Egnyte::InvalidParameters unless (permissions_hash.empty? or permissions_hash['users'] or permissions_hash['groups'])
+      @data = empty_permissions_hash
+      merge!(permissions_hash)
+    end
+
+    def merge(new_perm_set)
+      old_perm_set = @data.dup
+      new_perm_set = new_perm_set.data if new_perm_set.class == Egnyte::Permission
+      raise Egnyte::InvalidParameters unless new_perm_set.class == Hash
+      new_perm_set.each do |type, perms_hash|
+        perms_hash.each do |username, permission|
+          permission.capitalize!
+          old_perm_set[type][username] = permission if ["None", "Viewer", "Editor", "Full", "Owner"].include? permission
+        end
+      end
+      old_perm_set
+    end
+
+    def merge!(new_perm_set)
+      @data = merge(new_perm_set)
+    end
+
+    def empty_permissions_hash
+      Egnyte::Permission.empty_permissions_hash
+    end
+
+    def self.empty_permissions_hash
+      { 'users' => {}, 'groups' => {} }
+    end
+
+    def self.build_from_api_listing(json_listing)
+      perm = empty_permissions_hash
+      json_listing.each do |type, data|
+        data.each do |item|
+          perm[type][item["subject"]] = item["permission"]
+        end
+      end
+      Egnyte::Permission.new(perm)
+    end
+
+    def self.folder_permissions(session, path, params=nil)
+      path = Egnyte::Helper.normalize_path(path)
+      path += Egnyte::Helper.params_to_filter_string(params) if params
+      response = session.get("#{self.permission_path(session)}/#{path}")
+      self.build_from_api_listing(response)
+    end
+
+    def self.inherited_permissions(session, path, params=nil)
+      path = Egnyte::Helper.normalize_path(path)
+      path = path.split('/')[0..-2].join('/')
+      self.folder_permissions(session, path, params)
+    end
+
+    def self.explicit_permissions(session, path, params=nil)
+      inherited = self.inherited_permissions(session, path, params).data
+      permissions = self.folder_permissions(session, path, params).data
+      explicit = self.empty_permissions_hash
+
+      #filter out permissions that exist in the parent folder's permissions
+      permissions.each do |type, perm|
+        perm.each do |k,v|
+          explicit[type][k] = v unless inherited[type][k] == v
+        end
+      end
+      self.new(explicit)
+    end
+
+    def self.permission_path(session)
+      "https://#{session.domain}.#{EGNYTE_DOMAIN}/#{session.api}/v1/perms/folder"
+    end
+
+    def valid?
+      return @data['users'].class == Hash && @data['groups'].class == Hash
+    end
+
+    def has_data?
+      return @data['users'].size > 0 || @data['groups'].size > 0
+    end
+
+    def empty?
+      return !has_data?
+    end
+
+    def to_hash
+      @data
+    end
+
+    def to_json
+      to_hash.to_json
+    end
+
+    def to_s
+      to_json
+    end
+
+    def self.transfrom_by_perm_level(permission_object)
+      perm_type_hash = {
+        'users' => { "None" => [], "Viewer" => [], "Editor" => [], "Full"   => [], "Owner"  => [] },
+        'groups' => { "None" => [], "Viewer" => [], "Editor" => [], "Full"   => [], "Owner"  => [] }
+      }
+      permission_object.data.each do |type, perm|
+        perm.each do |k,v|
+          perm_type_hash[type][v] << k
+        end
+      end
+      perm_type_hash
+    end
+
+    def self.apply(session, permission_object, target_path)
+      if permission_object.valid? and permission_object.has_data?
+        permissions_set = transfrom_by_perm_level(permission_object)
+        ["None", "Viewer", "Editor", "Full", "Owner"].each do |level|
+          tmp_hash = {}
+          tmp_hash['users']  = permissions_set['users'][level] unless permissions_set['users'].nil?
+          tmp_hash['groups'] = permissions_set['groups'][level] unless permissions_set['groups'].nil?
+          tmp_hash['permission'] = level
+          unless tmp_hash['users'].nil? and tmp_hash['groups'].nil?
+            unless tmp_hash['users'].empty? and tmp_hash['groups'].empty?
+              session.post("#{self.permission_path(session)}/#{target_path}", tmp_hash.to_json, false)
+            end
+          end
+        end
+        "Permissions set on #{target_path}: #{permission_object.to_hash}"
+      end
+    end
+
+    def ==(other_perm_object)
+      @data == other_perm_object.data
+    end
+
+    def diff(other_perm_object)
+      only_originial = Egnyte::Permission.new
+      common_perms   = Egnyte::Permission.new
+      only_other     = Egnyte::Permission.new
+      discrepancies  = {'original' => Egnyte::Permission.new, 'other' => Egnyte::Permission.new}
+
+      # find whether permission is only in the self's set or is common between self and other
+      @data.each do |level, perm_hash|
+        perm_hash.each do |item, permission|
+          if other_perm_object.data[level][item].nil?
+            only_originial.data[level][item] = permission
+          elsif other_perm_object.data[level][item] != permission
+            discrepancies['original'].data[level][item] = permission
+            discrepancies['other'].data[level][item] = other_perm_object.data[level][item]
+          end
+          common_perms.data[level][item]   = permission if other_perm_object.data[level][item] == permission
+        end
+      end
+
+      # find whether permission is in the other_perm_object
+      other_perm_object.data.each do |level, perm_hash|
+        perm_hash.each do |item, permission|
+            only_other.data[level][item] = permission if @data[level][item].nil? || @data[level][item] != permission
+        end
+      end
+
+      [only_originial, common_perms, only_other, discrepancies]
+    end
+
+  end
+
+end

data/lib/egnyte/session.rb

@@ -0,0 +1,197 @@
+require 'os'
+
+module Egnyte
+  class Session
+
+    attr_accessor :domain, :api, :username
+    attr_reader :access_token
+
+    def initialize(opts, strategy=:implicit, backoff=0.5)
+
+      @strategy = strategy # the authentication strategy to use.
+      raise Egnyte::UnsupportedAuthStrategy unless [:implicit, :password].include? @strategy
+
+      @backoff = backoff # only two requests are allowed a second by Egnyte.
+      @api = 'pubapi' # currently we only support the public API.
+
+      @username = opts[:username]
+
+      # the domain of the egnyte account to interact with.
+      raise Egnyte::DomainRequired unless @domain = opts[:domain]
+
+      @client = OAuth2::Client.new(opts[:key], nil, {
+        :site => "https://#{@domain}.#{EGNYTE_DOMAIN}",
+        :authorize_url => "/puboauth/token",
+        :token_url => "/puboauth/token"
+      })
+
+      if @strategy == :implicit
+        @access_token = OAuth2::AccessToken.new(@client, opts[:access_token]) if opts[:access_token]
+      elsif @strategy == :password
+        if opts[:access_token]
+          @access_token = OAuth2::AccessToken.new(@client, opts[:access_token])
+        else
+          raise Egnyte::OAuthUsernameRequired unless @username
+          raise Egnyte::OAuthPasswordRequired unless opts[:password]
+          if true #OS.windows?
+            body = {
+              :client_id => opts[:key],
+              :username => @username,
+              :password => opts[:password],
+              :grant_type => 'password'
+            }.map {|k,v| "#{k}=#{v}"}.join("&")
+            url = "https://#{@domain}.#{EGNYTE_DOMAIN}/puboauth/token"
+            response = login_post(url, body, return_parsed_response=true)
+            @access_token = OAuth2::AccessToken.new(@client, response["access_token"])
+          else
+            @access_token = @client.password.get_token(@username, opts[:password])
+          end
+        end
+        @username = info["username"] unless @username
+      end
+      
+    end
+
+    def info
+      information
+    end
+
+    def information
+      get("https://#{@domain}.#{EGNYTE_DOMAIN}/#{@api}/v1/userinfo", return_parsed_response=true)
+    end
+
+    def authorize_url(redirect_uri)
+      @client.implicit.authorize_url(:redirect_uri => redirect_uri)
+    end
+
+    def create_access_token(token)
+      @access_token = OAuth2::AccessToken.new(@client, token) if @strategy == :implicit
+    end
+
+    def get(url, return_parsed_response=true)
+      uri = URI.parse(Egnyte::Helper.encode_url(url))
+      request = Net::HTTP::Get.new( uri.request_uri )
+      resp = request( uri, request, return_parsed_response )
+    end
+
+    def delete(url, return_parsed_response=true)
+      uri = URI.parse(Egnyte::Helper.encode_url(url))
+      request = Net::HTTP::Delete.new( uri.request_uri )
+      resp = request( uri, request, return_parsed_response )
+    end
+
+    def post(url, body, return_parsed_response=true)
+      uri = URI.parse(Egnyte::Helper.encode_url(url))
+      request = Net::HTTP::Post.new(uri.request_uri)
+      request.body = body
+      request.content_type = "application/json"
+      resp = request(uri, request, return_parsed_response)
+    end
+
+    def login_post(url, body, return_parsed_response=true)
+      uri = URI.parse(Egnyte::Helper.encode_url(url))
+      request = Net::HTTP::Post.new(uri.request_uri)
+      request.body = body
+      request.content_type = "application/x-www-form-urlencoded"
+      resp = request(uri, request, return_parsed_response)
+    end
+
+    def patch(url, body, return_parsed_response=true)
+      uri = URI.parse(Egnyte::Helper.encode_url(url))
+      request = Net::HTTP::Patch.new(uri.request_uri)
+      request.body = body
+      request.content_type = "application/json"
+      resp = request(uri, request, return_parsed_response)
+    end
+
+    def put(url, body, return_parsed_response=true)
+      uri = URI.parse(Egnyte::Helper.encode_url(url))
+      request = Net::HTTP::Put.new(uri.request_uri)
+      request.body = body
+      request.content_type = "application/json"
+      resp = request(uri, request, return_parsed_response)
+    end
+
+    def multipart_post(url, filename, data, return_parsed_response=true)
+      uri = URI.parse(Egnyte::Helper.encode_url(url))
+
+      request = Net::HTTP::Post.new(uri.request_uri)
+      request.body = data.read
+      request.content_type = 'application/binary'
+
+      resp = request(uri, request, return_parsed_response)
+    end
+
+    # perform a streaming download of a file
+    # rather than in-memory.
+    def streaming_download(url, opts)
+      uri = URI.parse(Egnyte::Helper.encode_url(url))
+
+      params = {
+        :content_length_proc => opts[:content_length_proc],
+        :progress_proc => opts[:progress_proc],
+        'Authorization' => "Bearer #{@access_token.token}"
+      }
+
+      open(uri, params)
+    end
+
+    private
+
+    def request(uri, request, return_parsed_response=true)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      if OS.windows? # Use provided certificate on Windows where gem doesn't have access to a cert store.
+        http.cert_store = OpenSSL::X509::Store.new
+        http.cert_store.set_default_paths
+        http.cert_store.add_file("#{::File.dirname(__FILE__)}/../../includes/cacert.pem")
+      end
+      #http.set_debug_output($stdout)
+
+      unless request.content_type == "application/x-www-form-urlencoded"
+        request.add_field('Authorization', "Bearer #{@access_token.token}")
+      end
+
+      response = http.request(request)
+
+      # Egnyte throttles requests to
+      # two requests per second by default.
+      sleep(@backoff)
+
+      # puts "#{response.code.to_i} ||||| #{response.body}"
+
+
+      return_value = return_parsed_response ? parse_response_body(response.body) : response
+      parse_response_code(response.code.to_i, return_value)
+
+      return_value
+    end
+
+    def parse_response_code(status, response)
+      case status
+      when 400
+        raise BadRequest.new(response)
+      when 401
+        raise NotAuthorized.new(response)
+      when 403
+        raise InsufficientPermissions.new(response)
+      when 404
+        raise RecordNotFound.new(response)
+      when 405
+        raise DuplicateRecordExists.new(response)
+      when 413
+        raise FileSizeExceedsLimit.new(response)
+      end
+
+      # Handle all other request errors.
+      raise RequestError.new(response) if status >= 400
+    end
+
+    def parse_response_body(body)
+      JSON.parse(body)
+    rescue
+      {}
+    end
+
+  end
+end