agcaldav 0.2.1 → 0.2.2

data/README.md

@@ -27,23 +27,47 @@ Alternatively, the proxy parameters can be specified:
 
     result = cal.create_event(:start => "2012-12-29 10:00", :end => "2012-12-30 12:00", :title => "12345", :description => "sdkvjsdf sdkf sdkfj sdkf dsfj")
 
-Determine Event UID:
+Analyze result:
+    
+    >> result.class
+    => Icalendar::Calendar
+
+    >> result.events.count
+    => 1
+
+    >> result.events.first
+    => #<Icalendar::Event:0x007ff653b47520 @name="VEVENT", @components={}, @properties={"sequence"=>0, "dtstamp"=>#<DateTime: 2012-12-30T19:59:04+00:00 (26527957193/10800,0/1,2299161)>, "description"=>"sdkvjsdf sdkf sdkfj sdkf dsfj", "dtend"=>#<DateTime: 2012-12-30T12:00:00+00:00 (2456292/1,0/1,2299161)>, "dtstart"=>#<DateTime: 2012-12-29T10:00:00+00:00 (29475491/12,0/1,2299161)>, "summary"=>"12345", "uid"=>"e795c480-34e0-0130-7d1d-109add70606c", "x-radicale_name"=>"e795c480-34e0-0130-7d1d-109add70606c.ics"}>
 
-    result[:uid]
+get UID of this Event:
+    >> result.events.first.uid
+    => "e795c480-34e0-0130-7d1d-109add70606c"
 
 
 Find Event:
     
-    r = cal.find_event(result[:uid])
+    r = cal.find_event("e795c480-34e0-0130-7d1d-109add70606c")
+    
+    >> result.class
+    => Icalendar::Calendar
 
 
 Find Events within time interval:
 
     result = cal.find_events(:start => "2012-10-01 08:00", :end => "2013-01-01")
-    #TODO.... (no XML -> Icalendar with multiple events....)
 
 
+####TODO's
+
+###############################################################
+#                                                             #
+#   TODO :                                                    #
+#       1. find and notify if overlapping events              #
+#       2. "create_event" check for UUID is really unique     #
+#       3. errorhandling & code cleanup                       #
+#                                                             #
+###############################################################
 
-... next tomorrow ...
 
+####Licence
 
+ -> MIT

data/lib/agcaldav/client.rb

@@ -1,152 +1,159 @@
 module AgCalDAV
-    class Client
-        include Icalendar
-        attr_accessor :host, :port, :url, :user, :password, :ssl
-
-        def format=( fmt )
-            @format = fmt
-        end
-
-        def format
-            @format ||= Format::Debug.new
-        end
-
-        def initialize( data )                                        
-            unless data[:proxy_uri].nil?
-              proxy_uri   = URI(data[:proxy_uri])
-              @proxy_host = proxy_uri.host 
-              @proxy_port = proxy_uri.port.to_i
-            end
-            uri = URI(data[:uri])
-            @host     = uri.host
-            @port     = uri.port.to_i
-            @url      = uri.path
-            @user     = data[:user]
-            @password = data[:password] 
-            @ssl      = uri.scheme == 'https'            
-        end
-    
-        def __create_http
-          if @proxy_uri.nil?
-            http = Net::HTTP.new(@host, @port)
-          else        
-            http = Net::HTTP.new(@host, @port, @proxy_host, @proxy_port)
-          end
-          if @ssl
-            http.use_ssl = @ssl
-            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-          end
-            http
-        end
-    
-        def find_events data
-            datetime_start = data[:start]
-            datetime_stop  = data[:end]
-            res = nil
-            __create_http.start {|http|
-                req = Net::HTTP::Report.new(@url, initheader = {'Content-Type'=>'application/xml'} )
-                req.basic_auth @user, @password
-                req.body = AgCalDAV::Request::ReportVEVENT.new(DateTime.parse(datetime_start).strftime("%Y%m%dT%H%M"), 
-                                                             DateTime.parse(datetime_stop).strftime("%Y%m%dT%H%M") ).to_xml
-                res = http.request( req )
-            }
-            format.parse_calendar( res.body ) #TODO
-            #result = Icalendar.parse(res.body)            
-        end
-        
-        def find_event uuid
-            res = nil
-            __create_http.start {|http|
-                req = Net::HTTP::Get.new("#{@url}/#{uuid}.ics")
-                req.basic_auth @user, @password
-                res = http.request( req )
-            }
-            #raise AuthenticationError if res.code.to_i == 401
-            #raise APIError if res.code.to_i >= 500
-            result = Icalendar.parse(res.body)
-            result
-        end
-    
-        def delete_event uuid
-          __create_http.start {|http|
-              req = Net::HTTP::Delete.new("#{@url}/#{uuid}.ics")
-              req.basic_auth @user, @password
-              res = http.request( req )
-            }
-        end
-    
-        def create_event event
-          c = Calendar.new
-          uuid = UUID.new.generate
-          c.event do
-            uid           uuid  # still a BUG
-            dtstart       DateTime.parse(event[:start])
-            dtend         DateTime.parse(event[:end])
-            duration      event[:duration]
-            summary       event[:title]
-            description   event[:description]
-            klass         event[:accessibility] #PUBLIC, PRIVATE, CONFIDENTIAL
-            location      event[:location]
-            geo_location  event[:geo_location]
-            status        event[:status]
-          end
-          c.publish
-          c.event.uid = uuid  
-          cstring = c.to_ical
-          res = nil
-          http = Net::HTTP.new(@host, @port) 
-          __create_http.start { |http|
-            req = Net::HTTP::Put.new("#{@url}/#{uuid}.ics")
-            req['Content-Type'] = 'text/calendar'
-            req.basic_auth @user, @password
-            req.body = cstring
-            res = http.request( req )
-          }
-          raise AuthenticationError if res.code.to_i == 401
-          raise APIError if res.code.to_i >= 500
-          {:uid => uuid, :cal => c, :cal_string => cstring, :response_code => res.code} #TODO
-        end
-    
-        def add_alarm tevent, altCal="Calendar"
-            # FIXME create icalendar event -> cal.event.new (tevent)  
-          
-            # TODO  
-
-
-
-
-        end
-        
-        def update event
-           # FIXME old one not neat 
-          
-            # TODO 
-        end
-    
-        def todo 
-            res = nil
-            __create_http.start {|http|
-                req = Net::HTTP::Report.new(@url, initheader = {'Content-Type'=>'application/xml'} )
-                req.basic_auth @user, @password
-                req.body = AgCalDAV::Request::ReportVTODO.new.to_xml
-                res = http.request( req )
-            }
-            # FIXME: process HTTP code
-            format.parse_todo( res.body )
-        end
-        
-        def filterTimezone( vcal )
-            data = ""
-            inTZ = false
-            vcal.split("\n").each{ |l| 
-                inTZ = true if l.index("BEGIN:VTIMEZONE") 
-                data << l+"\n" unless inTZ 
-                inTZ = false if l.index("END:VTIMEZONE") 
-            }
-            return data
-        end
+  class Client
+    include Icalendar
+    attr_accessor :host, :port, :url, :user, :password, :ssl
+
+    def format=( fmt )
+      @format = fmt
+    end
+
+    def format
+      @format ||= Format::Debug.new
+    end
+
+    def initialize( data )
+      unless data[:proxy_uri].nil?
+        proxy_uri   = URI(data[:proxy_uri])
+        @proxy_host = proxy_uri.host
+        @proxy_port = proxy_uri.port.to_i
+      end
+      uri = URI(data[:uri])
+      @host     = uri.host
+      @port     = uri.port.to_i
+      @url      = uri.path
+      @user     = data[:user]
+      @password = data[:password]
+      @ssl      = uri.scheme == 'https'
+    end
+
+    def __create_http
+      if @proxy_uri.nil?
+        http = Net::HTTP.new(@host, @port)
+      else
+        http = Net::HTTP.new(@host, @port, @proxy_host, @proxy_port)
+      end
+      if @ssl
+        http.use_ssl = @ssl
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+      http
+    end
+
+    def find_events data
+      result = ""
+      res = nil
+      __create_http.start {|http|
+        req = Net::HTTP::Report.new(@url, initheader = {'Content-Type'=>'application/xml'} )
+        req.basic_auth @user, @password
+        req.body = AgCalDAV::Request::ReportVEVENT.new(DateTime.parse(data[:start]).strftime("%Y%m%dT%H%M"),
+                                                       DateTime.parse(data[:end]).strftime("%Y%m%dT%H%M") ).to_xml
+        res = http.request(req)
+        s = res.body
+        result = ""
+        xml = REXML::Document.new(s)
+        REXML::XPath.each( xml, '//c:calendar-data/', {"c"=>"urn:ietf:params:xml:ns:caldav"} ){|c| result << c.text}
+        r = Icalendar.parse(result)
+        r.first
+
+      }
+
+     
+    end
+
+    def find_event uuid
+      res = nil
+      __create_http.start {|http|
+        req = Net::HTTP::Get.new("#{@url}/#{uuid}.ics")
+        req.basic_auth @user, @password
+        res = http.request( req )
+      }
+      raise AuthenticationError if res.code.to_i == 401
+      raise APIError if res.code.to_i >= 500
+      r = Icalendar.parse(res.body)      
+      r.first
+    end
+
+    def delete_event uuid
+      __create_http.start {|http|
+        req = Net::HTTP::Delete.new("#{@url}/#{uuid}.ics")
+        req.basic_auth @user, @password
+        res = http.request( req )
+      }
+    end
+
+    def create_event event
+      c = Calendar.new
+      uuid = UUID.new.generate
+      c.event do
+        uid           uuid  # still a BUG
+        dtstart       DateTime.parse(event[:start])
+        dtend         DateTime.parse(event[:end])
+        duration      event[:duration]
+        summary       event[:title]
+        description   event[:description]
+        klass         event[:accessibility] #PUBLIC, PRIVATE, CONFIDENTIAL
+        location      event[:location]
+        geo_location  event[:geo_location]
+        status        event[:status]
+      end
+      c.publish
+      c.event.uid = uuid
+      cstring = c.to_ical
+      res = nil
+      http = Net::HTTP.new(@host, @port)
+      __create_http.start { |http|
+        req = Net::HTTP::Put.new("#{@url}/#{uuid}.ics")
+        req['Content-Type'] = 'text/calendar'
+        req.basic_auth @user, @password
+        req.body = cstring
+        res = http.request( req )
+      }
+      raise AuthenticationError if res.code.to_i == 401
+      raise APIError if res.code.to_i >= 500
+      find_event uuid
+      #{:uid => uuid, :cal => c, :cal_string => cstring, :response_code => res.code} #TODO
+    end
+
+    def add_alarm tevent, altCal="Calendar"
+      # FIXME create icalendar event -> cal.event.new (tevent)
+
+      # TODO
+
+
+
+
     end
 
+    def update event
+      # FIXME old one not neat
+
+      # TODO
+    end
+
+    def todo
+      res = nil
+      __create_http.start {|http|
+        req = Net::HTTP::Report.new(@url, initheader = {'Content-Type'=>'application/xml'} )
+        req.basic_auth @user, @password
+        req.body = AgCalDAV::Request::ReportVTODO.new.to_xml
+        res = http.request( req )
+      }
+      # FIXME: process HTTP code
+      format.parse_todo( res.body )
+    end
+
+    def filterTimezone( vcal )
+      data = ""
+      inTZ = false
+      vcal.split("\n").each{ |l|
+        inTZ = true if l.index("BEGIN:VTIMEZONE")
+        data << l+"\n" unless inTZ
+        inTZ = false if l.index("END:VTIMEZONE")
+      }
+      return data
+    end
+  end
+
   class AgCalDAVError < StandardError
   end
   class AuthenticationError < AgCalDAVError; end

data/lib/agcaldav/event.rb

@@ -0,0 +1,121 @@
+
+
+module Icalendar
+  # A Event calendar component is a grouping of component
+  # properties, and possibly including Alarm calendar components, that
+  # represents a scheduled amount of time on a calendar. For example, it
+  # can be an activity; such as a one-hour long, department meeting from
+  # 8:00 AM to 9:00 AM, tomorrow. Generally, an event will take up time
+  # on an individual calendar.
+  class Event < Component
+    ical_component :alarms
+
+    ## Single instance properties
+
+    # Access classification (PUBLIC, PRIVATE, CONFIDENTIAL...)
+    ical_property :ip_class, :klass
+
+    # Date & time of creation
+    ical_property :created
+
+    # Complete description of the calendar component
+    ical_property :description
+
+    attr_accessor :tzid
+
+    # Specifies date-time when calendar component begins
+    ical_property :dtstart, :start
+
+    # Latitude & longitude for specified activity
+    ical_property :geo, :geo_location
+
+    # Date & time this item was last modified
+    ical_property :last_modified
+
+    # Specifies the intended venue for this activity
+    ical_property :location
+
+    # Defines organizer of this item
+    ical_property :organizer
+
+    # Defines relative priority for this item (1-9... 1 = best)
+    ical_property :priority
+
+    # Indicate date & time when this item was created
+    ical_property :dtstamp, :timestamp
+
+    # Revision sequence number for this item
+    ical_property :sequence, :seq
+
+    # Defines overall status or confirmation of this item
+    ical_property :status
+    ical_property :summary
+    ical_property :transp, :transparency
+
+    # Defines a persistent, globally unique id for this item
+    ical_property :uid, :unique_id
+
+    # Defines a URL associated with this item
+    ical_property :url
+    ical_property :recurrence_id, :recurid
+
+    ## Single but mutually exclusive properties (Not testing though)
+
+    # Specifies a date and time that this item ends
+    ical_property :dtend, :end
+
+    # Specifies a positive duration time
+    ical_property :duration
+
+    ## Multi-instance properties
+
+    # Associates a URI or binary blob with this item
+    ical_multi_property :attach, :attachment, :attachments
+
+    # Defines an attendee for this calendar item
+    ical_multiline_property :attendee, :attendee, :attendees
+
+    # Defines the categories for a calendar component (school, work...)
+    ical_multi_property :categories, :category, :categories
+
+    # Simple comment for the calendar user.
+    ical_multi_property :comment, :comment, :comments
+
+    # Contact information associated with this item.
+    ical_multi_property :contact, :contact, :contacts
+    ical_multi_property :exdate, :exception_date, :exception_dates
+    ical_multi_property :exrule, :exception_rule, :exception_rules
+    ical_multi_property :rstatus, :request_status, :request_statuses
+
+    # Used to represent a relationship between two calendar items
+    ical_multi_property :related_to, :related_to, :related_tos
+    ical_multi_property :resources, :resource, :resources
+
+    # Used with the UID & SEQUENCE to identify a specific instance of a
+    # recurring calendar item.
+    ical_multi_property :rdate, :recurrence_date, :recurrence_dates
+    ical_multi_property :rrule, :recurrence_rule, :recurrence_rules
+
+    def initialize()
+      super("VEVENT")
+
+      # Now doing some basic initialization
+      sequence 0
+      timestamp DateTime.now
+    end
+
+    def alarm(&block)
+      a = Alarm.new
+      self.add a
+
+      a.instance_eval(&block) if block
+
+      a
+    end
+
+    def occurrences_starting(time)
+      recurrence_rules.first.occurrences_of_event_starting(self, time)
+    end
+
+  end
+end

data/lib/agcaldav/format.rb

@@ -1,64 +1,60 @@
 module AgCalDAV
-    module Format
-        class Raw
-            def method_missing(m, *args, &block)
-                return *args
-            end
-        end
+  module Format
+    class Raw
+      def method_missing(m, *args, &block)
+        return *args
+      end
+    end
+
+    class Debug < Raw
+    end
 
-        class Debug < Raw
-        end
+    class Pretty < Raw
+      def parse_calendar(s)
+        result = ""
+        xml = REXML::Document.new(s)
+        puts "-"*10
+        p s
+        puts "-"*10
+        REXML::XPath.each( xml, '//c:calendar-data/', {"c"=>"urn:ietf:params:xml:ns:caldav"} ){|c| result << c.text}
+        r = Icalendar.parse(result)
 
-        class Pretty < Raw
-            def parse_calendar( body )
-                result = []
-                xml = REXML::Document.new( res.body )
-                REXML::XPath.each( xml, '//c:calendar-data/', { "c"=>"urn:ietf:params:xml:ns:caldav"} ){ |c|
-                    result += parse_events( c.text )
-                }
-                return result
-            end
+        puts "."*10
+        p r 
+        puts "."*10
+        r
+      end
 
-            def parse_todo( body )
-                result = []
-                xml = REXML::Document.new( body )
-                REXML::XPath.each( xml, '//c:calendar-data/', { "c"=>"urn:ietf:params:xml:ns:caldav"} ){ |c|
-                    p c.text
-                    p parse_tasks( c.text )
-                    result += parse_tasks( c.text )
-                }
-                return result
-            end
+      def parse_todo( body )
+        result = []
+        xml = REXML::Document.new( body )
+        REXML::XPath.each( xml, '//c:calendar-data/', { "c"=>"urn:ietf:params:xml:ns:caldav"} ){ |c|
+          p c.text
+          p parse_tasks( c.text )
+          result += parse_tasks( c.text )
+        }
+        return result
+      end
 
-            def parse_tasks( vcal )
-                return_tasks = Array.new
-                cals = Icalendar.parse(vcal)
-                cals.each { |tcal|
-                    tcal.todos.each { |ttask|  # FIXME
-                        return_tasks << ttask
-                    }
-                }
-                return return_tasks
-            end
+      def parse_tasks( vcal )
+        return_tasks = Array.new
+        cals = Icalendar.parse(vcal)
+        cals.each { |tcal|
+          tcal.todos.each { |ttask|  # FIXME
+            return_tasks << ttask
+          }
+        }
+        return return_tasks
+      end
 
-            def parse_events( vcal )
-                return_events = Array.new
-                cals = Icalendar.parse(vcal)
-                cals.each { |tcal|
-                    tcal.events.each { |tevent|
-                        if tevent.recurrence_id.to_s.empty? # skip recurring events
-                            return_events << tevent
-                        end
-                    }
-                }
-                return return_events
-            end
+      def parse_events( vcal )
+        Icalendar.parse(vcal)        
+      end
 
-            def parse_single( body )
-                # FIXME: parse event/todo/vcard
-                parse_events( body )
-            end
-        end
+      def parse_single( body )
+        # FIXME: parse event/todo/vcard
+        parse_events( body )
+      end
     end
+  end
 end
-

data/lib/agcaldav/version.rb

@@ -1,3 +1,3 @@
 module AgCalDAV
-    VERSION="0.2.1"
+    VERSION="0.2.2"
 end

data/lib/agcaldav.rb

@@ -6,14 +6,6 @@ require 'icalendar'
 require 'time'
 require 'date'
 
-['client.rb', 'request.rb', 'net.rb', 'query.rb', 'filter.rb', 'format.rb'].each do |f|
+['client.rb', 'request.rb', 'net.rb', 'query.rb', 'filter.rb', 'event.rb', 'format.rb'].each do |f|
     require File.join( File.dirname(__FILE__), 'agcaldav', f )
-end
-
-class Event
-    attr_accessor :uid, :created, :dtstart, :dtend, :lastmodified, :summary, :description, :name, :action, :to_ical
-end
-
-class Todo
-    attr_accessor :uid, :created, :summary, :dtstart, :status, :completed
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: agcaldav
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -86,6 +86,7 @@ files:
 - agcaldav.gemspec
 - lib/agcaldav.rb
 - lib/agcaldav/client.rb
+- lib/agcaldav/event.rb
 - lib/agcaldav/filter.rb
 - lib/agcaldav/format.rb
 - lib/agcaldav/net.rb