google_client 0.1.0

data/lib/google_client/contact.rb

@@ -0,0 +1,56 @@
+module GoogleClient
+
+  class Contact
+
+    attr_reader   :id
+    attr_accessor :name
+    attr_accessor :email
+    attr_accessor :phone_number
+    attr_accessor :user
+
+    def initialize(params = {})
+      @id = params[:id]
+      @name = params[:name]
+      @email = params[:email]
+      @phone_number = params[:phone_number]
+      @user = params[:user]
+    end
+
+    def to_s
+      "#{self.class.name} => { name: #{@name}, email: #{@email}, :phone_number => #{@phone_number} }"
+    end
+
+
+    def save
+
+    end
+
+    class << self
+      def build_contact(data, user = nil)
+        id = begin
+          data["id"]["$t"].split("base/").last
+        rescue
+          nil
+        end
+        name = begin
+          data["title"]["$t"].split("full/").last
+        rescue
+          ""
+        end
+        email = begin
+          data["gd$email"].collect { |address| address.select { |item| item["address"] }.values }.flatten
+        rescue
+          []
+        end
+        phone_number = begin
+          data["gd$phoneNumber"].collect { |number| number.select { |item| item["$t"] }.values }.flatten
+        rescue
+          []
+        end
+        Contact.new({:name => name, :email => email, :phone_number => phone_number, :user => user})
+      end
+    end
+
+  end
+
+end

data/lib/google_client/engine.rb

@@ -0,0 +1,39 @@
+require 'rails'
+require 'ostruct'
+
+module GoogleClient
+  #
+  # This class defines the GoogleClient Rails Engine to handle OAuth authentication.
+  # The Engine defines two new routes to handle each of the OAuth steps
+  # 1.- forward the user request to Google server
+  # 2.- get the oauth code, request a valid access token and forward the token info to a user defined action
+  #
+  # How to configure GoogleClient Engine
+  #
+  # :uri => Google API endpoint 
+  # :client_id => token that identifies your application in OAuth mechanism
+  # :client_secret => token that secures your communication in OAuth mechanism
+  # :forward_action => controller#action where google_client#code action will redirect the user token data:
+  #           - :access_token
+  #           - :expires_in
+  #           - :refresh_token
+  #
+  # These configuration can be included in an application initializer, i.e. config/initializers/google_client.rb
+  #
+  #      Rails.application.config.google_client.client_id = "<client_id>"
+  #      Rails.application.config.google_client.client_secret = "<client_secret"
+  #      Rails.application.config.google_client.forward_action = "controller#action" that will receive the user token data
+  #
+  
+  class Engine < Rails::Engine
+    
+    # we need to create the hashblue config hash before loading the application initializer
+    initializer :google_client, {:before => :load_config_initializers} do |app|
+
+      app.config.google_client = OpenStruct.new
+      # HashBlue API endpoint
+      app.config.google_client.uri = "https://www.google.com"
+    end
+    
+  end
+end

data/lib/google_client/error.rb

@@ -0,0 +1,13 @@
+module GoogleClient
+
+  Error = Class.new StandardError
+  
+  NotFoundError = Class.new Error
+
+  AuthenticationError = Class.new Error
+
+  BadRequestError = Class.new Error
+
+  ConflictError = Class.new Error
+
+end

data/lib/google_client/event.rb

@@ -0,0 +1,135 @@
+module GoogleClient
+  class Event
+
+    include Format
+
+    attr_reader :id
+    attr_accessor :calendar_id
+    attr_accessor :calendar
+    attr_accessor :title
+    attr_accessor :description
+    attr_accessor :attendees
+    attr_accessor :start_time
+    attr_accessor :end_time
+    attr_accessor :location
+    attr_accessor :attendees
+    attr_accessor :comments
+
+    def initialize(params = {})
+      @id = params[:event_id] || params[:id] || nil
+      @title = params[:title]
+      @description = params[:description]
+      @location = params[:location]
+      @start_time = params[:start_time]
+      @end_time = params[:end_time]
+      @calendar_id = params[:calendar_id]
+      @calendar = params[:calendar]
+      @comments = params[:comments]
+      @attendees = params[:attendees]
+
+      @calendar.nil? or @connection = @calendar.connection
+      @json_mode = true
+      block_given? and yield self
+    end
+
+    def to_s
+      "#{self.class.name} => { id: #{@id}, title: #{@title}, description: #{@description}, :start_time => #{@start_time}, :end_time => #{@end_time}, :location => #{@location}, :attendees => #{@attendees} }"
+    end
+
+    def to_hash
+      {
+        :title => @title,
+        :details => @description,
+        :timeZone => @timezone,
+        :when => [{:start => @start_time,
+          :end => @end_time}]
+      }.delete_if{|k,v| v.nil?}
+    end
+
+
+    def connection
+      @connection or raise RuntimeError.new "Http connection not established"
+    end
+
+    ##
+    # Save the Event in the server
+    # ==== Return
+    # * *Event* instance
+    def save
+      if @id.nil?
+        data = decode_response connection.post("/calendar/feeds/#{calendar}/private/full", {:data => self.to_hash})
+        @id = data["data"]["id"]
+      else
+        # put
+      end
+      self
+    end
+
+    def calendar
+      calendar= if @calendar.nil?
+        if @calendar_id.nil?
+          raise Error.new "Event must be associated to a calendar"
+        else
+          @calendar_id
+        end
+      else
+        @calendar.id
+      end
+    end
+
+    ##
+    # Delete the Event from the server
+    # ==== Return
+    # * *true* if sucessful
+    # * raise Error if failure
+    def delete
+      @id.nil? and raise Error.new "event cannot be deleted if has not an unique identifier"
+      connection.delete "/calendar/feeds/#{calendar}/private/full/#{@id}", nil,  {"If-Match" => "*"}
+      true
+    end
+
+    ##
+    # Fetch the specific event from Google Calendar
+    # ==== Return
+    # * *Event*
+    def fetch
+      if @calendar_id.nil?
+        @calendar.nil? and raise Error.new "calendar or calendar_id must be valid in the event"
+        @calendar_id = @calendar.id
+      end
+      data = connection.get "/calendar/feeds/#{@calendar_id}/private/full/#{@id}"
+      self.class.build_event data["entry"], @calendar
+    end
+
+    class << self
+
+      def create(params)
+        event = if block_given?
+          new(params, &Proc.new)
+        else
+          new(params)
+        end
+      end
+
+      def build_event(data, calendar = nil)
+        attendees = data["gd$who"]
+        attendees.nil? or attendees = attendees.map{|attendee| {:name => attendee["valueString"], :email => attendee["email"]}}
+
+        start_time = data["gd$when"][0]["startTime"]
+        end_time = data["gd$when"][0]["endTime"]
+
+        Event.new({:id => data["id"]["$t"].split("full/").last, 
+                    :calendar => calendar, 
+                    :title => data["title"]["$t"],
+                    :description => data["content"]["$t"],
+                    :location => data["gd$where"][0]["valueString"],
+                    :comments => data["gd$comments"],
+                    :attendees => attendees,
+                    :start_time => start_time,
+                    :end_time =>  end_time})
+      end
+    end
+
+  end
+
+end

data/lib/google_client/format.rb

@@ -0,0 +1,19 @@
+module GoogleClient
+
+  module Format
+
+    def decode_response(response)
+      response = if json?
+        JSON.parse(response.body)
+      else
+        raise Error.new "Unknow data format"
+      end
+    end
+
+    def json?
+      defined? @json_mode and return @json_mode
+      raise Error.new "Unknown data format"
+    end
+
+  end
+end

data/lib/google_client/http_connection.rb

@@ -0,0 +1,113 @@
+require 'rest-client'
+require 'addressable/uri'
+
+module GoogleClient
+  class HttpConnection
+    
+    attr_accessor :headers
+    attr_accessor :access_token
+    attr_accessor :query_params
+    attr_accessor :headers
+
+    def initialize(uri, query_params = {}, headers = {})
+      @headers = headers
+      uri = URI.parse(uri)
+      @host = uri.host
+      @port = uri.port
+      @scheme = uri.scheme
+      @query_params = query_params
+      @headers = headers
+    end
+
+    ##
+    # Http::GET request
+    #
+    # ==== Parameters
+    # * *path* URI path 
+    # * *query_params* query parameters to be added to the request
+    #
+    # ==== Return
+    # * Hash JSON decoded response
+    def get(path, query_params = {}, headers = {})
+      uri = create_uri(path, self.query_params.merge(query_params))
+      RestClient.get(uri.to_s, self.headers.merge(headers)) do |response, request, result, &block|
+        handle_response(response, request, result, &block)
+      end
+    end
+
+    def post(path, body = {}, headers = {})
+      uri = create_uri(path, {})
+
+      _headers = self.headers.merge(headers)
+      if _headers.has_key?("Content-Type") && _headers["Content-Type"].eql?("json")
+        body.is_a?(Hash) and body = body.to_json
+      end
+      RestClient.post(uri.to_s, body, _headers) do |response, request, result, &block|
+        handle_response(response, request, result, &block)
+      end
+    end
+
+    def delete(path, query_params = {}, headers = {})
+      uri = create_uri(path, {})
+      uri = uri.to_s[0..-2]
+      RestClient.delete(uri.to_s, headers.merge({:Authorization => self.headers[:Authorization]})) do |response, request, result, &block|
+        handle_response(response, request, result, &block)
+      end
+    end
+
+    def create_uri(path, query_params = {})
+      Addressable::URI.new({:host => @host, 
+                                  :port => @port, 
+                                  :scheme => @scheme, 
+                                  :path => path,
+                                  :query => create_query(query_params)})
+    end
+
+    private
+
+    ##
+    # This method is used to handle the HTTP response
+    # ==== Parameters
+    # *response* HTTP response
+    # *request* HTTP request
+    # *result*
+    def handle_response(response, request, result, &block)
+      case response.code
+      when 200..207
+        response.return!(request, result, &block)
+      when 301..307
+        response.follow_redirection(request, result, &block)
+      when 400
+        raise BadRequestError.new(result.body)
+      when 401
+        raise AuthenticationError.new(result.body)
+      when 404
+        raise NotFoundError.new(result.body)
+      when 409
+        raise ConflictError.new(result.body)
+      when 422
+        raise Error.new(result.body)
+      when 402..408,410..421,423..499
+        response.return!(request, result, &block)
+      when 500..599
+        raise Error.new(result.body)
+      else
+        response.return!(request, result, &block)
+      end
+    end
+
+    ##
+    # ==== Parameters
+    # * *query_params* query parameters to be added to the request
+    #
+    # ==== Return
+    # * String with the parameters concatened and escaped using CGI.escape
+    def create_query(query_params)
+      query_params.map do |k, v| 
+        "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}"
+      end.join("&")
+    end
+
+  end
+
+end

data/lib/google_client/profile.rb

@@ -0,0 +1,15 @@
+module GoogleClient
+  class Profile
+    attr_accessor :email
+    attr_accessor :external_id
+
+    def initialize(params ={})
+      @email = params[:email]
+      @external_id = params[:external_id]
+    end
+
+    def to_s
+      "#{self.class.name} => { email: #{@email}, external_id: #{@external_id} }"
+    end
+  end
+end

data/lib/google_client/user.rb

@@ -0,0 +1,130 @@
+module GoogleClient
+  class User
+
+    attr_accessor :oauth_credentials
+    attr_accessor :json_mode
+
+    include Format
+
+    def initialize(oauth_credentials, user_credentials = nil)
+      @oauth_credentials = oauth_credentials
+      @json_mode = true
+    end
+
+    # Get user profile
+    #
+    # ==== Return
+    # * Profile instance
+    def profile
+      data = decode_response http.get "/m8/feeds/contacts/default/full", {"max-results" => 1}
+      email = data["feed"]["id"]["$t"]
+      Profile.new({:email => email, :external_id => email.split("@").first})
+    rescue
+      Profile.new
+    end
+
+    # Refresh an invalid access_token
+    # ==== Parameters
+    # * *refresh_token*
+    # * *client_id*
+    # * *client_secret*
+    #
+    # ==== Return
+    # * Hash with the following keys:
+    #   * access_token
+    #   * token_type
+    #   * expires_in
+    # * BadRequestError if invalid refresh token or invalid client
+    def refresh refresh_token, client_id, client_secret
+      _params = {
+        :client_id => client_id,
+        :client_secret => client_secret,
+        :refresh_token => refresh_token,
+        :grant_type => "refresh_token"
+      }
+      data = HttpConnection.new("https://accounts.google.com", 
+                                    {:alt => "json"}, 
+                                    {:Authorization => "OAuth #{oauth_credentials}",
+                                     "Content-Type" => "application/x-www-form-urlencoded",
+                                     :Accept => "application/json"}).post "/o/oauth2/token", _params
+      decode_response data.body
+    end
+
+    # Same as refresh method, but also updates the oauth_credentials variable with the new granted token
+    def refresh! refresh_token, client_id, client_secret
+      data = refresh refresh_token, client_id, client_secret
+      @oauth_credentials = data["access_token"]
+      data
+    end
+
+    ##
+    # 
+    # ==== Parameters
+    # * *calendar_id* Calendar unique identifier
+    #
+    # ==== Return
+    # * *Calendar* instance
+    # * *Array of Calendar* instances
+    def calendar(calendar_id = :all)
+      calendars = if calendar_id.nil? || calendar_id.eql?(:all)
+        calendars = decode_response http.get "/calendar/feeds/default/allcalendars/full"
+        calendars = calendars["feed"]["entry"]
+        calendars.map{ |calendar| Calendar.build_calendar(calendar, self)}
+      elsif calendar_id.eql?(:own)
+        calendars = decode_response http.get "/calendar/feeds/default/owncalendars/full"
+        calendars = calendars["feed"]["entry"]
+        calendars.map{ |calendar| Calendar.build_calendar(calendar, self)}
+      elsif calendar_id.is_a?(String)
+        Calendar.new({:id => calendar_id, :user => self}).fetch
+      elsif calendar_id.is_a?(Hash)
+        # TODO add support to {:title => calendar_title}
+        raise ArgumentError.new "Invalid argument type #{calendar_id.class}"
+      else
+        raise ArgumentError.new "Invalid argument type #{calendar_id.class}"
+      end
+    end
+
+    # Create a calendar
+    #
+    # ==== Parameters
+    # * *params* Hash
+    #   * :title
+    #   * :details
+    #   * :timezone
+    #   * :location
+    #
+    # ==== Return
+    # Calendar instance
+    def create_calendar(params)
+      calendar = if block_given?
+                    Calendar.create(params.merge({:user => self}), &Proc.new)
+                  else
+                    Calendar.create(params.merge({:user => self}))
+                  end
+      calendar.save
+    end
+
+    # Fetch user contacts
+    def contacts
+      contacts = decode_response http.get "/m8/feeds/contacts/default/full", {"max-results" => "1000"}
+      contacts = contacts["feed"]["entry"]
+      contacts.map{|contact| Contact.build_contact(contact, self)}
+    end
+
+    ##
+    # Method that creates and returns the HttpConnection instance that shall be used
+    #
+    # ==== Return
+    # * *HttpConnection* instance
+    def http
+      @http ||= HttpConnection.new("https://www.google.com", 
+                                    {:alt => "json"}, 
+                                    {:Authorization => "OAuth #{oauth_credentials}",
+                                     "Content-Type" => "json",
+                                     :Accept => "application/json"})
+    end
+
+    alias :connection :http
+
+  end
+end