rox 0.1.0

data/README

@@ -0,0 +1 @@
+Try it out at: http://www.ox.io

data/examples/workspace.rb

@@ -0,0 +1,11 @@
+require 'rox'
+
+USER = "..."
+PASSWORD = "..."
+HOST = "https://ox.io"
+
+ROX::Client.new(:host => HOST).login(USER, PASSWORD) do
+  |client|
+  # ...
+  
+end

data/lib/rox.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__)+'/rox/dependencies'
+require File.dirname(__FILE__)+'/rox/rox'
+require File.dirname(__FILE__)+'/rox/webconversation'
+require File.dirname(__FILE__)+'/rox/client'
+require File.dirname(__FILE__)+'/rox/response'
+require File.dirname(__FILE__)+'/rox/exception'
+require File.dirname(__FILE__)+'/rox/config_tree'
+require File.dirname(__FILE__)+'/rox/folders'
+require File.dirname(__FILE__)+'/rox/simple_module'
+

data/lib/rox/client.rb

@@ -0,0 +1,78 @@
+module ROX
+  
+  class Client
+    
+    attr_accessor :webconversation
+    attr_accessor :session
+    
+    def initialize(options = nil)
+      if options
+          host = options[:host] 
+          raise "Please specify an option 'host'" unless host
+          @webconversation = ROX::WebConversation.new(host)
+      end
+    end
+    
+    def login(username, password)
+      response = @webconversation.get("/ajax/login", :action => :login, :name => username, :password => password)
+      response = ROX::Response.new(JSON.parse(response))
+      raise OXException.new(response) if response.error?
+      @session = response["session"]
+      
+      if block_given?
+        begin
+          return yield(self)
+        ensure
+          logout
+        end
+      end
+      
+    end
+    
+    def logout
+      response = @webconversation.get("/ajax/login", :action => :logout, :session => session)
+      if(response and response != "")
+        response = ROX::Response.new(JSON.parse(response))
+        raise OXException.new(response) if response.error?
+      end
+      @session = nil
+    end
+    
+    def logged_in?
+      !@session.nil?
+    end
+    
+    def get(path, parameters = {})
+      parameters[:session] ||= @session
+      @webconversation.get(path, parameters)
+    end
+    
+    def put(path, parameters = {})
+      parameters[:session] ||= @session
+      @webconversation.put(path, parameters)
+    end
+    
+    def get_response(path, parameters = {})
+      response = ROX::Response.new(JSON.parse(get(path, parameters)))
+      raise ROX::OXException.new(response) if response.error?
+      return response;
+    end
+    
+    def put_response(path, parameters = {}) 
+      response = ROX::Response.new(JSON.parse(put(path, parameters)))
+      raise ROX::OXException.new(response) if response.error?
+      return response
+    end
+    
+    def in_module(moduleName, &block)
+      mod = self.module(moduleName)
+      return mod.instance_eval(&block) if block_given?
+      return mod
+    end
+    
+    def module(moduleName)
+      ROX::SimpleModule.new("/ajax/"+moduleName.to_s, self)
+    end
+  end
+  
+end

data/lib/rox/config_tree.rb

@@ -0,0 +1,27 @@
+module ROX
+  class ConfigTree
+    def initialize(client)
+      @client = client
+    end
+    
+    def [](path)
+      return @client.get_response("/ajax/config/#{path}")["data"]
+    end
+    
+    def []=(path, value)
+      @client.put("/ajax/config/#{path}", :body => value.to_json)
+    end
+  
+  end
+
+
+  class Client
+    
+    def config
+      @config ||= ROX::ConfigTree.new(self)
+    end
+    
+  
+  end
+
+end

data/lib/rox/dependencies.rb

@@ -0,0 +1,2 @@
+require 'json'
+require 'tzinfo'

data/lib/rox/exception.rb

@@ -0,0 +1,14 @@
+module ROX
+
+  class OXException < Exception
+    def initialize(response)
+      @response = response
+    end
+    
+    def to_s
+      @response.error
+    end
+  
+  end
+
+end

data/lib/rox/folders.rb

@@ -0,0 +1,59 @@
+module ROX
+  
+  columns(:common) {
+    
+    column(1, :id, :string)
+    column(2, :created_by, :string)
+    column(3, :modified_by, :string)
+    column(4, :creation_date, :time)
+    column(5, :last_modified, :time)
+    column(6, :last_modified_utc, :timestamp)
+    column(20, :folder_id, :string)
+  
+  }
+  
+  columns(:folder => :common) {
+    
+    column(300, :title, :string)
+    column(301, :module, :string)
+    column(302, :type, :mappable, {1 => :private, 2 => :public, 3 => :shared, 5 => :system})
+    column(304, :boolean, :subfolders)
+    #column(305, :own_rights, :)
+    #column(306, :permissions, :)
+    column(307, :summary, :string)
+    column(308, :standard_folder, :boolean)
+    column(309, :total, :number)
+    column(310, :new, :number)
+    column(311, :unread, :number)
+    column(312, :deleted, :number)
+    column(313, :capabilities, :number)
+    column(314, :subscribed, :boolean)
+    column(315, :subscr_subflds, :boolean)
+  }
+  
+  
+  class Folders
+    def initialize(client)
+      @client = client
+      @columns = COLUMN_DEFINITIONS[:folder]
+    end
+    
+    def root(*columns)
+      column_list = get_columns(*columns)
+      @client.get_response("/ajax/folders", :action => :root, :columns => column_list.to_s)
+    end
+    
+    def get_columns(*columns)
+      @columns.sublist(*columns)
+    end
+    
+  end
+
+
+  class Client
+    def folders
+      Folders.new(self)
+    end
+  end
+
+end

data/lib/rox/response.rb

@@ -0,0 +1,29 @@
+module ROX
+  class Response
+    def initialize(ox_response)
+      @oxresponse = ox_response
+    end
+    
+    def error?
+      @oxresponse.include?('error')
+    end
+    
+    def error
+      return nil unless error?
+      sprintf(@oxresponse['error'], *@oxresponse['error_params'])
+    end
+    
+    def [](key)
+      @oxresponse[key.to_s]
+    end
+    
+    def data
+      @oxresponse['data']
+    end
+    
+    def to_s
+      @oxresponse.inspect
+    end
+    
+  end
+end

data/lib/rox/rox.rb

@@ -0,0 +1,170 @@
+module ROX
+  
+  class Column
+    
+    attr_accessor :number, :name, :type, :options
+    
+    def initialize(number, name, type, options = nil)
+      @number = number
+      @name = name
+      @type = type
+      @options = options
+    end
+    
+    def to_ox(client, value)
+      value
+    end
+    
+    def from_ox(client, value)
+      value
+    end
+  
+  end
+  
+  class MappableColumn < Column
+    def initialize(number, name, type, options)
+      super(number, name, type, options)
+      @from_ox = options
+      @inverse = @from_ox.inject({}) {|memo, pair| memo[pair[1]] = pair[0]; memo} if options
+    end
+    
+    def to_ox(client, value)
+      @inverse[value]
+    end
+    
+    def from_ox(client, value)
+      @from_ox[value]
+    end
+    
+  end
+  
+  class TimeColumn < Column
+    
+    def from_ox(client, value)
+      Time.at(client.config.timezone.local_to_utc(value / 1000))
+    end
+    
+    def to_ox(client, value)
+      client.config.timezone.utc_to_local(value.to_i) * 1000
+    end
+    
+  end
+  
+  class DateColumn < Column
+  
+    def from_ox(client, value)
+      Time.at(value / 1000)
+    end
+    
+    def to_ox(client, value)
+      value.to_i * 1000
+    end
+    
+  end
+  
+  class ComplexColumn < Column
+    def initialize(number, name, type, klass)
+      super(number, name, type, klass)
+      @klass = klass
+    end  
+  
+    def from_ox(client, value)
+      @klass.new(value)
+    end
+  
+    def to_ox(client, value)
+      value.to_ox
+    end
+  end
+  
+  class ColumnList
+    attr_reader :columns, :ancestors
+    
+    def initialize(ancestors = nil)
+      @ancestors = ancestors || Array.new
+      @columns = Hash.new
+      @columns_by_number = Hash.new
+    end
+  
+    def column(number, name, type, options = nil)
+      case(type)
+      when :date
+        klass = DateColumn
+      when :time
+        klass = TimeColumn
+      when :mappable
+        klass = MappableColumn
+      when :complex
+        klass = ComplexColumn
+      else
+        klass = Column
+      end
+      column = klass.new(number, name, type, options)
+      add_column(column)
+      self
+    end
+    
+    def add_column(column_def)
+      @columns[column_def.name] = column_def
+      @columns_by_number[column_def.number] = column_def
+    end
+    
+    def [](key)
+      return @columns[key] if @columns.include?(key)
+      return @columns_by_number[key] if @columns_by_number.include?(key)
+      @ancestors.each do
+        |ancestor|
+        column = ancestor[key]
+        return column if column
+      end
+      nil
+    end
+    
+    def sublist(*keys)
+      sublist = ColumnList.new
+      keys.each do
+        |key|
+        value = self[key]
+        sublist.add_column(value)
+      end
+      sublist
+    end
+    
+    def to_s
+      @columns_by_number.keys.join(",")
+    end
+  
+  end
+  
+  
+  class ColumnDefinitions
+    
+    def initialize
+      @definitions = Hash.new
+    end
+    
+    def columns(typedef, &block)
+      name = typedef
+      ancestors = Array.new
+      if(typedef.kind_of?(Hash))
+        name = typedef.keys.first
+        ancestors = [*typedef[name]].map{|ancestor| self[ancestor]}
+      end
+      column_list = ColumnList.new(ancestors)
+      column_list.instance_eval(&block)
+      @definitions[name] = column_list
+    end
+    
+    def [](key)
+      @definitions[key]
+    end
+    
+  end
+  
+  COLUMN_DEFINITIONS = ColumnDefinitions.new
+  
+  def self.columns(options, &block)
+    COLUMN_DEFINITIONS.columns(options, &block)
+  end
+
+end

data/lib/rox/simple_module.rb

@@ -0,0 +1,42 @@
+module ROX
+  
+  class SimpleModule
+    def initialize(path, client)
+      @path = path
+      @client = client
+    end
+    
+    def _get(params)
+      @client.get_response(@path, params)
+    end
+    
+    def _put(params)
+      @client.put_response(@path, params)
+    end
+    
+    def call(action, params)
+      _call(action, params)
+    end
+    
+    def _call(action, params)
+      params[:action] = action
+      if(params[:body])
+        params[:body] = params[:body].to_json
+        _put(params)
+      elsif params[:body_raw]
+        params[:body] = params[:body_raw]
+        params.delete(:body_raw)
+        _put(params)
+      else
+        _get(params)
+      end
+    end
+    
+    def method_missing(meth, *args, &block)
+      params = args.first || {}
+      _call(meth, params)
+    end
+    
+  end
+    
+end

data/lib/rox/webconversation.rb

@@ -0,0 +1,96 @@
+require 'net/http'
+require 'net/https'
+require 'open-uri'
+
+module ROX
+  class WebConversation
+    attr_accessor :cookies
+    
+    def initialize(uri)
+      @cookies = Hash.new
+      @uri = URI.parse(uri)
+    end
+    
+    def get(url, params = {})
+      req = Net::HTTP::Get.new(url+"?"+query(params))
+      res = request(req)
+      return res.body
+    end
+    
+    def post(url, params = {})
+      stringified_params = Hash.new
+      params.each do
+        |key, value|
+        next if key == :body or key == 'body'
+        stringified_params[key.to_s] = value.to_s
+      end
+      req = Net::HTTP::Post.new(url)
+      req.set_form_data(stringified_params)
+      req.body = params[:body] || params['body']
+      res = request(req)
+      return res.body
+    end
+    
+    def put(url, params = {})
+      req = Net::HTTP::Put.new(url+"?"+query(params))
+      req.body = params[:body] || params['body']
+      res = request(req)
+      return res.body
+    end
+    
+    def delete(url, params = {})
+      req = Net::HTTP::Delete.new(url+"?"+query(params))
+      res = request(req)
+      return res.body
+    end
+    
+    def remember_cookies(res)
+      setCookie = res['Set-Cookie']
+      return unless setCookie
+      cookies = setCookie.split(/\s*[,;]\s*/)
+
+      cookies.each do
+        |cookieDef|
+          if (cookieDef =~ /^(JS|open-xchange)/)
+            key, value = cookieDef.split(/\=/)
+            @cookies[key] = value
+          end
+        end
+      end
+    
+    def add_cookies(req)
+      return if @cookies.empty?
+      cookie_string = ""
+      @cookies.each do
+        |key, value|
+        cookie_string << "#{key}=#{value},"
+      end
+      req["Cookie"] = cookie_string[0...cookie_string.size-1]
+    end
+    
+    def query(params)
+      query = ""
+      params.each do
+        |key, value|
+        next if key == :body || key == 'body'
+        query += '&'
+        query += URI.escape(key.to_s)+"="+URI.escape(value.to_s)
+      end
+      query = query[1..query.size]
+      return query
+    end
+    
+    def request(req)
+      add_cookies(req)
+      http_session = Net::HTTP.new(@uri.host, @uri.port)
+      http_session.use_ssl = @uri.scheme == "https"
+      res = http_session.start do
+        |http|
+        http.request(req)
+      end
+      remember_cookies(res)
+      return res
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: rox
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Francisco Laguna
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-11 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: tzinfo
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: An Open-Xchange HTTP API client library
+email: fla@synapps.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/rox.rb
+- lib/rox/client.rb
+- lib/rox/config_tree.rb
+- lib/rox/dependencies.rb
+- lib/rox/exception.rb
+- lib/rox/folders.rb
+- lib/rox/response.rb
+- lib/rox/rox.rb
+- lib/rox/simple_module.rb
+- lib/rox/webconversation.rb
+- examples/workspace.rb
+- README
+homepage: http://www.ox.io
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.1
+signing_key: 
+specification_version: 3
+summary: An Open-Xchange HTTP API client library
+test_files: []
+