oos4ruby 0.1.0

data/lib/oos4ruby/feed.rb

@@ -0,0 +1,65 @@
+require 'rexml/document'
+require 'rexml/xpath'
+
+module Oos4ruby
+class Feed
+
+  attr_reader :previous, :next, :entries, :xml
+  
+  def initialize(entries, xml)
+    @entries = entries
+    @xml = xml
+    @next = Feed.get_link('next', xml)
+    @previous = Feed.get_link 'previous', xml
+    @self = Feed.get_link 'self', xml
+  end
+  
+  def self.get_link(rel, xml)
+    link = REXML::XPath.first(xml, "./atom:link[@rel=\"#{rel}\"]", XmlNamespaces)
+    if link      
+      uri = URI.parse link.attributes['href']
+      if uri.absolute?
+        return uri
+      else
+        return URI.parse(OOS_URL).merge(uri)
+      end      
+    end
+  end
+  
+  def Feed.read(body)
+
+    feed = nil
+    begin
+      feed = REXML::Document.new(body, { :raw => nil }).root
+      
+      entries = REXML::XPath.match(feed, "./atom:entry", XmlNamespaces)      
+
+      entries.map! { |entry| Entry.new(entry) }
+      feed = Feed.new( entries, feed )
+    rescue => ex
+      puts ex.message
+      puts ex.backtrace.join("\n")        
+    end    
+
+    return feed
+  end
+  
+  def self_link
+    @self
+  end
+    
+  def self_link?
+    !@self.nil?
+  end
+  
+  def previous?    
+    !@previous.nil?
+  end
+  
+  def next?    
+    !@next.nil?
+  end
+
+end
+end
+

data/lib/oos4ruby/http_invoker.rb

@@ -0,0 +1,140 @@
+
+require 'net/http'
+
+module Oos4ruby
+class HTTPInvoker
+  
+  attr_reader :response, :headers, :entry, :body
+  
+  def initialize(uri, authent)
+    @uri = (uri if uri.kind_of?URI) || URI.parse(uri)
+    @authent = authent
+    
+    @headers = {}
+    @entry = nil
+  end
+  
+  def set_header(name, val)
+    @headers[name] = val
+  end
+  
+  def get(depth = 0, req = nil)           
+    return false unless is_authenticate?depth, req
+    
+    http, req = prepare_http req, :get
+    
+    http.start do |connection|
+      @response = connection.request(req)
+
+      return get(depth + 1, req) if need_authentication?(req)
+
+      if @response.kind_of?Net::HTTPSuccess
+        @body = @response.body
+        return true
+      end 
+
+      
+      return false
+    end      
+    
+  end
+  
+  def post(contentType, body, depth = 0, req = nil)    
+    return false unless is_authenticate?depth, req
+    
+    http, req = prepare_http req, :post
+    
+    req.set_content_type contentType
+    @headers.each { |k, v| req[k]= v }
+
+    http.start do |connection|
+      @response = connection.request(req, body)
+
+      return post(contentType, body, depth + 1, req) if need_authentication?(req)
+
+      return false if @response.code != '201'
+
+      begin
+        @entry = Entry.new @response.body
+        return true
+      rescue ArgumentError          
+        return false
+      end
+    end
+    
+  end
+  
+  def put(contentType, body, depth = 0, req = nil)    
+    return false unless is_authenticate?depth, req
+    
+    http, req = prepare_http req, :put    
+    
+    req.set_content_type contentType
+    @headers.each { |k, v| req[k]= v }
+
+    http.start do |connection|
+      @response = connection.request(req, body)
+
+      return put(contentType, body, depth +1, req) if need_authentication?(req)
+
+      return true if @response.kind_of? Net::HTTPSuccess        
+
+      return false
+    end
+    
+  end
+  
+  def delete( req = nil, depth = 0 )
+    return false unless is_authenticate?depth, req
+
+    http, req = prepare_http req, :delete
+    
+    http.start do |connection|
+      @response = connection.request(req)
+
+      return delete(req, depth + 1) if need_authentication?(req)
+
+      return true if @response.kind_of? Net::HTTPSuccess
+
+      return false
+    end
+
+  end
+  
+  private
+  def header(which)
+    @response[which]
+  end
+  
+  def prepare_http( req, option )
+    http = Net::HTTP.new(@uri.host, @uri.port)
+    http.use_ssl = true if @uri.scheme == 'https'    
+    
+    unless req
+      url = @uri.path
+      url += "?#{@uri.query}" if @uri.query
+      req = Net::HTTP::Get.new( url ) if option == :get
+      req = Net::HTTP::Post.new( url ) if option == :post
+      req = Net::HTTP::Put.new( url ) if option == :put
+      req = Net::HTTP::Delete.new( url ) if option == :delete
+    end
+    
+    return http, req
+  end
+  
+  def need_authentication?(req)    
+    if @response.instance_of?(Net::HTTPUnauthorized) && @authent      
+      @authent.add_to req      
+      req.body = nil unless req.body.nil?
+      return true
+    end
+    return false 
+  end
+  
+  def is_authenticate?(depth, req)
+    return false if depth > 2 and need_authentication?(req)          
+    return true
+  end
+  
+end
+end

data/lib/oos4ruby/oos.rb

@@ -0,0 +1,54 @@
+
+require 'rexml/document'
+require 'rexml/xpath'
+
+module Oos4ruby
+  class Oos
+    def auth_app(app_token, secret_key)
+      @auth = Auth.new(app_token, secret_key, :app)
+    end
+    
+    def auth_user(email, api_token)
+      @auth = Auth.new(email, api_token, :wsse)
+      document_service
+    end
+    
+    def user(slug = nil)      
+      User.find( @auth, slug )
+    end
+    
+    def search(opts)
+      Search.find @auth, opts
+    end
+   
+    def privacy_cats
+      return @privacy_cats if @privacy_cats
+      getter = HTTPInvoker.new PRIVACY_URL, @auth
+      
+      worked = getter.get
+      
+      if worked
+        @privacy_cats = {}
+        cats = REXML::Document.new( getter.body ).root
+        REXML::XPath.match(cats, './atom:category', XmlNamespaces).each { |cat|          
+          cat.add_attribute('scheme', cats.attributes['scheme'])
+          @privacy_cats[cat.attributes['term'].underscore.to_sym] = Category.new(cat)
+        }
+      end
+      return @privacy_cats
+    end
+
+    private
+    def document_service
+      getter = HTTPInvoker.new API_URL, @auth
+      
+      worked = getter.get
+      
+      if worked 
+        @service = Service.new(REXML::Document.new( getter.body ).root)
+      end
+    end
+  end
+end
+
+

data/lib/oos4ruby/search.rb

@@ -0,0 +1,75 @@
+
+require 'cgi'
+
+module Oos4ruby
+class Search
+  
+=begin rdoc
+  Method to search places into 11870
+  available parameters:
+  <tt>q</tt>:: string that represents a siple query.
+  <tt>bbox</tt>:: array of points that delimiters a rectangle, SW and NE.
+  <tt>as</tt>:: area specified by a slug. I.E: /es/madrid.
+  <tt>tags</tt>:: array of tags.
+  <tt>tag_op</tt>:: tags operator, "and" or "or".
+  <tt>lat</tt>:: latitude of the center point of an area.
+  <tt>lon</tt>:: longitude of the center point of an area.
+  <tt>radius</tt>:: radius to create a rectangle from the center point of an area.
+  <tt>page</tt>:: page number in the search results
+=end
+  def Search.find(auth, opts)
+    query = SEARCH_URL
+    
+    more_params = false
+    unless opts.empty?
+      query += "?"
+      if opts[:q]
+        query += "q=#{CGI.escape(opts[:q])}"
+        more_params = true
+      end
+      if opts[:bbox]
+        query += "&" if more_params
+        query += "bbox=#{opts[:bbox].join(",")}"
+        more_params = true
+      end
+      if opts[:as]
+        query += "&" if more_params
+        query += "as=#{opts[:as]}"
+        more_params = true
+      end
+      if opts[:tags]
+        query += "&" if more_params
+        opts[:tags].each_with_index do |tag, index|
+          query += "tag=#{CGI.escape(tag)}"          
+          query += "&" if index < opts[:tags].length - 1
+        end
+        more_params = true
+      end
+      if opts[:tag_op]
+        query += "&" if more_params
+        query += "tagOp=#{opts[:tag_op]}"
+        more_params = true
+      end
+      if opts[:lat] and opts[:lon] and opts[:radius]
+        query += "&" if more_params
+        query += "lat=#{opts[:lat]}&lon=#{opts[:lon]}&radius=#{opts[:radius]}"
+        more_params = true
+      end
+      if opts[:page]
+        query += "&" if more_params
+        query += "page=#{opts[:page]}"
+      end
+    else
+      raise RuntimeError('a parameter is obligatory at least')
+    end
+    
+    getter = HTTPInvoker.new query, auth
+    
+    worked = getter.get
+    raise RuntimeError.new(getter.response.message) unless worked
+    Sites.new(Feed.read(getter.body), auth, nil)
+  end
+end
+end
+
+

data/lib/oos4ruby/service.rb

@@ -0,0 +1,13 @@
+#
+module Oos4ruby
+class Service
+  
+  attr_reader :xml
+  
+  def initialize(xml)    
+    @xml = xml
+  end
+end
+end
+
+

data/lib/oos4ruby/site.rb

@@ -0,0 +1,220 @@
+
+include Bean
+
+module Oos4ruby
+class Site < Bean::BeanClass
+  
+  define_el_reader(
+    {
+      OosNamespace => [:id, :user_address, :url, :locality, :subadministrativearea, :country, :telephone],
+      AppNamespace => [:edited],
+      AtomNamespace => [:title, :updated, :summary, :content]
+    }
+  )
+  
+  define_attr_reader OosNamespace => {:country => :slug, :locality => :slug}
+  
+  alias :oos_id :id
+  alias :name :title
+  alias :review_title :summary
+  alias :review_content :content
+    
+  attr_writer :review_title, :review_content, :user_address, :url, :locality, :telephone
+  
+  def country=(name, slug)
+    @country = REXML::Element.new('oos:country')
+    @country.add_namespace('oos', OosNamespace)
+    @country.add_text name 
+    @country.add_attribute 'slug', slug
+  end
+  
+  def initialize(xml, auth, slug = nil)
+    @xml = xml
+    @auth = auth
+    if slug
+      @slug = slug
+      @tags_scheme = "#{TAGS_URL}/#{@slug}"
+      @lists_scheme = "#{LISTS_URL}/#{@slug}"
+    end
+    @categories_added = []
+    @categories_removed = []
+  end
+  
+  def Site.find_by_user( auth, slug, opts = {} )
+    raise Oos4ruby::UnknownUser if slug.nil?
+    
+    uri = SITES_URL + "/#{slug}"
+    
+    getter = HTTPInvoker.new uri, auth
+    
+    worked = getter.get
+    
+    Sites.new(Feed.read(getter.body), auth, slug) if worked
+  end    
+  
+  def Site.dump!(opts, slug)
+    entry = create_entry
+    
+    entry.add_element opts[:author]
+    
+    add_element entry, 'updated', DateTime.now
+    add_element entry, 'id', make_id
+    add_element entry, 'oos:id', opts[:id] if opts[:id]
+    add_element entry, 'title', opts[:title] if opts[:title]
+    add_element entry, 'oos:useraddress', opts[:user_address] if opts[:user_address]
+    add_element entry, 'oos:url', opts[:url] if opts[:url]
+    add_element entry, 'summary', opts[:review_title] if opts[:review_title]
+    add_element entry, 'summary', opts[:summary] if opts[:summary] and REXML::XPath.first(entry, 'summary', XmlNamespaces).nil?
+    
+    if opts[:privacy]
+      if opts[:privacy].is_a?REXML::Element
+        entry.add_element opts[:privacy]
+      elsif opts[:privacy].is_a?String         
+        add_category entry, opts[:privacy], PRIVACY_URL
+      end
+    end
+      
+    if opts[:review_content] || opts[:content]
+      content = opts[:review_content] || opts[:content]
+      attrs = {}
+      text = nil
+      if content.is_a?String
+        text = content
+      elsif content.is_a?Hash
+        text = content[:text]
+        content.delete :text
+        content.each_pair {|key, value| attrs[key.to_s] = value}        
+      end
+      add_element entry, 'content', text, attrs
+    end
+    
+    if opts[:locality]
+      name = nil
+      local_slug = nil
+      attrs = {}
+      if opts[:locality].is_a?Hash
+        name = opts[:locality][:name]
+        local_slug = opts[:locality][:slug]
+      elsif opts[:locality].is_a?String
+        name = opts[:locality]
+      end
+      attrs['slug'] = local_slug if local_slug
+      add_element entry, 'oos:locality', name, attrs
+    end
+    
+    if opts[:country]
+      name = opts[:country][:name]
+      opts[:country].delete :name
+      attrs = {}
+      opts[:country].each_pair {|key, value| attrs[key.to_s] = value}
+      add_element entry, 'oos:country', name, attrs
+    end
+    
+    opts[:tags].each { |tag| add_category entry, tag.to_s, "#{TAGS_URL}/#{slug}"} if opts[:tags]
+    opts[:lists].each { |list| add_category entry, list.to_s, "#{LISTS_URL}/#{slug}"} if opts[:lists]
+    
+    entry
+  end
+  
+  def tags
+    return @tags if @tags
+    categories = @xml.match("./atom:category[@scheme=\"#{@tags_scheme}\"]")
+    if categories
+      @tags = categories.map { |cat|
+        Category.new cat
+      }
+    end
+    @tags
+  end
+  
+  def lists
+    return @lists if @lists
+    categories = @xml.match("./atom:category[@scheme=\"#{@lists_scheme}\"]")
+    if categories
+      @lists = categories.map { |cat|
+        Category.new cat
+      }
+    end
+    @lists
+  end
+  
+  def latitude
+    @xml.first('./georss:where/gml:Point/gml:pos').text.
+      split[0] if @xml.first('./georss:where')
+  end
+  
+  def longitude
+    @xml.first('./georss:where/gml:Point/gml:pos').text.
+      split[1] if @xml.first('./georss:where')
+  end
+  
+  def add_tag(tag)
+    tag = Category.new(tag, @tags_scheme )
+    @categories_added << tag
+  end
+  
+  def add_list(list)
+    list = Category.new(list, @lists_scheme )
+    @categories_added << list
+  end
+  
+  def remove_tag(tag)
+    tag = Category.new(tag, @tags_scheme )
+    @categories_removed << tag
+  end
+  
+  def remove_list(list)
+    list = Category.new(list, @lists_scheme )
+    @categories_removed << list
+  end
+  
+  def privacy
+    return @privacy if @privacy
+    @privacy = @xml.category({:scheme => PRIVACY_URL}).attributes['term']
+    @privacy
+  end
+  
+  def privacy=(privacy)    
+    @privacy_updated = privacy
+  end
+  
+  private
+  def load!
+    if @title_review
+      summary = @xml.child('summary') || @xml.add_child('summary')
+      summary.text = @title_review
+    end
+
+    if @content_review
+      content = @xml.child('content') || @xml.add_child('content', nil, nil, {:type => 'html'})
+      content.text = @content_review 
+    end
+
+    if @categories_added
+      @categories_added.each { |cat|
+        add_category cat.term, cat.scheme
+        @tags << cat if cat.scheme == @tags_scheme
+        @lists << cat if cat.scheme == @lists_scheme
+      }
+      @categories_added.clear
+    end
+    
+    if @categories_removed
+      @categories_removed.each { |cat|
+        remove_category cat.term, cat.scheme
+        @tags = @tags.reject { |tag|
+          tag.term == cat.term and tag.scheme == cat.scheme
+        }
+      }
+      @categories_removed.clear
+    end
+              
+    update_category @privacy_updated.term, @privacy_updated.scheme, 
+      nil, @privacy_updated.scheme if @privacy_updated
+    
+  end
+    
+end
+end
+
+

data/lib/oos4ruby/sites.rb

@@ -0,0 +1,11 @@
+
+module Oos4ruby
+class Sites < Collection  
+  def initialize(feed, auth, slug = nil)
+    super( feed, auth, slug )    
+    @entries = feed.entries.map {|entry| Site.new(entry, @auth, slug) }
+  end    
+end
+end
+
+

data/lib/oos4ruby/user.rb

@@ -0,0 +1,122 @@
+
+require 'mime/types'
+
+include Bean
+
+module Oos4ruby
+class User < Bean::BeanClass
+  
+  define_el_reader({
+    OosNamespace => [:name, :surname, :no_mails, :only_contacts, :no_newsletter],
+    AtomNamespace => [:title, :updated, :content]
+  })
+  
+  alias :nick :title
+  alias :about_me :content
+  
+  attr_writer :nick, :about_me, :name, :surname, :no_mails, :only_contacts, :no_newsletter
+  
+  def initialize(entry, auth, slug = nil)
+    @xml = entry
+    @auth = auth
+    @slug = slug || @xml.child('slug', OosNamespace).text
+  end
+  
+  def User.find( auth, slug = nil )
+    raise Oos4ruby::UnknownUser if auth.method?(:app) && slug.nil?
+    
+    begin
+      uri = URI.parse(slug)
+    rescue
+      uri = nil
+    end
+    
+    unless uri
+      uri = USERS_URL
+      uri = uri + "/#{slug}" if slug
+    end
+    
+    getter = HTTPInvoker.new uri.to_s, auth
+    
+    worked = getter.get
+    
+    if worked
+      if slug #response is an Entry
+        entry = Entry.new getter.body
+        return User.new(entry, auth, slug)
+      else
+        #response is a feed
+        feed = Feed.read getter.body        
+        rel_edit = feed.entries[0].link('edit')
+        
+        getter = HTTPInvoker.new rel_edit, auth
+        worked = getter.get
+        if worked
+          entry = Entry.new getter.body
+          return User.new(entry, auth)
+        else
+          raise Oos4ruby::UnknownUser
+        end
+      end
+    end    
+  end
+  
+  def to_xml
+    @xml.to_s
+  end
+  
+  def sites( opts = {} )
+    @sites_collection = Site.find_by_user(@auth, @slug, opts) unless @sites_collection
+    @sites_collection
+  end
+  
+  def contacts( opts = {} )
+    @contacts_collection = Contact.find_by_user(@auth, @slug, opts) unless @contacts_collection
+    @contacts_collection
+  end
+  
+  def avatar
+    @xml.link('avatar')
+  end
+  
+  def avatar!(file_path)
+    getter = HTTPInvoker.new @xml.link('edit-media'), @auth
+    worked = getter.get
+    
+    if worked
+      file = File.new(file_path, 'w+')
+      file << getter.body
+    end
+  end
+  
+  def update_avatar!(file_path)
+    file = File.open(file_path, "rb") { |f| f.read } 
+        
+    putter = HTTPInvoker.new(@xml.link('edit-media'), @auth)
+    
+    putter.set_header 'Content-Length', File.size(file_path)
+    
+    worked = putter.put MIME::Types.type_for(file_path)[0].to_s, file
+    
+    raise RuntimeError unless worked
+  end
+  
+  private
+  def load!    
+      @xml.child('title').text = @nick if @nick
+      if @about_me
+        about = @xml.child('content') || @xml.add_child('content', nil, nil, {:type => 'text'})
+        about.text = @about_me
+      end
+      
+      @xml.child('name', OosNamespace).text = @name if @name
+      @xml.child('surname', OosNamespace).text = @surname if @surname
+      @xml.child('nomails', OosNamespace).text = @no_mails.to_s if !@no_mails.nil?
+      @xml.child('nonewsletter', OosNamespace).text = @no_newsletter.to_s if !@no_newsletter.nil?
+      @xml.child('onlycontacts', OosNamespace).text = @only_contacts.to_s if !@only_contacts.nil?
+  end
+end
+end
+
+
+

data/lib/oos4ruby/version.rb

@@ -0,0 +1,9 @@
+module Oos4ruby #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end