gcalapi 0.0.4 → 0.1.0

data/lib/googlecalendar/auth_sub_util.rb

@@ -0,0 +1,143 @@
+require "cgi"
+require "uri"
+require "net/http"
+require "net/https"
+
+module GoogleCalendar
+
+  #
+  # Exception about AuthSub
+  #
+  class AuthSubFailed < StandardError
+    attr_accessor :http_response
+    def initialize(res)
+      http_response = res
+    end
+  end
+  #
+  # = Summary
+  # Helper class for AuthSub authentication.
+  # For detail, see http://code.google.com/apis/accounts/AuthForWebApps.html
+  # Currently, this class is available for only unregistered website.
+  #
+  # = How to use this class
+  #
+  # == Show AuthSubRequest link to a user.
+  #
+  #    First, you need to show your user an anchor to the AuthSubRequest. The user can get authentication token 
+  #    in the page. And the user will redirect back to your Website with authentication token.
+  #
+  #    request_url = AuthSubUtil.build_request_url(next_url, AuthSubUtil::CALENDAR_SCOPE, use_secure, use_session)
+  #
+  # == Get token from redirected URL.
+  #
+  #    The redirected URL string contains one time session token. You can get the token using get_one_time_token method.
+  #
+  #    token = AuthSubUtil.get_one_time_token(urlstr)
+  #
+  # == Get session token.
+  #
+  #    You will get an one time token above process. Then you can get longtime living sessin token.
+  #
+  #    session = AuthSubUtil.exchange_session_token(one_time_token)
+  #
+  # == make a ServiceAuthSub instance instead of Service.
+  #
+  #    srv = GoogleCalendar::ServiceAuthSub.new(session_token)
+  #
+  # == Revoke session token.
+  #
+  #    Google limits the number of session token per user. So you should revoke the session token after using.
+  #
+  #    AuthSubUtil.revoke_session_token(session_token)
+  #
+  class AuthSubUtil
+    REQUEST_URL = "https://www.google.com/accounts/AuthSubRequest"
+    SESSION_URL = "https://www.google.com/accounts/AuthSubSessionToken"
+    REVOKE_URL  = "https://www.google.com/accounts/AuthSubRevokeToken"
+    INFO_URL = "https://www.google.com/accounts/AuthSubTokenInfo"
+
+    CALENDAR_SCOPE = "http://www.google.com/calendar/feeds/"
+    
+    #
+    # Build url for AuthSubRequest.
+    # http://code.google.com/apis/accounts/AuthForWebApps.html#AuthSubRequest
+    # Currently, secure token is not implemented.
+    #
+    def self.build_request_url(next_url, scope, use_secure, use_session)
+      hq = [["next", next_url], 
+            ["scope", CALENDAR_SCOPE], 
+            ["secure", use_secure ? "1" : "0"], 
+            ["session", use_session ? "1" : "0"]]
+      query = hq.map do |elem| "#{elem[0]}=#{CGI.escape(elem[1])}" end.join("&")
+      return "#{REQUEST_URL}?#{query}"
+    end
+    
+    #
+    # Get authentication token from the redirected url.
+    # When the AuthSubRequest is accepted, the edirected URL string (specified in next_url parameter of 
+    # build_reque4st_url method) contains authentication token. This method retrieves the token from url string.
+    # This token is for a single use only. To get long-lived token, use exchange_session_token method.
+    #
+    def self.get_one_time_token(url_str)
+      uri = URI.parse(url_str)
+      params = CGI.parse(uri.query)
+      throw AuthSubFailed, "Token is not found" unless params.key?("token")
+      return params["token"][0]
+    end
+    
+    #
+    # Get session token. 
+    # The authentication token you get by calling AuthSubRequest is available only once. 
+    # To get long-lived token, use this.
+    # For detail, see http://code.google.com/apis/accounts/AuthForWebApps.html#AuthSubSessionToken
+    #
+    def self.exchange_session_token(one_time_token)
+      res = do_get_with_ssl(SESSION_URL, one_time_token)
+      throw AuthSubFailed.new(res) unless res.code == "200"
+      session_token = nil
+      if /Token=(.*)$/ =~ res.body 
+        session_token = $1.to_s 
+      else
+        throw AuthSubFailed.new(res), "Token not found"
+      end
+      return session_token
+    end
+    
+    #
+    # You can get session token by calling exchange_session_token method. Session token will remain
+    # until you revoke.
+    # For detail, http://code.google.com/apis/accounts/AuthForWebApps.html#AuthSubRevokeToken
+    #
+    def self.revoke_session_token(session_token)
+      res = do_get_with_ssl(REVOKE_URL, session_token)
+      throw AuthSubFailed.new(res) unless res.code == "200"
+      return res
+    end
+    
+    
+    def self.token_info(session_token)
+      res = do_get_with_ssl(INFO_URL, session_token)
+      throw AuthSubFailed.new(res), res.to_s unless res.code == "200"
+      ret = {}
+      res.body.each_line do |line|
+        ret[$1] = $2  if line =~ /^([^=]+)=(.+)$/
+      end
+      return ret
+    end
+    
+    private 
+    
+    def self.do_get_with_ssl(str_uri, token)
+      res = nil
+      uri = URI.parse(str_uri)
+      https = Net::HTTP.new(uri.host, uri.port)
+      https.use_ssl = true
+      https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      https.start do |http|
+        res = http.get(uri.path, {"Authorization" => "AuthSub token=\"#{token}\""})
+      end
+      return res
+    end
+  end # AuthSubUtil
+end # GoogleCalendar

data/lib/googlecalendar/calendar.rb

@@ -2,8 +2,14 @@ require "googlecalendar/service"
 require "googlecalendar/event"
 require "rexml/document"
 
+#
+# = SUMMARY
+# google calendar api for ruby
+#
 module GoogleCalendar
   class InvalidCalendarURL < StandardError; end #:nodoc: all
+
+  #
   # = SUMMARY
   #   This class represents User's Calendar.
   # 
@@ -22,47 +28,14 @@ module GoogleCalendar
   #    srv = GoogleCalendar::Service.new(MAIL, PASS)
   #    cal = Calendar.new(srv, FEED)
   #
-  class Calendar
-
-    #
-    # get user's calendar list.
-    #
-    def self.calendars(srv)
-      ret = srv.calendar_list
-      list = REXML::Document.new(ret.body)
-      h = {}
-      list.root.elements.each("entry/link") do |e|
-        if e.attributes["rel"] == "alternate"
-          feed = e.attributes["href"]
-          h[feed] = Calendar.new(srv, feed)
-        end
-      end
-      h
-    end
 
-    #
-    # defines calendar's readonly attributes
-    #
-    ATTRIBUTES = {
-      "updated" => ["updated"], 
-      "title" => ["title"], 
-      "subtitle" => ["subtitle"], 
-      "name" => ["author/name"], 
-      "email" => ["author/email"], 
-      "timezone" => ["gCal:timezone", "value"],
-      "where" => ["gd:where", "valueString"]}.each do |key, val|
-      module_eval(
-        "def #{key}; self.source.root.elements[\"#{val[0]}\"]." + 
-        (val.length == 1 ? "text" : "attributes[\"#{val[1]}\"]") +
-        "; end"
-      )
-    end
+  class Calendar
 
     attr_reader :feed
 
     # srv: GoogleCalendar::Service object
-    # feed: Calendar's editable feed url
-    def initialize(srv, feed)
+    # feed: Calendar's editable feed url(default value: user's default calendar)
+    def initialize(srv, feed = DEFAULT_CALENDAR_FEED)
       @srv = srv
       @feed = feed
       @source = nil
@@ -112,6 +85,45 @@ module GoogleCalendar
       raise InvalidCalendarURL, ret.inspect unless ret.code == "200"
       REXML::Document.new(ret.body)
     end
+
+    public
+    
+    DEFAULT_CALENDAR_FEED = "http://www.google.com/calendar/feeds/default/private/full"
+    #
+    # get user's calendar list.
+    #
+    def self.calendars(srv)
+      ret = srv.calendar_list
+      list = REXML::Document.new(ret.body)
+      h = {}
+      list.root.elements.each("entry/link") do |e|
+        if e.attributes["rel"] == "alternate"
+          feed = e.attributes["href"]
+          h[feed] = Calendar.new(srv, feed)
+        end
+      end
+      h
+    end
+
+    #
+    # defines calendar's readonly attributes
+    #
+    ATTRIBUTES = {
+      "updated" => ["updated"], 
+      "title" => ["title"], 
+      "subtitle" => ["subtitle"], 
+      "name" => ["author/name"], 
+      "email" => ["author/email"], 
+      "timezone" => ["gCal:timezone", "value"],
+      "where" => ["gd:where", "valueString"]}.each do |key, val|
+      module_eval(
+        "def #{key}; self.source.root.elements[\"#{val[0]}\"]." + 
+        (val.length == 1 ? "text" : "attributes[\"#{val[1]}\"]") +
+        "; end"
+      )
+    end
+
   end # class Calendar
+
 end # module
 

data/lib/googlecalendar/event.rb

@@ -6,6 +6,7 @@ module GoogleCalendar
   class EventInsertFailed < StandardError; end #:nodoc: all
   class EventUpdateFailed < StandardError; end #:nodoc: all
   class EventDeleteFailed < StandardError; end #:nodoc: all
+  class EventGetFailed < StandardError; end #:nodoc: all
 
   #
   # = Summary
@@ -16,6 +17,8 @@ module GoogleCalendar
   # * MAIL: your gmail account.
   # * PASS: password for MAIL.
   # * FEED: a calendar's editable feed url.
+  #   0. your default calendar's feed url is defined in Calendar::DEFAULT_CALENDAR_FEED. 
+  #      To get other calendar's feed url, read below.
   #   1. click "Manage Calendars" in Google Calendar.
   #   2. select a calendar you want to edit.
   #   3. copy private address of XML.
@@ -70,6 +73,10 @@ module GoogleCalendar
   #    event.allday = true
   #    event.save!
   #    
+  # == get existint event
+  #
+  #    event = Event.get(FEED, Service.new(MAIL, PASS))
+  #
   # = TODO
   #
   # * this class doesn't support recurring event.
@@ -156,6 +163,15 @@ XML
       @xml.to_s
     end
   
+    # get event from event feed
+    def self.get(feed, srv)
+      ret = srv.query(feed)
+      raise EventGetFailed, ret.body unless ret.code == "200"
+      evt = Event.new
+      evt.srv = srv
+      evt.load_xml(ret.body)
+      evt
+    end
     private
 
     def do_without_exception(method)
@@ -268,16 +284,5 @@ XML
       end
       ret
     end
-
-    # convert string to numeric character reference
-    def num_char_ref(str)
-      str.to_s.split(//u).map do |c|
-        if /[[:alnum:][:space:][:punct:]]/.match(c) then
-          c
-        else 
-          "&##{c.unpack('U*')[0]};"
-        end
-      end.join
-    end
   end #class Event
 end #module GoogleCalendar

data/lib/googlecalendar/service.rb

@@ -1,23 +1,12 @@
-require "cgi"
-require "uri"
-require "net/http"
-require "net/https"
-require "open-uri"
-require "nkf"
-require "time"
-
-Net::HTTP.version_1_2
+require "googlecalendar/service_base"
 
 module GoogleCalendar
-
-  class AuthenticationFailed < StandardError; end #:nodoc: all
-
   #
-  # This class interacts with google calendar service.
+  # This class interacts with google calendar service. 
+  # If you want to use ClientLogin for authentication, use this class.
+  # If you want to use AuthSub, use ServiceAuthSub. 
   #
-  class Service
-    # Server name to Authenticate
-    AUTH_SERVER = "www.google.com"
+  class Service < ServiceBase
 
     # Server Path to authenticate
     AUTH_PATH = "/accounts/ClientLogin"
@@ -25,192 +14,53 @@ module GoogleCalendar
     # URL to get calendar list
     CALENDAR_LIST_PATH = "http://www.google.com/calendar/feeds/"
   
-    # proxy server address
-    @@proxy_addr = nil
-    def self.proxy_addr
-      @@proxy_addr
-    end
-
-    def self.proxy_addr=(addr)
-      @@proxy_addr=addr
-    end
-
-    # proxy server port number
-    @@proxy_port = nil
-    def self.proxy_port
-      @@proxy_port
-    end
-
-    def self.proxy_port=(port)
-      @@proxy_port = port
-    end
-
-    # proxy server username
-    @@proxy_user = nil
-    def self.proxy_user
-      @@proxy_user
-    end
-
-    def self.proxy_user=(user)
-      @@proxy_user = user
-    end
-
-    # proxy server password
-    @@proxy_pass = nil
-    def self.proxy_pass
-      @@proxy_pass
-    end
-
-    def self.proxy_pass=(pass)
-      @@proxy_pass = pass
-    end
-
-    
-    def initialize(email, pass)
-      @email = email
-      @pass = pass
-      @session = nil
-      @cookie = nil
-      @auth = nil
-    end 
-  
     #
     # get the list of user's calendars and returns http response object
     #
     def calendar_list
+      logger.info("-- calendar list st --") if logger
       auth unless @auth
       uri = URI.parse(CALENDAR_LIST_PATH + @email)
-      do_get(uri, "Authorization" =>  "GoogleLogin auth=#{@auth}")
+      res = do_get(uri, {})
+      logger.info("-- calendar list en(#{res.message}) --") if logger
+      res
     end
 
     alias :calendars :calendar_list
   
-    #
-    # send query for events of a calendar and returns http response object.
-    # available condtions are 
-    # * :q => query string
-    # * :max-results => max contents count. (default: 25)
-    # * :start-index => 1-based index of the first result to be retrieved
-    # * :orderby => the order of retrieved data.
-    # * :published-min => Bounds on the entry publication date(oldest)
-    # * :published-max => Bounds on the entry publication date(newest)
-    # * :updated-min => Bounds on the entry update date(oldest)
-    # * :updated-max => Bounds on the entry update date(newest)
-    # * :author => Entry author
-    #
-    # For detail, see http://code.google.com/apis/gdata/protocol.html#Queries
-    #
-    def query(cal_url, conditions)
-      auth unless @auth
-      uri = URI.parse(cal_url)
-      uri.query = conditions.map do |key, val|
-        "#{key}=#{URI.escape(val.kind_of?(Time) ? val.getutc.iso8601 : val.to_s)}"
-      end.join("&")
-      do_get(uri, "Authorization" =>  "GoogleLogin auth=#{@auth}")
-    end
-  
-    #
-    # delete an event.
-    #
-    def delete(feed)
-      auth unless @auth
-      uri = URI.parse(feed)
-      do_post(uri, 
-              {"X-HTTP-Method-Override" => "DELETE", 
-               "Authorization" =>  "GoogleLogin auth=#{@auth}"}, 
-               "DELETE " + uri.path)
-    end
-    
-    #
-    # insert an event
-    #
-    def insert(feed, event)
-      auth unless @auth
-      uri = URI.parse(feed)
-      do_post(uri, 
-              {"Authorization" =>  "GoogleLogin auth=#{@auth}",
-               "Content-Type" => "application/atom+xml",
-               "Content-Length" => event.length.to_s}, event)
-    end
-  
-    #
-    # update an event.
-    #
-    def update(feed, event)
-      auth unless @auth
-      uri = URI.parse(feed)
-      do_post(uri, 
-              {"X-HTTP-Method-Override" => "PUT", 
-               "Authorization" =>  "GoogleLogin auth=#{@auth}", 
-               "Content-Type" => "application/atom+xml",
-               "Content-Length" => event.length.to_s}, event)
-    end
-    
-    private 
-  
-    # authencate
+    def initialize(email, pass)
+      @email = email
+      @pass = pass
+      @session = nil
+      @cookie = nil
+      @auth = nil
+    end 
+
+  private 
     def auth
       https = Net::HTTP.new(AUTH_SERVER, 443, @@proxy_addr, @@proxy_port, @@proxy_user, @@proxy_pass)
       https.use_ssl = true
       https.verify_mode = OpenSSL::SSL::VERIFY_NONE
       head = {'Content-Type' => 'application/x-www-form-urlencoded'}
+      logger.info "-- auth st --" if logger
       https.start do |w|
         res = w.post(AUTH_PATH, "Email=#{@email}&Passwd=#{@pass}&source=company-app-1&service=cl", head)
+        logger.debug res if logger
         if res.body =~ /Auth=(.+)/
           @auth = $1 
         else
-          raise AuthenticationFailed
-        end
-      end
-    end
-    
-    def do_post(uri, header, content)
-      res = nil
-      try_http(uri, header, content) do |http,path,head,args|
-        cont = args[0]
-        res = http.post(path, cont, head) 
-      end
-      res
-    end
-    
-    def do_get(uri, header)
-      res = nil
-      try_http(uri, header) do |http,path,head| 
-        res = http.get(path, head) 
-      end
-      res
-    end
-    
-    def try_http(uri, header, *args)
-      res = nil
-      Net::HTTP.start(uri.host, uri.port, @@proxy_addr, @@proxy_port, @@proxy_user, @@proxy_pass) do |http|
-        header["Cookie"] = @cookie if @cookie
-        res = yield(http, path_with_authorized_query(uri), header, args)
-        if res.code == "302"
-          ck = sess = nil
-          ck = res["set-cookie"] if res.key?("set-cookie")
-          uri = URI.parse(res["location"]) if res.key?("location")
-          if uri && uri.query
-            qr = CGI.parse(uri.query)
-            sess = qr["gsessionid"][0] if qr.key?("gsessionid")
-          end
-          if ck && sess
-            header["Cookie"] = @cookie = ck
-            @session = sess
-            res = yield(http, path_with_authorized_query(uri), header, args)
-          else
-            p res
+          if logger
+            logger.fatal(res)
+            logger.fatal(res.body)
           end
+          raise AuthenticationFailed
         end
       end
-      res
+      logger.info "-- auth en --" if logger
     end
-    
-    def path_with_authorized_query(uri)
-      query = CGI.parse(uri.query.nil? ? "" : uri.query)
-      query["gsessionid"] = [@session] if @session
-      qs = query.map do |k,v| "#{CGI.escape(k)}=#{CGI.escape(v[0])}" end.join("&")
-      qs.empty? ? uri.path : "#{uri.path}?#{qs}"
+  
+    def add_authorize_header(header)
+      header["Authorization"] = "GoogleLogin auth=#{@auth}"
     end
-  end # class Service
-end # module
+  end # Service
+end # GoogleCalendar