browse-everything 0.1.0

data/lib/browse_everything/driver/box.rb

@@ -0,0 +1,90 @@
+module BrowseEverything
+  module Driver
+    class Box < Base
+      require 'ruby-box'
+
+      def icon
+        'cloud'
+      end
+
+      def validate_config
+        unless config[:client_id]
+          raise BrowseEverything::InitializationError, "Box driver requires a :client_id argument"
+        end
+        unless config[:client_secret]
+          raise BrowseEverything::InitializationError, "Box driver requires a :client_secret argument"
+        end
+      end
+
+      def contents(path='')
+        path.sub!(/^[\/.]+/,'')
+        result = []
+        unless path.empty?
+          result << BrowseEverything::FileEntry.new(
+              Pathname(path).join('..'),
+              '', '..', 0, Time.now, true
+          )
+        end
+        folder = path.empty? ? box_client.root_folder : box_client.folder(path)
+        result += folder.items.collect do |f|
+        BrowseEverything::FileEntry.new(
+            File.join(path,f.name),#id here
+            "#{self.key}:#{File.join(path,f.name)}",#single use link
+            f.name,
+            f.size,
+            f.created_at,
+            f.type == 'folder'
+        )
+        end
+        result
+      end
+
+      def link_for(path)
+        file = box_client.file(path)
+        file.create_shared_link
+        link = file.shared_link
+        extras = link.unshared_at.nil? ? {} : { expires: link.unshared_at }
+        [link.download_url,extras]
+      end
+
+      def details(f)
+      end
+
+      def auth_link
+        callback = connector_response_url(config[:url_options])
+        oauth_client.authorize_url(callback.to_s)
+      end
+
+      def authorized?
+        #false
+        @token.present?
+      end
+
+      def connect(params,data)
+        @token = oauth_client.get_access_token(params[:code]).token
+      end
+
+      private
+      def oauth_client
+        session = RubyBox::Session.new({
+                                           client_id: config[:client_id],
+                                           client_secret: config[:client_secret]
+                                       })
+
+         session
+        #todo error checking here
+      end
+
+      def box_client
+        session = RubyBox::Session.new({
+                                           client_id: config[:client_id],
+                                           client_secret: config[:client_secret],
+                                           access_token: @token
+                                       })
+        RubyBox::Client.new(session)
+      end
+
+    end
+
+  end
+end

data/lib/browse_everything/driver/drop_box.rb

@@ -0,0 +1,74 @@
+require 'dropbox_sdk'
+
+module BrowseEverything
+  module Driver
+    class DropBox < Base
+
+      def icon
+        'dropbox'
+      end
+      
+      def validate_config
+        unless [:app_key,:app_secret].all? { |key| config[key].present? }
+          raise BrowseEverything::InitializationError, "DropBox driver requires :app_key and :app_secret"
+        end
+      end
+
+      def contents(path='')
+        path.sub!(/^[\/.]+/,'')
+        result = []
+        unless path.empty?
+          result << BrowseEverything::FileEntry.new(
+            Pathname(path).join('..'),
+            '', '..', 0, Time.now, true
+          )
+        end
+        result += client.metadata(path)['contents'].collect do |info|
+          path = info['path']
+          BrowseEverything::FileEntry.new(
+            path,
+            [self.key,path].join(':'),
+            File.basename(path),
+            info['size'],
+            Time.parse(info['modified']),
+            info['is_dir']
+          )
+        end
+        result
+      end
+
+      def link_for(path)
+        [client.media(path)['url'], { expires: 4.hours.from_now }]
+      end
+
+      def details(path)
+        contents(path).first
+      end
+
+      def auth_link
+        [ auth_flow.start('drop_box'), @csrf ]
+      end
+
+      def connect(params,data)
+        @csrf = data
+        @token, user, state = auth_flow.finish(params)
+        @token
+      end
+
+      def authorized?
+        token.present?
+      end
+
+      private
+      def auth_flow
+        @csrf ||= {}
+        DropboxOAuth2Flow.new(config[:app_key], config[:app_secret], connector_response_url(config[:url_options]).to_s,@csrf,:token)
+      end
+
+      def client
+        DropboxClient.new(token)
+      end
+    end
+
+  end
+end

data/lib/browse_everything/driver/file_system.rb

@@ -0,0 +1,62 @@
+module BrowseEverything
+  module Driver
+    class FileSystem < Base
+
+      def icon
+        'file'
+      end
+      
+      def validate_config
+        unless config[:home]
+          raise BrowseEverything::InitializationError, "FileSystem driver requires a :home argument"
+        end
+      end
+
+      def contents(path='')
+        relative_path = path.sub(%r{^[/.]+},'')
+        real_path = File.join(config[:home], relative_path)
+        result = []
+        if File.directory?(real_path)
+          if relative_path.present?
+            result << details('..')
+          end
+          result += Dir[File.join(real_path,'*')].collect { |f| details(f) }
+        elsif File.exists?(real_path)
+          result += [details(real_path)]
+        end
+        result.sort do |a,b|
+          if b.container?
+            a.container? ? a.name.downcase <=> b.name.downcase : 1
+          else
+            a.container? ? -1 : a.name.downcase <=> b.name.downcase
+          end
+        end
+      end
+
+      def details(path)
+        if File.exists?(path)
+          info = File::Stat.new(path)
+          BrowseEverything::FileEntry.new(
+            Pathname.new(File.expand_path(path)).relative_path_from(Pathname.new(config[:home])),
+            [self.key,path].join(':'),
+            File.basename(path),
+            info.size,
+            info.mtime,
+            info.directory?
+          )
+        else
+          nil
+        end
+      end
+
+      def link_for(path)
+        "file://#{File.expand_path(path)}"
+      end
+
+      def authorized?
+        true
+      end
+    end
+
+  end
+end

data/lib/browse_everything/driver/google_drive.rb

@@ -0,0 +1,103 @@
+module BrowseEverything
+  module Driver
+    class GoogleDrive < Base
+
+      require 'google/api_client'
+
+      def icon
+        'google-plus-sign'
+      end
+
+      def validate_config
+        unless config[:client_id]
+          raise BrowseEverything::InitializationError, "GoogleDrive driver requires a :client_id argument"
+        end
+        unless config[:client_secret]
+          raise BrowseEverything::InitializationError, "GoogleDrive driver requires a :client_secret argument"
+        end
+      end
+
+      def contents(path='')
+        default_params = { }
+        page_token = nil
+        files = []
+        begin
+          unless path.blank?
+            default_params[:q] = "'#{path}' in parents"
+          end
+          unless page_token.blank?
+            default_params[:pageToken] = page_token
+          end
+          api_result = oauth_client.execute( api_method: drive.files.list, parameters: default_params )
+          response = JSON.parse(api_result.response.body)
+          page_token = response["nextPageToken"]
+          response["items"].select do |file|
+            path.blank? ? (file["parents"].blank? or file["parents"].any?{|p| p["isRoot"] }) : true
+          end.each do |file|
+            files << details(file, path)
+          end
+        end while !page_token.blank?
+        files.compact
+      end
+
+      def details(file, path='')
+        if file["downloadUrl"] or file["mimeType"] == "application/vnd.google-apps.folder"
+          BrowseEverything::FileEntry.new(
+            file["id"],
+            "#{self.key}:#{file["id"]}",
+            file["title"],
+            (file["fileSize"] || 0),
+            Time.parse(file["modifiedDate"]),
+            file["mimeType"] == "application/vnd.google-apps.folder",
+            file["mimeType"] == "application/vnd.google-apps.folder" ?
+                                  "directory" :
+                                  file["mimeType"]
+          )
+        end
+      end
+
+      def link_for(id)
+        api_method = drive.files.get
+        api_result = oauth_client.execute(api_method: api_method, parameters: {fileId: id})
+        download_url = JSON.parse(api_result.response.body)["downloadUrl"]
+        auth_header = {'Authorization' => "Bearer #{oauth_client.authorization.access_token.to_s}"}
+        [download_url,{ auth_header: auth_header, expires: 1.hour.from_now }]
+      end
+
+      def auth_link
+        oauth_client.authorization.authorization_uri.to_s
+      end
+
+      def authorized?
+        @token.present?
+      end
+
+      def connect(params, data)
+        oauth_client.authorization.code = params[:code]
+        @token = oauth_client.authorization.fetch_access_token!
+      end
+
+      def drive
+        oauth_client.discovered_api('drive', 'v2')
+      end
+
+      private
+
+      def oauth_client
+        if @client.nil?
+          callback = connector_response_url(config[:url_options])
+          @client = Google::APIClient.new
+          @client.authorization.client_id = config[:client_id]
+          @client.authorization.client_secret = config[:client_secret]
+          @client.authorization.scope = "https://www.googleapis.com/auth/drive"
+          @client.authorization.redirect_uri = callback
+          @client.authorization.update_token!(@token) if @token.present?
+        end
+        #todo error checking here
+        @client
+      end
+
+    end
+
+  end
+end

data/lib/browse_everything/driver/sky_drive.rb

@@ -0,0 +1,132 @@
+module BrowseEverything
+  module Driver
+    class SkyDrive < Base
+
+      require 'skydrive'
+
+      def icon
+        'windows'
+      end
+
+      def container_items
+        ["folder","album"]
+      end
+
+      def validate_config
+        unless config[:client_id]
+          raise BrowseEverything::InitializationError, "SkyDrive driver requires a :client_id argument"
+        end
+        unless config[:client_secret]
+          raise BrowseEverything::InitializationError, "SkyDrive driver requires a :client_secret argument"
+        end
+      end
+
+      def contents(path='')
+        result = []
+        token_obj = rehydrate_token
+        client = Skydrive::Client.new(token_obj)
+        if (path == '')
+          folder = client.my_skydrive
+        #todo do some loop to get down to my path
+        else
+          folder = client.get("/#{path.gsub("-",".")}/")
+          result += [parent_folder_details(folder)] if folder.parent_id
+        end
+
+        files = folder.files
+        files.items.each do |item|
+          if container_items.include? item.type
+            result += [folder_details(item)]
+          else
+            Rails.logger.warn("\n\nID #{item.id} #{item.type}")
+            result += [file_details(item)]
+          end
+        end
+        result
+      end
+
+      def link_for(path)
+        response = Skydrive::Client.new(rehydrate_token).get("/#{real_id(path)}/")
+        [response.download_link, {expires: 1.hour.from_now}]
+      end
+
+
+
+      def file_details(file)
+          BrowseEverything::FileEntry.new(
+            safe_id(file.id),
+            "#{key}:#{safe_id(file.id)}",
+            file.name,
+            file.size,
+            file.updated_time,
+            false
+          )
+      end
+
+     def parent_folder_details(file)
+          BrowseEverything::FileEntry.new(
+            safe_id(file.parent_id),
+            "#{key}:#{safe_id(file.parent_id)}",
+            "..",
+            0,
+            Time.now,
+            true
+          )
+      end
+
+
+
+
+      def folder_details(folder)
+        BrowseEverything::FileEntry.new(
+            safe_id(folder.id),
+            "#{key}:#{safe_id(folder.id)}",
+            folder.name,
+            0,
+            folder.updated_time,
+            true,
+            'directory'#todo how are we getting mime type
+        )
+      end
+
+
+      def auth_link
+        oauth_client.authorize_url
+      end
+
+      def authorized?
+        return false unless @token.present?
+        return !rehydrate_token.expired?
+      end
+
+      def connect(params,data)
+        Rails.logger.warn "params #{params.inspect}"
+        token = oauth_client.get_access_token(params[:code])
+        @token = {token:token.token, expires_at:token.expires_at}
+      end
+
+      private
+      def oauth_client
+        callback = connector_response_url(config[:url_options])
+        Skydrive::Oauth::Client.new(config[:client_id], config[:client_secret], callback.to_s,"wl.skydrive")
+        #todo error checking here
+      end
+
+      def rehydrate_token
+        return @rehydrate_token if @rehydrate_token
+        token_str = @token[:token]
+        token_expires = @token[:expires_at]
+        Rails.logger.warn "\n\n Rehydrating: #{@token} #{token_str} #{token_expires}"
+        @rehydrate_token = oauth_client.get_access_token_from_hash(token_str,{expires_at:token_expires})
+      end
+
+      def safe_id(id)
+        id.gsub(".","-")
+      end
+
+      def real_id(id)
+        id.gsub("-",".")
+      end
+    end
+  end
+end