sabredav_client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5a3c684d5190fe9608d786b4619fc6494ead48b7
+  data.tar.gz: b44836242e58f0ed59c074f71b76b1ac1f145fa2
+SHA512:
+  metadata.gz: 31bb29f8199f0a2e1fc1c3fc46120951aa79131d631637eedcf3e5d61acf463418f39684a24341a24cecb9050e6b7bdfd0a1f744aa89c07f193e05fc91ecc955
+  data.tar.gz: 2ac0d0920b6ae3500f8cef24e6396756fba06bcafda200bafe0e0cf3509ff27839528f75af580fd0c716dc4640da226143bfb88f4886bf751de27dd9601d1b00

data/.gitignore

@@ -0,0 +1,3 @@
+caldaver-test.sh
+*.gem
+*.tmp

data/.rspec

@@ -0,0 +1 @@
+--colour

data/CHANGELOG.rdoc

@@ -0,0 +1,8 @@
+= v0.2.5.3
+
+* Fixed gemspec 
+
+= v0.2.5.2
+
+* client.update_event *args* changed. UID has to be provided 
+  now ->  client.update_event(:uid => "123", ...)

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,46 @@
+PATH
+  remote: .
+  specs:
+    sabredav_client (0.2.6.0)
+      builder (~> 3.2)
+      icalendar (~> 2.4)
+      net-http-digest_auth (~> 1.4)
+      uuid (~> 2.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    builder (3.2.2)
+    diff-lcs (1.2.5)
+    fakeweb (1.3.0)
+    icalendar (2.4.0)
+    macaddr (1.7.1)
+      systemu (~> 2.6.2)
+    net-http-digest_auth (1.4)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.2)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    systemu (2.6.5)
+    uuid (2.3.8)
+      macaddr (~> 1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  fakeweb (~> 1.3)
+  rspec (~> 3.5)
+  sabredav_client!
+
+BUNDLED WITH
+   1.12.5

data/README.md

@@ -0,0 +1,131 @@
+#Ruby CalDAV library named "agcaldav"
+**agcaldav is a CalDAV library based on martinpovolny/ruby-caldav and 4fthawaiian/ruby-caldav and collectiveidea/caldav**
+
+**Please keep in mind, agcaldav ist still under heavy development and still not finished...**
+
+##Usage Events
+
+First, you've to install the gem
+
+    gem install agcaldav
+
+and require it
+
+    require "agcaldav"
+
+Next you have to obtain the URI, username and password to a CalDAV-Server. If you don't have one try RADICALE (https://github.com/agilastic/Radicale). It's small, simple and written in python. In the following steps I'm using the default params of Radical.
+
+
+Now you can e.g. create a new AgCalDAV-Client:
+    	
+	cal = AgCalDAV::Client.new(:uri => "http://localhost:5232/user/calendar", :user => "user" , :password => "")
+
+Alternatively, the proxy parameters can be specified:
+
+	cal = AgCalDAV::Client.new(:uri => "http://localhost:5232/user/calendar",:user => "user" , :password => "password", :proxy_uri => "http://my-proxy.com:8080")
+
+
+####Create an Event
+
+    result = cal.create_event(:start => "2012-12-29 10:00", :end => "2012-12-30 12:00", :title => "12345", :description => "12345 12345")
+
+Analyze result:
+   
+    >> result
+    => #<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.class
+    => Icalendar::Event
+
+   
+get UID of this Event:
+
+    >> result.uid
+    => "e795c480-34e0-0130-7d1d-109add70606c"
+
+
+####Find an Event  (via UUID)  
+
+    result = cal.find_event("e795c480-34e0-0130-7d1d-109add70606c")
+    
+    >> result.class
+    => Icalendar::Event
+
+
+####Find Events within time interval
+
+    result = cal.find_events(:start => "2012-10-01 08:00", :end => "2013-01-01")
+
+    >> result
+    => [#<Icalendar::Event:0x007f8ad11cfdf0 @name="VEVENT", @components={}, @properties={"sequence"=>0, "dtstamp"=>#<DateTime: 2012-12-31T13:44:10+00:00 (4244474429/1728,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"=>"b2c45e20-3575-0130-7d2e-109add70606c", "x-radicale_name"=>"b2c45e20-3575-0130-7d2e-109add70606c.ics"}>, #<Icalendar::Event:0x007f8ad10d7dd0 @name="VEVENT", @components={}, @properties={"sequence"=>0, "dtstamp"=>#<DateTime: 2012-12-31T13:44:10+00:00 (4244474429/1728,0/1,2299161)>, "uid"=>"b2c45e20-3575-0130-7d2e-109add70606c", "x-radicale_name"=>"b2c45e20-3575-0130-7d2e-109add70606c.ics"}>]
+
+    >> result.class
+    => Array
+
+    >> result.count
+    => 2
+
+
+
+####Update Event
+
+    event = {:start => "2012-12-29 10:00", :end => "2012-12-30 12:00", :title => "12345", :description => "sdkvjsdf sdkf sdkfj sdkf dsfj"}
+    # set UUID 
+    event[:uid] => "e795c480-34e0-0130-7d1d-109add70606c"
+    c = cal.update_event(event)
+
+
+
+####Delete Event
+
+    cal.delete_event("e795c480-34e0-0130-7d1d-109add70606c")
+
+
+
+
+##Usage ToDo
+
+####not finished ATM
+Have a look tomorrow...
+
+
+
+##Work to be done ...
+
+1. find and notify if overlapping events              
+2. code cleanup -> more ActiveRecord style    
+            
+                                                             
+
+
+##Testing
+
+agcaldav will use RSpec for its test coverage. Inside the gem
+directory, you can run the specs for RoR 3.x with:
+
+  rake spec 
+(will be implemented in > v0.2.5)  
+
+
+ 
+##Licence
+
+MIT
+
+
+
+##Contributors
+
+[Check all contributors][c]
+
+
+1. Fork it.
+2. Create a branch (`git checkout -b my_feature_branch`)
+3. Commit your changes (`git commit -am "bugfixed abc..."`)
+4. Push to the branch (`git push origin my_feature_branch`)
+5. Open a [Pull Request][1]
+6. Enjoy a refreshing Club Mate and wait
+
+[c]: https://github.com/agilastic/agcaldav/contributors
+[1]: https://github.com/agilastic/agcaldav/pulls/
+

data/Rakefile

@@ -0,0 +1,6 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+# If you want to make this the default task
+task :default => :spec

data/lib/sabredav_client/calendar.rb

@@ -0,0 +1,111 @@
+module SabredavClient
+
+  class Calendar
+    attr_accessor :client
+
+    def initialize(data)
+      @client = SabredavClient::Client.new(data)
+    end
+
+    def events
+      @events ||= SabredavClient::Events.new(client)
+    end
+
+    def info
+      header  = {content_type: "application/xml"}
+      body    = SabredavClient::XmlRequestBuilder::PROPFINDCalendar.new(properties: [:displayname, :sync_token, :getctag]).to_xml
+
+      req = client.create_request(:propfind, header: header, body: body)
+      res = req.run
+
+      SabredavClient::Errors::errorhandling(res)
+
+      xml = REXML::Document.new(res.body)
+      {
+        displayname: REXML::XPath.first(xml, "//d:displayname").text,
+        ctag: REXML::XPath.first(xml, "//cs:getctag").text,
+        sync_token: REXML::XPath.first(xml, "//d:sync-token").text
+      }
+    end
+
+    def create(displayname: "", description: "")
+      body    = SabredavClient::XmlRequestBuilder::Mkcalendar.new(displayname, description).to_xml
+      header  = {dav: "resource-must-be-null", content_type: "application/xml"}
+
+      req = client.create_request(:mkcalendar, header: header, body: body)
+
+      res = req.run
+
+      SabredavClient::Errors.errorhandling(res)
+      info
+    end
+
+    def delete
+      req = client.create_request(:delete)
+      res = req.run
+
+      if res.code.to_i.between?(200,299)
+        true
+      else
+        SabredavClient::Errors::errorhandling(res)
+      end
+    end
+
+    def share(adds: [], removes: [], summary: nil, common_name: nil,
+      privilege: "write-read", type: nil)
+
+      header  = {content_length: "xxxx", content_type: "application/xml"}
+      body    = SabredavClient::XmlRequestBuilder::PostSharing.new(
+        adds, summary, common_name, privilege, removes).to_xml
+
+      req = client.create_request(:post, header: header, body: body)
+
+      res = req.run
+
+      raise SabredavClient::Errors::ShareeTypeNotSupportedError if type && type != :email
+
+      if res.code.to_i.between?(200,299)
+        true
+      else
+        SabredavClient::Errors::errorhandling(res)
+      end
+    end
+
+    def fetch_changes(sync_token)
+
+      body    = SabredavClient::XmlRequestBuilder::ReportEventChanges.new(sync_token).to_xml
+      header  = {content_type: "application/xml"}
+
+      req     = client.create_request(:report, header: header, body: body)
+
+      res     = req.run
+
+      SabredavClient::Errors::errorhandling(res)
+
+      changes   = []
+      deletions = []
+      xml = REXML::Document.new(res.body)
+
+      #FIXME This is so damn ugly, but at least it`s working now
+      REXML::XPath.each(xml, "//d:response/", {"d"=> "DAV:"}) do |response|
+        entry = REXML::Document.new.add(response)
+        if (REXML::XPath.first(entry, "//d:status").text == "HTTP/1.1 404 Not Found")
+            deletions.push(
+              REXML::XPath.first(entry, "//d:href").text.to_s.split("/").last)
+        else
+          changes.push(
+            {
+              uri:  REXML::XPath.first(entry, "//d:href").text.split("/").last,
+              etag: REXML::XPath.first(entry, "//d:getetag").text
+            })
+        end
+      end
+
+      {
+        changes: changes,
+        deletions: deletions,
+        sync_token: REXML::XPath.first(xml, "//d:sync-token").text
+      }
+    end
+  end
+end

data/lib/sabredav_client/client.rb

@@ -0,0 +1,57 @@
+module SabredavClient
+  class Client
+    attr_reader :authtype, :host, :port, :base_path, :user, :password, :ssl,
+     :digest_auth, :duri, :proxy_host, :proxy_uri, :proxy_port, :base_path
+
+    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
+      @base_path = uri.path
+      @user     = data[:user]
+      @password = data[:password]
+      @ssl      = uri.scheme == 'https'
+
+      unless data[:authtype].nil?
+        @authtype = data[:authtype]
+
+        if @authtype == 'digest'
+
+          @digest_auth = Net::HTTP::DigestAuth.new
+          @duri = URI.parse data[:uri]
+          @duri.user = @user
+          @duri.password = @password
+
+        elsif @authtype == 'basic'
+          #Don't Raise or do anything else
+        else
+          raise "Authentication Type Specified Is Not Valid. Please use basic or digest"
+        end
+      else
+        @authtype = 'basic'
+      end
+    end
+
+    def create_request(method, header: {}, body: "", path: "")
+      request = SabredavClient::Request.new(method, self, path)
+      request.add_header(header)  unless header.empty?
+      request.add_body(body)      unless body.empty?
+      request
+    end
+  end
+end

data/lib/sabredav_client/errors/errors.rb

@@ -0,0 +1,38 @@
+module SabredavClient
+  module Errors
+
+    def  self.errorhandling response
+      case response.code.to_i
+      when 401
+        raise SabredavClient::Errors::AuthenticationError
+      when 403
+        raise SabredavClient::Errors::ForbiddenError
+      when 404
+        raise SabredavClient::Errors::NotFoundError
+      when 405
+        raise SabredavClient::Errors::NotAllowedError
+      when 410
+        raise SabredavClient::Errors::NotExistError
+      when 412
+        raise SabredavClient::Errors::PreconditionFailed
+      when 500
+        raise SabredavClient::Errors::APIError
+      end
+    end
+
+    class SabredavClientError < StandardError; end
+
+    class PropertyNotSupportedError   < SabredavClientError; end
+    class ShareeTypeNotSupportedError < SabredavClientError; end
+
+    class HTTPMethodNotSupportedError < SabredavClientError; end
+
+    class APIError            < SabredavClientError; end
+    class ForbiddenError      < APIError; end
+    class NotFoundError       < APIError; end
+    class PreconditionFailed  < APIError; end
+    class NotAllowedError     < APIError; end
+    class AuthenticationError < APIError; end
+    class NotExistError       < APIError; end
+  end
+end

data/lib/sabredav_client/events.rb

@@ -0,0 +1,97 @@
+module SabredavClient
+
+  class Events
+    attr_accessor :client
+
+    def initialize(client)
+      @client = client
+    end
+
+    def find(uri)
+      req = client.create_request(:get, path: uri)
+      res = req.run
+
+      SabredavClient::Errors::errorhandling(res)
+      res.body
+    end
+
+    def find_multiple(starts: "", ends: "")
+      events  = []
+      header  = {depth: "1", content_type: "application/xml"}
+
+      if starts.is_a? Integer
+        body = SabredavClient::XmlRequestBuilder::ReportVEVENT.new(Time.at(starts).utc.strftime("%Y%m%dT%H%M%S"),
+                                                      Time.at(ends).utc.strftime("%Y%m%dT%H%M%S") ).to_xml
+      else
+        body = SabredavClient::XmlRequestBuilder::ReportVEVENT.new(Time.parse(starts).utc.strftime("%Y%m%dT%H%M%S"),
+                                                      Time.parse(ends).utc.strftime("%Y%m%dT%H%M%S") ).to_xml
+      end
+
+      req = client.create_request(:report, header: header)
+      res = req.run
+
+      SabredavClient::Errors::errorhandling(res)
+      result = ""
+
+      xml = REXML::Document.new(res.body)
+      REXML::XPath.each( xml, '//c:calendar-data/', {"c"=>"urn:ietf:params:xml:ns:caldav"} ){|c| result << c.text}
+
+      calendar = Icalendar::Calendar.parse(result).first
+      if calendar
+        calendar.events
+      else
+        false
+      end
+    end
+
+    def owner(uri)
+      header = {content_type: "application/xml"}
+      body = XmlRequestBuilder::PropfindOwner.new.to_xml
+      req = client.create_request(:propfind, path: uri, header: header, body: body)
+      res = req.run
+
+      SabredavClient::Errors::errorhandling(res)
+      xml = REXML::Document.new(res.body)
+      REXML::XPath.first(xml, "//d:objectOwner").text
+    end
+
+    def update_owner(uri, owner)
+      header = {content_type: "application/xml"}
+      body = XmlRequestBuilder::ProppatchOwner.new(owner).to_xml
+      req = client.create_request(:proppatch, path: uri, header: header, body: body)
+      res = req.run
+
+      if res.code.to_i.between?(200,299)
+        true
+      else
+        SabredavClient::Errors::errorhandling(res)
+      end
+    end
+
+    def delete(uri)
+      req = client.create_request(:delete, path: uri)
+      res = req.run
+
+      if res.code.to_i.between?(200,299)
+        true
+      else
+        SabredavClient::Errors::errorhandling(res)
+      end
+    end
+
+    def create_update(uri, event_ics, etag = nil)
+      header  = {content_type: "text/calendar"}
+      body    = event_ics
+
+      if etag
+        header[:if_match] = %Q/"#{etag.gsub(/\A['"]+|['"]+\Z/, "")}"/
+      end
+
+      req = client.create_request(:put,header: header, body: body, path: uri)
+      res = req.run
+
+      SabredavClient::Errors::errorhandling(res)
+      res['etag']
+    end
+  end
+end

data/lib/sabredav_client/format.rb

@@ -0,0 +1,54 @@
+module SabredavClient
+  module Format
+    class Raw
+      def method_missing(m, *args, &block)
+        return *args
+      end
+    end
+
+    class Debug < Raw
+    end
+
+    class Pretty < Raw
+      def parse_calendar(s)
+        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
+      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_events( vcal )
+        Icalendar.parse(vcal)
+      end
+
+      def parse_single( body )
+        # FIXME: parse event/todo/vcard
+        parse_events( body )
+      end
+    end
+  end
+end

data/lib/sabredav_client/net.rb

@@ -0,0 +1,15 @@
+module Net
+    class HTTP
+        class Report < HTTPRequest
+            METHOD = 'REPORT'
+            REQUEST_HAS_BODY = true
+            RESPONSE_HAS_BODY = true
+        end
+
+        class Mkcalendar < HTTPRequest
+            METHOD = 'MKCALENDAR'
+            REQUEST_HAS_BODY = true
+            RESPONSE_HAS_BODY = true
+        end
+    end
+end

data/lib/sabredav_client/principal.rb

@@ -0,0 +1,36 @@
+module SabredavClient
+
+  class Principal
+    attr_accessor :client
+
+    def initialize(data)
+      @client = SabredavClient::Client.new(data)
+    end
+
+    def create(email, displayname = nil)
+      header  = {content_type: "text/xml", depth: "1"}
+      body    = SabredavClient::XmlRequestBuilder::MkcolPrincipal.new(email, displayname).to_xml
+      req = client.create_request(:mkcol, header: header, body: body)
+
+      res = req.run
+      if res.code.to_i.between?(200,299)
+        true
+      else
+        SabredavClient::Errors::errorhandling(res)
+      end
+    end
+
+    def delete
+      #FIXME seems like deleting a principal is forbidden by sabredav
+      req = client.create_request(:delete)
+      res = req.run
+
+      if res.code.to_i.between?(200,299)
+        true
+      else
+        SabredavClient::Errors::errorhandling(res)
+      end
+    end
+
+  end
+end