ruby-egnyte 0.1.6

data/lib/egnyte.rb

@@ -0,0 +1,25 @@
+require 'uri'
+require 'json'
+require 'oauth2'
+require 'open-uri'
+require 'net/https'
+require 'mime/types'
+require 'net/http/post/multipart'
+
+require "egnyte/version"
+require "egnyte/helper"
+require "egnyte/errors"
+require "egnyte/session"
+require "egnyte/client"
+require "egnyte/item"
+require "egnyte/folder"
+require "egnyte/file"
+require "egnyte/folder_structure"
+require "egnyte/user"
+require "egnyte/group"
+require "egnyte/link"
+require "egnyte/permission"
+
+module Egnyte
+	EGNYTE_DOMAIN = "egnyte.com"
+end

data/lib/egnyte/client.rb

@@ -0,0 +1,11 @@
+module Egnyte
+
+  class Client
+
+    def initialize(session)
+      @session = session
+    end
+
+  end
+  
+end

data/lib/egnyte/errors.rb

@@ -0,0 +1,28 @@
+module Egnyte 
+  class EgnyteError < StandardError
+    def initialize(data)
+      @data = data
+    end
+
+    def [](key)
+      @data[key]
+    end
+  end
+
+  class UnsupportedAuthStrategy < StandardError; end
+  class InvalidParameters < StandardError; end
+  class FileExpected < StandardError; end
+  class FolderExpected < StandardError; end
+  class RecordNotFound < EgnyteError; end
+  class RequestError < EgnyteError; end
+  class BadRequest < EgnyteError; end
+  class NotAuthorized < EgnyteError; end
+  class InsufficientPermissions < EgnyteError; end
+  class DuplicateRecordExists < EgnyteError; end
+  class FileSizeExceedsLimit < EgnyteError; end
+  class ClientIdRequired < EgnyteError; end
+  class DomainRequired < EgnyteError; end
+  class OAuthUsernameRequired < StandardError; end
+  class OAuthPasswordRequired < StandardError; end
+  class MissingAttribute < EgnyteError; end
+end

data/lib/egnyte/file.rb

@@ -0,0 +1,51 @@
+module Egnyte
+
+  class Client
+
+    def file(path)
+      File::find(@session, path)
+    end
+
+  end
+
+  class File < Item
+
+    def download
+      stream.read
+    end
+
+    def download_version(entry_id)
+      stream(:entry_id => entry_id).read
+    end
+
+    # use opts to provide lambdas
+    # to track the streaming download:
+    #
+    # :content_length_proc
+    # :progress_proc
+    def stream( opts={} )
+      file_content_path = "#{fs_path('fs-content')}#{Egnyte::Helper.normalize_path(path)}"
+      file_content_path += "?entry_id=#{opts[:entry_id]}" if opts[:entry_id]
+      @session.streaming_download(file_content_path, opts )
+    end
+
+    def delete
+      @session.delete("#{fs_path}#{path}")
+    end
+
+    def self.find(session, path)
+      path = Egnyte::Helper.normalize_path(path)
+
+      file = File.new({
+        'path' => path
+      }, session)
+
+      parsed_body = session.get("#{file.fs_path}#{path}")
+
+      raise FileExpected if parsed_body['is_folder']
+
+      file.update_data(parsed_body)
+    end
+
+  end
+end

data/lib/egnyte/folder.rb

@@ -0,0 +1,112 @@
+module Egnyte
+
+  class Client
+    def folder(path='Shared')
+      Folder::find(@session, path)
+    end
+
+    def create_folder(path)
+      Folder::create(@session, path)
+    end
+
+    def delete_folder(path)
+      Folder::delete(@session, path)
+    end
+  end
+
+  class Folder < Item
+    def create(path)
+      path = Egnyte::Helper.normalize_path(path)
+      new_folder_path = "#{self.path}/#{path}"
+      Egnyte::Folder.create(@session, new_folder_path)
+    end
+
+    def self.create(session, path)
+      path = Egnyte::Helper.normalize_path(path)
+      session.post("#{Egnyte::Item.fs_path(session)}#{path}", JSON.dump({
+        action: 'add_folder'
+      }))
+
+      Folder.new({
+        'path' => path,
+        'folders' => [],
+        'is_folder' => true,
+        'name' => path.split('/').pop
+      }, session)
+    end
+
+    def delete
+      Egnyte::Folder.delete(@session, path)
+    end
+
+    def self.delete(session, path)      
+      session.delete("#{Egnyte::Item.fs_path(session)}/#{path}")
+    end
+
+    def upload(filename, content)
+      resp = @session.multipart_post("#{fs_path('fs-content')}#{path}/#{filename}", filename, content, false)
+
+      content.rewind # to calculate size, rewind content stream.
+
+      File.new({
+        'is_folder' => false,
+        'entry_id' => resp['ETag'],
+        'checksum' => resp['X-Sha512-Checksum'],
+        'last_modified' => resp['Last-Modified'],
+        'name' => filename,
+        'size' => content.size
+      }, @session)
+    end
+
+    def files
+      create_objects(File, 'files')
+    end
+
+    def folders
+      create_objects(Folder, 'folders')
+    end
+
+    def self.find(session, path)
+      path = Egnyte::Helper.normalize_path(path)
+
+      folder = Folder.new({
+        'path' => path
+      }, session)
+      
+      parsed_body = session.get("#{folder.fs_path}#{path}")
+
+      raise FolderExpected unless parsed_body['is_folder']
+
+      folder.update_data(parsed_body)
+    end
+
+    def permissions(params=nil)
+      Egnyte::Permission.folder_permissions(@session, @data['path'])
+    end
+
+    def inherited_permissions(params=nil)
+      Egnyte::Permission.inherited_permissions(@session, @data['path'])
+    end
+
+    def explicit_permissions(params=nil)
+      Egnyte::Permission.explicit_permissions(@session, @data['path'])
+    end
+
+    def apply_permissions(permission_object)
+      Egnyte::Permission.apply(@session, permission_object, @data['path'])
+    end
+
+    private
+
+    def create_objects(klass, key)
+      return [] unless @data[key]
+      @data[key].map do |data|
+        data = data.merge({
+          'path' => "#{path}/#{data['name']}"
+        })
+        klass.new(data, @session)
+      end
+    end
+
+  end
+end

data/lib/egnyte/folder_structure.rb

@@ -0,0 +1,13 @@
+module Egnyte
+ class FolderStructure
+    def self.traverse_dfs(folder, session, order=:preorder, max_depth=nil, current_depth=1, &block)
+      yield folder if order == :preorder
+      folder.folders = folder.folders.each do |f|
+        f = Egnyte::Folder.find(session, f.path)
+        traverse_dfs(f, session, order, max_depth, current_depth+1, &block) unless !max_depth.nil? and current_depth >= max_depth 
+        f
+      end
+      yield folder if order == :postorder
+    end
+  end
+end

data/lib/egnyte/group.rb

@@ -0,0 +1,185 @@
+module Egnyte
+
+  class Client
+
+    def groups
+      Group::all(@session)
+    end
+
+    def groups_where(params)
+      Group::where(@session, params)
+    end
+
+    def search_groups(search_string)
+      Group::search(@session, search_string)
+    end
+
+    def group(id)
+      Group::find(@session, id)
+    end
+
+    def group_by_name(name)
+      Group::where(@session, {:displayName => name}).first
+    end
+
+    def create_group(params)
+      Group::create(@session, params)
+    end
+
+    def delete_group(id)
+      Group::delete(@session, id)
+    end
+
+  end
+
+  class Group
+
+    @@required_attributes = ['displayName']
+    attr_accessor :displayName, :members
+    attr_reader :id
+
+    def initialize(session, params)
+      @session = session
+      if params.is_a? String
+        @displayName = params
+      elsif params.is_a? Hash
+        params.each do |k,v|
+          if k == "name"
+            @displayName = v
+          else
+            instance_variable_set("@#{k}", v)
+          end
+        end
+      end
+      @members = [] if @members.nil?
+    end
+
+    def self.all(session)
+      self.where(session)
+    end
+
+    def self.create(session, params)
+      group = self.new(session, params)
+      group.save
+    end
+
+    def name
+      @displayName
+    end
+
+    def name=(name)
+      @displayName = name
+    end
+
+    def self.find(session, id)
+      response = session.get("#{self.group_path(session)}/#{id}", return_parsed_response=true)
+      self.new(session, response)
+    end
+
+    def self.find_by_name(session, displayName)
+      self.where(session, {:displayName => displayName}).first
+    end
+
+    def self.where(session, params=nil)
+      startIndex = 1
+      group_count = nil
+      itemsPerPage = 100
+      group_list = []
+      base_url = self.group_path(session)
+      base_url += Egnyte::Helper.params_to_filter_string(params) if params
+      while startIndex == 1 || group_count > startIndex
+        url = base_url
+        url += params.nil? ? '?' : '&'
+        url += "startIndex=#{startIndex}&count=#{itemsPerPage}"
+        parsed_body = session.get(url)
+        parsed_body["resources"].each do |group_hash|
+          group_list << self.new(session, group_hash)
+        end
+        group_count = parsed_body["totalResults"]
+        startIndex += itemsPerPage
+      end
+      group_list
+    end
+
+    def self.search(session, search_string)
+      group_list = self.all(session)
+      result_list = []
+      group_list.each do |user|
+        catch(:found) do 
+          user.instance_variables.each do |ivar|
+            value = user.instance_variable_get(ivar).to_s
+            if value.match(search_string)
+              result_list << user
+              throw :found
+            end
+          end
+        end
+      end
+      result_list
+    end
+
+    def save
+      raise Egnyte::MissingAttribute.new(missing_attributes) unless valid?
+      response = ''
+      if @id.nil? or @id.to_s.empty?
+        response = @session.post(group_path, to_json_for_api_call)
+        @id = response['id']
+      else
+        response = @session.put("#{group_path}/#{@id}", to_json_for_api_call)
+      end
+      Egnyte::Group.new(@session, response)
+    end
+
+    def delete
+      Egnyte::Group.delete(@session, @id)
+    end
+
+    def self.delete(session, id)
+      session.delete("#{self.group_path(session)}/#{id}", return_parsed_response=true)
+    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_hash
+      hash = to_hash_for_api_call
+      hash[:id] = @id
+      hash
+    end
+
+    def to_json
+      to_hash.to_json
+    end
+
+    def to_hash_for_api_call
+      hash = {}
+      hash[:displayName] = @displayName
+      hash[:members] = []
+      @members.each do |group_member|
+        hash[:members] << {"value" => group_member}
+      end
+      hash
+    end
+
+    def to_json_for_api_call
+      to_hash_for_api_call.to_json
+    end
+
+    def group_path
+      Egnyte::Group.group_path(@session)
+    end
+
+    def self.group_path(session)
+      "https://#{session.domain}.#{EGNYTE_DOMAIN}/#{session.api}/v2/groups"
+    end
+
+  end
+end

data/lib/egnyte/helper.rb

@@ -0,0 +1,41 @@
+module Egnyte
+  class Helper
+
+    # removes leading and trailing '/'
+    # from folder and file names.
+    def self.normalize_path(path)
+      path.gsub(/(^\/)|(\/$)/, '')
+    end
+
+    def self.params_to_s(params)
+      str = ''
+      if params
+        str = "?"
+        params.each_with_index do |(k,v),i|
+          v.split('|') if v.instance_of? Array
+          str += "#{k}=#{v}"
+          str += "&" unless i == params.size - 1
+        end
+      end
+      return str
+    end
+
+    def self.params_to_filter_string(params)
+      str = ''
+      if params
+        str = "?"
+        params.each_with_index do |(k,v),i|
+          str += "filter="
+          str += "#{k} eq \"#{v}\""
+          str += "&" unless i == params.size - 1
+        end
+      end
+      return str
+    end
+
+    def self.encode_url(url)
+      URI.encode(url).gsub("[","%5B").gsub("]","%5D")
+    end
+
+  end
+end