gcal4ruby 0.3.1 → 0.5.0

data/lib/gcal4ruby/event.rb

@@ -1,57 +1,106 @@
+# Author:: Mike Reich (mike@seabourneconsulting.com)
+# Copyright:: Copyright (C) 2010 Mike Reich
+# License:: GPL v2
+#--
+# Licensed under the General Public License (GPL), Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#
+# Feel free to use and update, but be sure to contribute your
+# code back to the project and attribute as required by the license.
+#++
+
 require 'gcal4ruby/recurrence'
 
 module GCal4Ruby
-  #The Event Class represents a remote event in calendar. 
+  #The Event Class represents a remote event in calendar
   #
   #=Usage
   #All usages assume a successfully authenticated Service and valid Calendar.
   #1. Create a new Event
-  #    event = Event.new(calendar)
-  #    event.title = "Soccer Game"
-  #    event.start = Time.parse("12-06-2009 at 12:30 PM")
-  #    event.end = Time.parse("12-06-2009 at 1:30 PM")
-  #    event.where = "Merry Playfields"
+  #    event = Event.new(service, {:calendar => cal, :title => "Soccer Game", :start => Time.parse("12-06-2009 at 12:30 PM"), :end => Time.parse("12-06-2009 at 1:30 PM"), :where => "Merry Playfields"})
   #    event.save
   #
-  #2. Find an existing Event
-  #    event = Event.find(cal, "Soccer Game", {:scope => :first})
+  #2. Find an existing Event by title
+  #    event = Event.find(service, {:title => "Soccer Game"})
+  #
+  #3. Find an existing Event by ID
+  #    event = Event.find(service, {:id => event.id})
+  #
+  #4. Find all events containing the search term
+  #    event = Event.find(service, "Soccer Game")
   #
-  #3. Find all events containing the search term
-  #    event = Event.find(cal, "Soccer Game")
+  #5. Find all events on a calendar containing the search term
+  #    event = Event.find(service, "Soccer Game", {:calendar => cal.id})
   #
-  #4. Create a recurring event for every saturday
-  #    event = Event.new(calendar)
+  #6. Find events within a date range
+  #    event = Event.find(service, "Soccer Game", {'start-min' => Time.parse("01/01/2010").utc.xmlschema, 'start-max' => Time.parse("06/01/2010").utc.xmlschema})
+  #
+  #7. Create a recurring event for every saturday
+  #    event = Event.new(service)
   #    event.title = "Baseball Game"
+  #    event.calendar = cal
   #    event.where = "Municipal Stadium"
   #    event.recurrence = Recurrence.new
-  #    event.recurrence.start = Time.parse("13-06-2009 at 4:30 PM")
-  #    event.recurrence.end = Time.parse("13-06-2009 at 6:30 PM")
+  #    event.recurrence.start_time = Time.parse("06/20/2009 at 4:30 PM")
+  #    event.recurrence.end_time = Time.parse("06/20/2009 at 6:30 PM")
   #    event.recurrence.frequency = {"weekly" => ["SA"]}
   #    event.save 
   #
-  #5. Create an event with a 15 minute email reminder
-  #    event = Event.new(calendar)
+  #8. Create an event with a 15 minute email reminder
+  #    event = Event.new(service)
+  #    event.calendar = cal
   #    event.title = "Dinner with Kate"
-  #    event.start = Time.parse("20-06-2009 at 5 pm")
-  #    event.end = Time.parse("20-06-209 at 8 pm")
+  #    event.start_time = Time.parse("06/20/2009 at 5 pm")
+  #    event.end_time = Time.parse("06/20/2009 at 8 pm")
   #    event.where = "Luigi's"
   #    event.reminder = {:minutes => 15, :method => 'email'}
   #    event.save
   #
-  #6. Create an event with attendees
-  #    event = Event.new(calendar)
+  #9. Create an event with attendees
+  #    event = Event.new(service)
+  #    event.calendar = cal
   #    event.title = "Dinner with Kate"
-  #    event.start = Time.parse("20-06-2009 at 5 pm")
-  #    event.end = Time.parse("20-06-209 at 8 pm")
+  #    event.start_time = Time.parse("06/20/2009 at 5 pm")
+  #    event.end_time = Time.parse("06/20/2009 at 8 pm")
   #    event.attendees => {:name => "Kate", :email => "kate@gmail.com"}
   #    event.save
   #
   #After an event object has been created or loaded, you can change any of the 
   #attributes like you would any other object.  Be sure to save the event to write changes
   #to the Google Calendar service.
-  class Event
-    #The event title
-    attr_accessor :title
+  
+  class Event < GData4Ruby::GDataObject
+    EVENT_QUERY_FEED = "http://www.google.com/calendar/feeds/default/private/full/"
+    EVENT_XML = "<entry xmlns='http://www.w3.org/2005/Atom'
+    xmlns:gd='http://schemas.google.com/g/2005'>
+  <category scheme='http://schemas.google.com/g/2005#kind'
+    term='http://schemas.google.com/g/2005#event'></category>
+  <title type='text'></title>
+  <content type='text'></content>
+  <gd:transparency
+    value='http://schemas.google.com/g/2005#event.opaque'>
+  </gd:transparency>
+  <gd:eventStatus
+    value='http://schemas.google.com/g/2005#event.confirmed'>
+  </gd:eventStatus>
+  <gd:where valueString=''></gd:where>
+  <gd:when startTime=''
+    endTime=''></gd:when>
+</entry>"
+    STATUS = {:confirmed => "http://schemas.google.com/g/2005#event.confirmed",
+              :tentative => "http://schemas.google.com/g/2005#event.tentative",
+              :cancelled => "http://schemas.google.com/g/2005#event.canceled"}
+              
+    TRANSPARENCY = {:free => "http://schemas.google.com/g/2005#event.transparent",
+                    :busy => "http://schemas.google.com/g/2005#event.opaque"}
+    
     #The content for the event
     attr_accessor :content
     #The location of the event
@@ -60,33 +109,34 @@ module GCal4Ruby
     attr_accessor :transparency
     #A flag indicating the status of the event.  Values can be :confirmed, :tentative or :cancelled
     attr_accessor :status
-    #The unique event ID
-    attr_accessor :id
     #Flag indicating whether it is an all day event
-    attr_accessor :all_day
-    
-    @attendees
-    
-    #The event start time
-    attr_reader :start
-    #The event end time
-    attr_reader :end
+    attr_reader :all_day    
     #The reminder settings for the event, returned as a hash
     attr_reader :reminder
-    #The date the event was created
-    attr_reader :published
-    #The date the event was last updated
-    attr_reader :updated
     #The date the event was last edited
     attr_reader :edited
+    #Id of the parent calendar
+    attr_reader :calendar_id
+    
+    #Creates a new Event.  Accepts a valid Service object and optional attributes hash.
+    def initialize(service, attributes = {})
+      super(service, attributes)
+      attributes.each do |key, value|
+        self.send("#{key}=", value)
+      end
+      @xml = EVENT_XML
+      @transparency ||= "http://schemas.google.com/g/2005#event.opaque"
+      @status ||= "http://schemas.google.com/g/2005#event.confirmed"
+      @attendees ||= []
+      @all_day ||= false
+      @reminder = []
+      @start_time = @end_time = @calendar_id = nil
+    end
     
-    #Sets the reminder options for the event.  Parameter must be a hash containing one of 
-    #:hours, :minutes and :days, which are simply the number of each before the event start date you'd like to 
-    #receive the reminder.  
-    #
-    #:method can be one of the following:
-    #- <b>'alert'</b>: causes an alert to appear when a user is viewing the calendar in a browser
-    #- <b>'email'</b>: sends the user an email message
+    #Sets the reminder options for the event.  Parameter must be a hash a :minutes key with a value of 5 up to 40320 (4 weeks)
+    #and a :method key of with a value of one the following:
+    #alert:: causes an alert to appear when a user is viewing the calendar in a browser
+    #email:: sends the user an email message
     def reminder=(r)
       @reminder = r
     end
@@ -101,31 +151,36 @@ module GCal4Ruby
       @attendees
     end
     
+    def all_day=(value)
+      puts 'all_day value = '+value.to_s if service.debug
+      if value.is_a? String 
+        @all_day = true if value.downcase == 'true'
+        @all_day = false if value.downcase == 'false'
+      else
+        @all_day = value
+      end
+      puts 'after all_day value = '+@all_day.to_s if service.debug
+      @all_day
+    end
+    
     #Accepts an array of email address/name pairs for attendees.  
     #  [{:name => 'Mike Reich', :email => 'mike@seabourneconsulting.com'}]
     #The email address is requried, but the name is optional
     def attendees=(a)
-      if a.is_a?(Array)
-        @attendees = a
-      else
-        raise "Attendees must be an Array of email/name hash pairs"
-      end
+      raise ArgumentError, "Attendees must be an Array of email/name hash pairs" if not a.is_a?(Array) 
+      @attendees = a
     end
     
     #Sets the event's recurrence information to a Recurrence object.  Returns the recurrence if successful,
     #false otherwise
     def recurrence=(r)
-      if r.is_a?(Recurrence) or r.nil?
-        r.event = self unless r.nil?
-        @recurrence = r
-      else
-        return false
-      end
+      raise ArgumentError, 'Recurrence must be a Recurrence object' if not r.is_a?(Recurrence)
+      @recurrence = r
     end
     
     #Returns a duplicate of the current event as a new Event object
     def copy()
-      e = Event.new()
+      e = Event.new(service)
       e.load(to_xml)
       e.calendar = @calendar
       return e
@@ -133,154 +188,96 @@ module GCal4Ruby
     
     #Sets the start time of the Event.  Must be a Time object or a parsable string representation
     #of a time.
-    def start=(str)
-      if str.is_a?String
-        @start = Time.parse(str)      
+    def start_time=(str)
+      raise ArgumentError, "Start Time must be either Time or String" if not str.is_a?String and not str.is_a?Time
+      @start_time = if str.is_a?String
+        Time.parse(str)      
       elsif str.is_a?Time
-        @start = str
-      else
-        raise "Start Time must be either Time or String"
+        str
       end
     end
     
     #Sets the end time of the Event.  Must be a Time object or a parsable string representation
     #of a time.
-    def end=(str)
-      if str.is_a?String
-        @end = Time.parse(str)      
+    def end_time=(str)
+      raise ArgumentError, "End Time must be either Time or String" if not str.is_a?String and not str.is_a?Time
+      @end_time = if str.is_a?String
+        Time.parse(str)      
       elsif str.is_a?Time
-        @end = str
-      else
-        raise "End Time must be either Time or String"
+        str
       end
     end
     
-    #Deletes the event from the Google Calendar Service.  All values are cleared.
-    def delete
-        if @exists    
-          if @calendar.service.send_delete(@edit_feed, {"If-Match" => @etag})
-            @exists = false
-            @deleted = true
-            @title = nil
-            @content = nil
-            @id = nil
-            @start = nil
-            @end = nil
-            @transparency = nil
-            @status = nil
-            @where = nil
-            return true
-          else
-            return false
-          end
-        else
-          return false
-        end
+    #The event start time.  If a recurring event, the recurrence start time.
+    def start_time
+      return @start_time ? @start_time : @recurrence ? @recurrence .start_time : nil
     end
     
-    #Creates a new Event.  Accepts a valid Calendar object and optional attributes hash.
-    def initialize(calendar, attributes = {})
-      if not calendar.editable
-        raise CalendarNotEditable
-      end
-      super()
-      attributes.each do |key, value|
-        self.send("#{key}=", value)
-      end
-      @xml ||= EVENT_XML
-      @calendar ||= calendar
-      @transparency ||= "http://schemas.google.com/g/2005#event.opaque"
-      @status ||= "http://schemas.google.com/g/2005#event.confirmed"
-      @attendees ||= []
-      @all_day ||= false
+    #The event end time.  If a recurring event, the recurrence end time.
+    def end_time
+      return @end_time ? @end_time : @recurrence ? @recurrence.end_time : nil
     end
+
     
     #If the event does not exist on the Google Calendar service, save creates it.  Otherwise
     #updates the existing event data.  Returns true on success, false otherwise.
     def save
-      if @deleted
-        return false
-      end
-      if @exists 
-        ret = @calendar.service.send_put(@edit_feed, to_xml, {'Content-Type' => 'application/atom+xml', "If-Match" => @etag})
-      else
-        ret = @calendar.service.send_post(@calendar.event_feed, to_xml, {'Content-Type' => 'application/atom+xml'})
-      end
-      if !@exists
-        if load(ret.read_body)
-          return true
-        else
-          raise EventSaveFailed
-        end
-      end
-      reload
-      return true
+      raise CalendarNotEditable if not calendar.editable
+      super
+    end
+    
+    #Creates a new event
+    def create
+      service.send_request(GData4Ruby::Request.new(:post, @parent_calendar.content_uri, to_xml))
     end
     
     #Returns an XML representation of the event.
     def to_xml()
-      xml = REXML::Document.new(@xml)
+      xml = REXML::Document.new(super)
       xml.root.elements.each(){}.map do |ele|
         case ele.name
-        when 'id'
-          ele.text = @id
-        when "title"
-          ele.text = @title
-        when "content"
-          ele.text = @content
-        when "when"
-          if not @recurrence
-            ele.attributes["startTime"] = @all_day ? @start.strftime("%Y-%m-%d") : @start.xmlschema
-            ele.attributes["endTime"] = @all_day ? @end.strftime("%Y-%m-%d") : @end.xmlschema
-            set_reminder(ele)
-          else
-            if not @reminder
-              xml.root.delete_element("/entry/gd:when")
-              xml.root.add_element("gd:recurrence").text = @recurrence.to_s
+          when "content"
+            ele.text = @content
+          when "when"
+            if not @recurrence
+              puts 'all_day = '+@all_day.to_s if service.debug
+              if @all_day
+                puts 'saving as all-day event' if service.debug 
+              else
+                puts 'saving as timed event' if service.debug
+              end
+              ele.attributes["startTime"] = @all_day ? @start_time.strftime("%Y-%m-%d") : @start_time.utc.xmlschema
+              ele.attributes["endTime"] = @all_day ? @end_time.strftime("%Y-%m-%d") : @end_time.utc.xmlschema
+              set_reminder(ele)
             else
-              ele.delete_attribute('startTime')
-              ele.delete_attribute('endTime')
-              set_reminder(ele)  
+              xml.root.delete_element("/entry/gd:when")
+              ele = xml.root.add_element("gd:recurrence")
+              ele.text = @recurrence.to_recurrence_string
+              set_reminder(ele) if @reminder
             end
-          end
-        when "eventStatus"
-          ele.attributes["value"] = case @status
-            when :confirmed
-              "http://schemas.google.com/g/2005#event.confirmed"
-            when :tentative
-              "http://schemas.google.com/g/2005#event.tentative"
-            when :cancelled
-              "http://schemas.google.com/g/2005#event.canceled"
+          when "eventStatus"
+            ele.attributes["value"] = STATUS[@status]
+          when "transparency"
+            ele.attributes["value"] = TRANSPARENCY[@transparency]
+          when "where"
+            ele.attributes["valueString"] = @where
+          when "recurrence"
+            puts 'recurrence element found' if service.debug
+            if @recurrence
+              puts 'setting recurrence' if service.debug
+              ele.text = @recurrence.to_recurrence_string
             else
-              "http://schemas.google.com/g/2005#event.confirmed"
-          end
-        when "transparency"
-          ele.attributes["value"] = case @transparency
-              when :free
-                "http://schemas.google.com/g/2005#event.transparent"
-              when :busy
-                "http://schemas.google.com/g/2005#event.opaque"
-              else
-                "http://schemas.google.com/g/2005#event.opaque"
+              puts 'no recurrence, adding when' if service.debug
+              w = xml.root.add_element("gd:when")
+              xml.root.delete_element("/entry/gd:recurrence")
+              w.attributes["startTime"] = @all_day ? @start_time.strftime("%Y-%m-%d") : @start_time.xmlschema
+              w.attributes["endTime"] = @all_day ? @end_time.strftime("%Y-%m-%d") : @end_time.xmlschema
+              set_reminder(w)
             end
-        when "where"
-          ele.attributes["valueString"] = @where
-        when "recurrence"
-          puts 'recurrence element found' if @calendar.service.debug
-          if @recurrence
-            puts 'setting recurrence' if @calendar.service.debug
-            ele.text = @recurrence.to_s
-          else
-            puts 'no recurrence, adding when' if @calendar.service.debug
-            w = xml.root.add_element("gd:when")
-            xml.root.delete_element("/entry/gd:recurrence")
-            w.attributes["startTime"] = @all_day ? @start.strftime("%Y-%m-%d") : @start.xmlschema
-            w.attributes["endTime"] = @all_day ? @end.strftime("%Y-%m-%d") : @end.xmlschema
-            set_reminder(w)
-          end
         end
       end        
       if not @attendees.empty?
+        xml.root.elements.delete_all "gd:who"
         @attendees.each do |a|
           xml.root.add_element("gd:who", {"email" => a[:email], "valueString" => a[:name], "rel" => "http://schemas.google.com/g/2005#event.attendee"})
         end
@@ -288,166 +285,124 @@ module GCal4Ruby
       xml.to_s
     end
     
+    #The event's parent calendar
+    def calendar 
+      @parent_calendar = Calendar.find(service, {:id => @calendar_id}) if not @parent_calendar and @calendar_id
+      return @parent_calendar
+    end
+    
+    #Sets the event's calendar
+    def calendar=(p)
+      raise ArgumentError, 'Value must be a valid Calendar object' if not p.is_a? Calendar
+      @parent_calendar = p
+    end
+    
     #Loads the event info from an XML string.
     def load(string)
+      super(string)
       @xml = string
       @exists = true
       xml = REXML::Document.new(string)
       @etag = xml.root.attributes['etag']
       xml.root.elements.each(){}.map do |ele|
-          case ele.name
-             when 'updated'
-                @updated = ele.text
-             when 'published'
-                @published = ele.text
-             when 'edited'
-                @edited = ele.text
-             when 'id'
-                @id, @edit_feed = ele.text
-             when 'title'
-                @title = ele.text
-              when 'content'
-                @content = ele.text
-              when "when"
-                @start = Time.parse(ele.attributes['startTime'])
-                @end = Time.parse(ele.attributes['endTime'])
-                ele.elements.each("gd:reminder") do |r|
-                  @reminder = {:minutes => r.attributes['minutes'] ? r.attributes['minutes'] : 0, :hours => r.attributes['hours'] ? r.attributes['hours'] : 0, :days => r.attributes['days'] ? r.attributes['days'] : 0, :method => r.attributes['method'] ? r.attributes['method'] : ''}
-                end
-              when "where"
-                @where = ele.attributes['valueString']
-              when "link"
-                if ele.attributes['rel'] == 'edit'
-                  @edit_feed = ele.attributes['href']
-                end
-              when "who"
-                if ele.attributes['rel'] == "http://schemas.google.com/g/2005#event.attendee"
-                n = {}
-                ele.attributes.each do |name, value|
-                    case name
-                      when "email"
-                        n[:email] = value
-                      when "valueString"
-                        n[:name] = value
-                    end
-                  end                
-               @attendees << n
-               end
-              when "eventStatus"
-              case ele.attributes["value"] 
-                when "http://schemas.google.com/g/2005#event.confirmed"
-                 @status =  :confirmed
-                when "http://schemas.google.com/g/2005#event.tentative"
-                  @status = :tentative
-                when "http://schemas.google.com/g/2005#event.cancelled"
-                  @status = :cancelled
-              end
-            when 'recurrence'
-              @recurrence = Recurrence.new(ele.text)
-            when "transparency"
-               case ele.attributes["value"]
-                  when "http://schemas.google.com/g/2005#event.transparent" 
-                    @transparency = :free
-                  when "http://schemas.google.com/g/2005#event.opaque"
-                    @transparency = :busy
-                end
-            end      
-        end
+        case ele.name
+          when 'id'
+            @calendar_id, @id = @feed_uri.gsub("http://www.google.com/calendar/feeds/", "").split("/events/")
+            @id = "#{@calendar_id}/private/full/#{@id}"
+          when 'edited'
+            @edited = Time.parse(ele.text)
+          when 'content'
+            @content = ele.text
+          when "when"
+            @start_time = Time.parse(ele.attributes['startTime'])
+            @end_time = Time.parse(ele.attributes['endTime'])
+            @all_day = !ele.attributes['startTime'].include?('T')
+            @reminder = []
+            ele.elements.each("gd:reminder") do |r|
+              rem = {}
+              rem[:minutes] = r.attributes['minutes'] if r.attributes['minutes']
+              rem[:method] = r.attributes['method'] if r.attributes['method']
+              @reminder << rem
+            end
+          when "where"
+            @where = ele.attributes['valueString']
+          when "link"
+            if ele.attributes['rel'] == 'edit'
+              @edit_feed = ele.attributes['href']
+            end
+          when "who"        
+            @attendees << {:email => ele.attributes['email'], :name => ele.attributes['valueString'], :role => ele.attributes['rel'].gsub("http://schemas.google.com/g/2005#event.", ""), :status => ele.elements["gd:attendeeStatus"] ? ele.elements["gd:attendeeStatus"].attributes['value'].gsub("http://schemas.google.com/g/2005#event.", "") : ""}
+          when "eventStatus"
+            @status =  ele.attributes["value"].gsub("http://schemas.google.com/g/2005#event.", "").to_sym 
+          when 'recurrence'
+            @recurrence = Recurrence.new(ele.text)
+          when "transparency"
+             @transparency = case ele.attributes["value"]
+                when "http://schemas.google.com/g/2005#event.transparent" then :free
+                when "http://schemas.google.com/g/2005#event.opaque" then :busy
+             end
+        end      
+      end
     end
     
     #Reloads the event data from the Google Calendar Service.  Returns true if successful,
     #false otherwise.
     def reload
-      t = Event.find(@calendar, @id)
-      if t
-        if load(t.to_xml)
+      return false if not @exists
+      t = Event.find(service, {:id => @id})
+      if t and load(t.to_xml)
          return true
-        else
-         return false
-        end
-      else
-        return false
       end
+      return false
     end
     
-    #Finds the event that matches a query term in the event title or description.
-    #  
-    #'query' is a string to perform the search on or an event id.
-    # 
-    #The params hash can contain the following hash values
-    #* *scope*: may be :all or :first, indicating whether to return the first record found or an array of all records that match the query.  Default is :all.
-    #* *range*: a hash including a :start and :end time to constrain the search by
-    #* *max_results*: an integer indicating the number of results to return.  Default is 25.
-    #* *sort_order*: either 'ascending' or 'descending'.
-    #* *single_events*: either 'true' to return all recurring events as a single entry, or 'false' to return all recurring events as a unique event for each recurrence.
-    #* *ctz*: the timezone to return the event times in
-    def self.find(calendar, query = '', params = {})
-      query_string = ''
-      
-      begin 
-        test = URI.parse(query).scheme
-      rescue Exception => e
-        test = nil
-      end
-      
-      if test
-        puts "id passed, finding event by id" if calendar.service.debug
-        puts "id = "+query if calendar.service.debug
-        event_id = query.gsub("/events/","/private/full/") #fix provided by groesser3
-      
-        es = calendar.service.send_get(event_id)
-        puts es.inspect if calendar.service.debug
-        if es
-          entry = REXML::Document.new(es.read_body).root
-          puts 'event found' if calendar.service.debug
-          Event.define_xml_namespaces(entry)
-          event = Event.new(calendar)
-          event.load("<?xml version='1.0' encoding='UTF-8'?>#{entry.to_s}")
-          return event
+    #Finds an Event based on a text query or by an id.  Parameters are:
+    #*service*::  A valid Service object to search.
+    #*query*:: either a string containing a text query to search by, or a hash containing an +id+ key with an associated id to find, or a +query+ key containint a text query to search for, or a +title+ key containing a title to search.  All searches are case insensitive.
+    #*args*:: a hash containing optional additional query paramters to use.  Limit a search to a single calendar by passing the calendar id as {:calendar => calendar.id}.  See here[http://code.google.com/apis/calendar/data/2.0/developers_guide_protocol.html#RetrievingEvents] and here[http://code.google.com/apis/gdata/docs/2.0/reference.html#Queries] for a full list of possible values.  Example: 
+    # {'max-results' => '100'}
+    #If an ID is specified, a single instance of the event is returned if found, otherwise false.
+    #If a query term or title text is specified, and array of matching results is returned, or an empty array if nothing
+    #was found.
+    def self.find(service, query, args = {})
+      raise ArgumentError, 'query must be a hash or string' if not query.is_a? Hash and not query.is_a? String
+      if query.is_a? Hash and query[:id]
+        id = query[:id]
+        puts "id passed, finding event by id" if service.debug
+        puts "id = "+id if service.debug
+        d = service.send_request(GData4Ruby::Request.new(:get, "http://www.google.com/calendar/feeds/"+id, {"If-Not-Match" => "*"}))
+        puts d.inspect if service.debug
+        if d
+          return get_instance(service, d)
         end
-        return nil
-      end
-
-  
-      #parse params hash for values
-      range = params[:range] || nil
-      max_results = params[:max_results] || nil
-      sort_order = params[:sortorder] || nil
-      single_events = params[:singleevents] || nil
-      timezone = params[:ctz] || nil
-      
-      #set up query string
-      query_string += "q=#{CGI.escape(query)}" if query
-      if range
-        if not range.is_a? Hash or (range.size > 0 and (not range[:start].is_a? Time or not range[:end].is_a? Time))
-          raise "The date range must be a hash including the :start and :end date values as Times"
+      else
+        results = []
+        if query.is_a?(Hash)
+          args["q"] = query[:query] if query[:query]
+          args['title'] = query[:title] if query[:title]
         else
-          date_range = ''
-          if range.size > 0
-            #Added via patch from Fabio Inguaggiato
-            query_string += "&start-min=#{CGI::escape(range[:start].xmlschema)}&start-max=#{CGI::escape(range[:end].xmlschema)}"
-          end
+          args["q"] = CGI::escape(query) if query != ''
         end
-      end
-      query_string += "&max-results=#{max_results}" if max_results
-      query_string += "&sortorder=#{sort_order}" if sort_order
-      query_string += "&ctz=#{timezone.gsub(" ", "_")}" if timezone
-      query_string += "&singleevents=#{single_events}" if single_events
-      if query_string
-        events = calendar.service.send_get("http://www.google.com/calendar/feeds/#{calendar.id}/private/full?"+query_string)
-        ret = []
-        REXML::Document.new(events.read_body).root.elements.each("entry"){}.map do |entry|
-          Event.define_xml_namespaces(entry)
-          event = Event.new(calendar)
-          event.load("<?xml version='1.0' encoding='UTF-8'?>#{entry.to_s}")
-          ret << event
+        if args[:calendar]
+          cal = Calendar.find(service, {:id => args[:calendar]})
+          args.delete(:calendar)
+          ret = service.send_request(GData4Ruby::Request.new(:get, cal.content_uri, nil, nil, args))
+          xml = REXML::Document.new(ret.body).root
+          xml.elements.each("entry") do |e|
+            results << get_instance(service, e)
+          end
+        else
+          service.calendars.each do |cal|
+            ret = service.send_request(GData4Ruby::Request.new(:get, cal.content_uri, nil, nil, args))
+            xml = REXML::Document.new(ret.body).root
+            xml.elements.each("entry") do |e|
+              results << get_instance(service, e)
+            end
+          end
         end
+        return results
       end
-      if params[:scope] == :first
-        return ret[0]
-      else
-        return ret
-      end
+      return false
     end
     
     #Returns true if the event exists on the Google Calendar Service.
@@ -455,46 +410,37 @@ module GCal4Ruby
       return @exists
     end
   
-    private 
-    @exists = false
-    @calendar = nil
-    @xml = nil
-    @etag = nil
-    @recurrence = nil
-    @deleted = false
-    @edit_feed = ''
-    
-    def self.define_xml_namespaces(entry)
-      entry.attributes["xmlns:gCal"] = "http://schemas.google.com/gCal/2005"
-      entry.attributes["xmlns:gd"] = "http://schemas.google.com/g/2005"
-      entry.attributes["xmlns:app"] = "http://www.w3.org/2007/app"
-      entry.attributes["xmlns"] = "http://www.w3.org/2005/Atom"
-      entry.attributes["xmlns:georss"] = "http://www.georss.org/georss"
-      entry.attributes["xmlns:gml"] = "http://www.opengis.net/gml"
-    end
-    
+    private     
     def set_reminder(ele)
-      ele.delete_element("gd:reminder")
+      num = ele.elements.delete_all "gd:reminder"
+      puts 'num = '+num.size.to_s if service.debug
       if @reminder
-        e = ele.add_element("gd:reminder")
-        used = false
-        if @reminder[:minutes] 
-          e.attributes['minutes'] = @reminder[:minutes] 
-          used = true
-        elsif @reminder[:hours] and not used
-          e.attributes['hours'] = @reminder[:hours]
-          used = true
-        elsif @reminder[:days] and not used
-          e.attributes['days'] = @reminder[:days]
+        @reminder.each do |reminder|
+          puts 'reminder added' if service.debug
+          e = ele.add_element("gd:reminder")
+          e.attributes['minutes'] = reminder[:minutes].to_s if reminder[:minutes]
+          if reminder[:method] 
+            e.attributes['method'] = reminder[:method]
+          else
+            e.attributes['method'] = 'email'
+          end
         end
-        if @reminder[:method] 
-          e.attributes['method'] = @reminder[:method]
-        else
-          e.attributes['method'] = 'email'
+      end
+    end
+
+    def self.get_instance(service, d)
+      if d.is_a? Net::HTTPOK
+        xml = REXML::Document.new(d.read_body).root
+        if xml.name == 'feed'
+          xml = xml.elements.each("entry"){}[0]
         end
       else
-        ele.delete_element("gd:reminder")
+        xml = d
       end
+      ele = GData4Ruby::Utils::add_namespaces(xml)
+      e = Event.new(service)
+      e.load(ele.to_s)
+      e
     end
   end
 end