go-picasa-go 0.0.1

data/lib/picasa/album.rb

@@ -0,0 +1,267 @@
+# Module that offers methods to do high level operations concerning
+# a album within Picasa.
+
+module Picasa::Album
+
+  include Picasa::Missing   
+
+  # Class methods to be added to the class that will include this module.
+    
+  module ClassMethods
+    include Picasa::Util
+    
+    # Sets the user class configured so it can be used later.
+    
+    def belongs_to_picasa_user params
+      unless params[:class_name] and params[:class_name].class == String
+        raise Exception, 'You should pass the string of the class name that includes Picasa::User.'
+      end
+      
+      define_dependent_class_methods :user_class, params[:class_name]
+    end
+    
+    # Method used to tell the gem what is the class that implements the
+    # Picasa::Photo module.
+    
+    def has_many_picasa_photos params
+      unless params[:class_name] and params[:class_name].class == String
+        raise Exception, 'You should pass the string of the class name that includes Picasa::Album.'
+      end
+
+      define_dependent_class_methods :photo_class, params[:class_name]      
+    end
+    
+    # Find an album by user_id and album_id. It's mandatory to inform the 
+    # authentication token. If no album is found, then an exception is raised.
+    
+    def picasa_find user_id, album_id, auth_token
+      resp, data = Picasa::HTTP::Album.get_album user_id, album_id, auth_token
+      
+      if resp.code != "200" or resp.message != "OK"
+        return nil
+      end
+      
+      album = new
+      album.send(:populate_attributes_from_xml, data)
+      album.user = create_user user_id, auth_token
+      album
+    end
+    
+    # Find an album by user_id and album_id. It's mandatory to inform the 
+    # authentication token. If no album is found, then an exception is raised.
+    
+    def picasa_find_all user_id, auth_token
+      albums = []
+      resp, data = Picasa::HTTP::Album.get_albums user_id, auth_token
+      
+      if resp.code != "200" or resp.message != "OK"
+        return nil
+      end
+      
+      doc = Nokogiri::XML(data)
+      doc.css('entry').each do |entry|
+        album = new
+        album.send(:populate_attributes, entry)
+        album.user = create_user user_id, auth_token
+        albums << album
+      end
+      albums
+    end
+    
+    private
+    
+    def create_user picasa_id, auth_token
+      user = user_class.new
+      user.picasa_id = picasa_id
+      user.auth_token = auth_token
+      user 
+    end
+  end
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  attr_reader :picasa_id, :author_name, :author_uri, :timestamp, :num_photos, 
+              :nickname, :commenting_enable, :comment_count, 
+              :media_content_url, :media_thumbnail_url, :user, :link_edit
+
+  attr_accessor :title, :summary, :location, :keywords, :user, :access
+
+  alias_method :cover_url, :media_content_url
+  alias_method :thumbnail_url, :media_thumbnail_url
+  
+  # Post an album into Picasa. 
+  # If cannot create the album an exception is raised.
+  
+  def picasa_save!
+    if self.picasa_id and picasa_id.length > 0
+      return self.picasa_update!
+    end
+    
+    params = {
+      :title => title,
+      :summary => summary,
+      :location => location,
+      :keywords => keywords,
+      :access => access
+    }
+    
+    resp, data = Picasa::HTTP::Album.post_album(user_id, auth_token, params)
+    
+    if resp.code != "201" or resp.message != "Created"
+      raise Exception, "Error creating album: #{resp.message}."
+    end
+    
+    populate_attributes_from_xml data
+    self
+  end
+
+  # Post an album into Picasa.
+  # If cannot create the album returns false.
+  
+  def picasa_save
+    raise_exception? do
+      picasa_save!
+    end
+  end
+  
+  # Update the attributes of the current album.
+  # If cannot update, an exception is raised.
+  
+  def picasa_update_attributes! params
+    resp, data = Picasa::HTTP::Album.update_album user_id, self.picasa_id, auth_token, params
+
+    if resp.code != "200" or resp.message != "OK"
+      raise Exception, "Error updating album."
+    end
+    
+    populate_attributes_from_xml data
+  end
+  
+  # Update the attributes of the current album.
+  # If cannot update, return false.
+  
+  def picasa_update_attributes params
+    raise_exception? do
+      picasa_update_attributes! params
+    end
+  end
+  
+  # Update all attributes of the current album.
+  # If cannot update, an exception is raised.
+  
+  def picasa_update!
+    params = {
+      :title => title,
+      :summary => summary,
+      :location => location,
+      :keywords => keywords
+    }
+    picasa_update_attributes! params
+  end
+
+  # Update all attributes of the current album.
+  # If cannot update, returns false.
+  
+  def picasa_update
+    raise_exception? do
+      picasa_update!
+    end
+  end
+  
+  
+  # Destroy the current album. 
+  # If cannot destroy it, an exception is raised.
+  
+  def picasa_destroy!
+    resp, data = Picasa::HTTP::Album.delete_album user_id, self.picasa_id, auth_token
+    
+    if resp.code != "200" or resp.message != "OK"
+      raise Exception, "Error destroying album."
+    end
+  end
+  
+  # Destroy the current album and returns true. 
+  # If cannot destroy it, returns false.
+  
+  def picasa_destroy
+    raise_exception? do
+      picasa_destroy!
+    end
+  end
+  
+  def find_photo photo_id
+    photo_class.picasa_find user_id, picasa_id, photo_id, auth_token
+  end
+  
+  # Find all photos from the current album. The operation is done only one time
+  # for an instance, if it it's needed to do it to refresh the data you can 
+  # pass the parameter true so it can be reloaded.
+  
+  def photos(reload = false)
+    @photos = photo_class.picasa_find_all user_id, picasa_id, auth_token if reload
+    @photos ||= photo_class.picasa_find_all user_id, picasa_id, auth_token
+  end
+  
+  ##############################################################################
+  # Private Methods                                                            #
+  ##############################################################################
+
+  private 
+
+  # Returns the user email based on the user_id methods
+  
+  def user_email
+    "#{user_id}@gmail.com"
+  end
+  
+  # Populates the attributes of the object based on the xml
+  
+  def populate_attributes doc
+    hash = doc_to_hash doc
+    
+    hash.keys.each do |k|
+      self.instance_variable_set("@#{k}", hash[k])
+    end
+  end
+  
+  def populate_attributes_from_xml xml
+    doc = Nokogiri::XML xml
+    entry = doc.css('entry')
+    populate_attributes entry
+  end
+  
+  # Generate a hash representing the attributes of the album from a Nokogiri 
+  # document 
+  
+  def doc_to_hash(doc)
+    hash = {
+      :picasa_id => doc.at_xpath('//gphoto:id').content,
+      :title => doc.at_css('title').content,
+      :summary => doc.at_css('summary').content,
+      :location => doc.at_xpath('gphoto:location').content,
+      :keywords => doc.at_xpath('//media:keywords').content,
+      :access => doc.at_xpath('gphoto:access').content,
+      :author_name => doc.at_css('author name').content,
+      :author_uri => doc.at_css('author uri').content,
+      :timestamp => Time.at(doc.at_xpath('gphoto:timestamp').content.slice(0..9).to_i),
+      :num_photos => doc.at_xpath('gphoto:numphotos').content.to_i,
+      :nickname => doc.at_xpath('gphoto:nickname').content,
+      :commenting_enable => doc.at_xpath('gphoto:commentingEnabled').content == "true" ? true : false,
+      :comment_count => doc.at_xpath('gphoto:commentCount').content.to_i,
+      :media_content_url => doc.at_xpath('//media:content').attr('url'),
+      :media_thumbnail_url => doc.at_xpath('//media:thumbnail').attr('url'),
+      :link_edit => doc.at_css('link[@rel="edit"]').attr('href')
+    }
+  end
+  
+  def user_id
+    @user.picasa_id
+  end
+  
+  def auth_token
+    @user.auth_token
+  end
+
+end

data/lib/picasa/authentication.rb

@@ -0,0 +1,19 @@
+# Module that offers methods to do the basic HTTP requests to authenticate
+# an user with a google account.
+
+module Picasa::Authentication
+  extend Picasa::Util
+
+  # Authenticate user and returns the authorization token 
+  # if the operation succeeds other whise an exception is raised.
+  
+  def self.authenticate user_id, password
+    resp, body = Picasa::HTTP::Authentication.authenticate user_id, password
+    
+    if resp.code != '200' or resp.message != 'OK'
+      raise Exception, "Could not authenticate user. Code: #{resp.code}. Message: #{resp.message}"
+    end
+    
+    extract_auth_token body
+  end
+end

data/lib/picasa/default_album.rb

@@ -0,0 +1,9 @@
+# Default class already configured to be used with Picasa api.
+
+module Picasa
+  class DefaultAlbum
+    acts_as_picasa_album
+    belongs_to_picasa_user :class_name => "Picasa::DefaultUser"
+    has_many_picasa_photos :class_name => 'Picasa::DefaultPhoto'
+  end
+end

data/lib/picasa/default_photo.rb

@@ -0,0 +1,6 @@
+module Picasa
+  class DefaultPhoto
+    acts_as_picasa_photo
+    belongs_to_picasa_album :class_name => 'Picasa::DefaultAlbum'
+  end
+end

data/lib/picasa/default_user.rb

@@ -0,0 +1,6 @@
+module Picasa
+  class DefaultUser
+    acts_as_picasa_user
+    has_many_picasa_albums :class_name => "Picasa::DefaultAlbum"
+  end
+end

data/lib/picasa/http/album.rb

@@ -0,0 +1,113 @@
+# Module that offers methods to do the basic HTTP requests to services provided
+# by Picasa to manipulate albums.
+module Picasa
+  module HTTP
+    module Album
+      # Do a post request to create an album into the user account. 
+      # The attributes used to create the album are:
+      #
+      # title, summary, location, keywords
+
+      def self.post_album user_id, auth_token, params
+        
+        puts params.inspect
+        
+        headers = albums_headers auth_token
+        
+        uri = albums_uri user_id
+        http = Net::HTTP.new(uri.host, uri.port)
+        
+        # Render the album template
+        template_path = File.dirname(__FILE__) + '/../template/'
+        template = ERB.new File.open(template_path+"album.xml.erb").read
+        
+        data = template.result(binding)
+        
+        puts data
+        
+        return http.post(uri.path, data, headers)
+      end
+      
+      # Do a put request to update album data
+      
+      def self.update_album user_id, album_id, auth_token, params
+        resp, data = get_album user_id, album_id, auth_token
+        
+        raise Exception, "Album not found." unless resp.code == "200"
+
+        data = update_album_xml data, params 
+        
+        headers = albums_headers auth_token, "If-Match" => "*"
+        
+        uri = album_uri user_id, album_id
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.send_request('PUT',uri.path, data, headers)
+      end
+      
+      # Do a delete request to delete an album from a user
+      
+      def self.delete_album user_id, album_id, auth_token
+        headers = albums_headers auth_token, "If-Match" => "*"
+        
+        uri = album_uri user_id, album_id
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.send_request('DELETE',uri.path, nil, headers)
+      end
+      
+      
+      # Do a get request to retrieve all the albums from a user using the user_id. 
+
+      def self.get_albums user_id, auth_token
+        headers = albums_headers auth_token
+        
+        uri = albums_uri user_id
+        
+        http = Net::HTTP.new(uri.host, 80)
+        http.get uri.path, headers
+      end
+      
+      # Do a get request to retrieve one specific album from a user
+      
+      def self.get_album user_id, album_id, auth_token = nil
+        headers = albums_headers auth_token
+        
+        uri = album_uri user_id, album_id
+        
+        http = Net::HTTP.new(uri.host, 80)
+        http.get uri.path, headers
+      end
+      
+      private 
+      
+      def self.update_album_xml xml, params
+        doc = Nokogiri::XML xml
+        doc.at_css('title').content = params[:title] if params[:title]
+        doc.at_css('summary').content = params[:summary] if params[:summary]
+        doc.at_xpath('//gphoto:access').content = params[:access] if params[:access]
+        doc.at_xpath('//gphoto:location').content = params[:location] if params[:location]
+        doc.at_xpath('//media:keywords').set_attribute("value", params[:keywords]) if params[:keywords]
+        doc.to_xml
+      end
+      
+      def self.albums_headers auth_token, opts = {}
+        headers = {}
+        headers["Content-Type"] = "application/atom+xml"
+        
+        if auth_token and auth_token.length > 0
+          headers["Authorization"] = "GoogleLogin auth=#{auth_token}"
+        end
+        
+        headers.merge opts
+      end
+      
+      def self.albums_uri user_id
+        URI.parse "http://picasaweb.google.com/data/feed/api/user/#{user_id}"
+      end
+      
+      def self.album_uri user_id, album_id
+        URI.parse "http://picasaweb.google.com/data/entry/api/user/#{user_id}/albumid/#{album_id}"
+      end
+      
+    end
+  end
+end

data/lib/picasa/http/authentication.rb

@@ -0,0 +1,40 @@
+# Module that offers methods to do the basic HTTP requests to authenticate user
+# for Picasa.
+
+module Picasa
+  module HTTP
+    module Authentication
+      
+      HTTPS_PORT = 443
+      
+      PICASA_SERVICE = 'lh2'
+      APP_NAME = 'BandManager'
+      
+      # Do a post request to authenticate user with the e-mail and password provided
+      # and return the response and data of the request
+      
+      def self.authenticate email, password
+        uri = uri_login
+        
+        http = Net::HTTP.new(uri.host, HTTPS_PORT)
+        http.use_ssl=true
+
+        data = login_data email, password
+        
+        headers = {'Content-Type' => 'application/x-www-form-urlencoded'}
+        resp, data = http.post(uri.path, data, headers)
+      end
+      
+      private 
+        
+      def self.login_data email, password
+        "accountType=HOSTED_OR_GOOGLE&Email=#{email}&Passwd=#{password}&service=#{PICASA_SERVICE}&source=#{APP_NAME}"
+      end
+      
+      def self.uri_login
+        URI.parse "http://www.google.com/accounts/ClientLogin"
+      end  
+    end
+  end
+end
+