tilia-dav 3.1.0.pre.alpha2

data/lib/tilia/cal_dav/calendar_query_validator.rb

@@ -0,0 +1,294 @@
+module Tilia
+  module CalDav
+    # CalendarQuery Validator
+    #
+    # This class is responsible for checking if an iCalendar object matches a set
+    # of filters. The main function to do this is 'validate'.
+    #
+    # This is used to determine which icalendar objects should be returned for a
+    # calendar-query REPORT request.
+    class CalendarQueryValidator
+      # Verify if a list of filters applies to the calendar data object
+      #
+      # The list of filters must be formatted as parsed by \Sabre\CalDAV\CalendarQueryParser
+      #
+      # @param VObject\Component v_object
+      # @param array filters
+      # @return bool
+      def validate(v_object, filters)
+        fail ArgumentError, 'Object must be VCalendar' unless v_object.is_a?(VObject::Component::VCalendar)
+
+        # The top level object is always a component filter.
+        # We'll parse it manually, as it's pretty simple.
+        return false unless v_object.name == filters['name']
+
+        validate_comp_filters(v_object, filters['comp-filters']) &&
+          validate_prop_filters(v_object, filters['prop-filters'])
+      end
+
+      protected
+
+      # This method checks the validity of comp-filters.
+      #
+      # A list of comp-filters needs to be specified. Also the parent of the
+      # component we're checking should be specified, not the component to check
+      # itself.
+      #
+      # @param VObject\Component parent
+      # @param array filters
+      # @return bool
+      def validate_comp_filters(parent, filters)
+        filters.each do |filter|
+          is_defined = parent.key?(filter['name'])
+
+          if filter['is-not-defined']
+            if is_defined
+              return false
+            else
+              next
+            end
+          end
+
+          return false unless is_defined
+
+          skip = false
+          if filter['time-range'] && filter['time-range'].any?
+            parent[filter['name']].each do |sub_component|
+              if validate_time_range(sub_component, filter['time-range']['start'], filter['time-range']['end'])
+                skip = true
+                break
+              end
+            end
+            next if skip
+
+            return false
+          end
+
+          next if !filter['comp-filters'] && !filter['prop-filters']
+
+          # If there are sub-filters, we need to find at least one component
+          # for which the subfilters hold true.
+          parent[filter['name']].each do |sub_component|
+            next unless validate_comp_filters(sub_component, filter['comp-filters']) &&
+                        validate_prop_filters(sub_component, filter['prop-filters'])
+            skip = true
+            break
+          end
+          next if skip
+
+          # If we got here it means there were sub-comp-filters or
+          # sub-prop-filters and there was no match. This means this filter
+          # needs to return false.
+          return false
+        end
+
+        # If we got here it means we got through all comp-filters alive so the
+        # filters were all true.
+        true
+      end
+
+      # This method checks the validity of prop-filters.
+      #
+      # A list of prop-filters needs to be specified. Also the parent of the
+      # property we're checking should be specified, not the property to check
+      # itself.
+      #
+      # @param VObject\Component parent
+      # @param array filters
+      # @return bool
+      def validate_prop_filters(parent, filters)
+        filters.each do |filter|
+          is_defined = parent.key?(filter['name'])
+
+          if filter['is-not-defined']
+            if is_defined
+              return false
+            else
+              next
+            end
+          end
+
+          return false unless is_defined
+
+          skip = false
+          if filter['time-range']
+            parent[filter['name']].each do |sub_component|
+              if validate_time_range(sub_component, filter['time-range']['start'], filter['time-range']['end'])
+                skip = true
+                break
+              end
+            end
+            next if skip
+
+            return false
+          end
+
+          next if !filter['param-filters'] && !filter['text-match']
+
+          # If there are sub-filters, we need to find at least one property
+          # for which the subfilters hold true.
+          parent[filter['name']].each do |sub_component|
+            next unless validate_param_filters(sub_component, filter['param-filters']) &&
+                        (!filter['text-match'] || validate_text_match(sub_component, filter['text-match']))
+            skip = true
+            break
+          end
+          next if skip
+
+          # If we got here it means there were sub-param-filters or
+          # text-match filters and there was no match. This means the
+          # filter needs to return false.
+          return false
+        end
+
+        # If we got here it means we got through all prop-filters alive so the
+        # filters were all true.
+        true
+      end
+
+      # This method checks the validity of param-filters.
+      #
+      # A list of param-filters needs to be specified. Also the parent of the
+      # parameter we're checking should be specified, not the parameter to check
+      # itself.
+      #
+      # @param VObject\Property parent
+      # @param array filters
+      # @return bool
+      def validate_param_filters(parent, filters)
+        filters.each do |filter|
+          is_defined = parent.key?(filter['name'])
+
+          if filter['is-not-defined']
+            if is_defined
+              return false
+            else
+              next
+            end
+          end
+
+          return false unless is_defined
+          next unless filter['text-match']
+
+          # If there are sub-filters, we need to find at least one parameter
+          # for which the subfilters hold true.
+          skip = false
+          parent[filter['name']].parts.each do |param_part|
+            next unless validate_text_match(param_part, filter['text-match'])
+            skip = true
+            break
+          end
+
+          next if skip
+
+          # If we got here it means there was a text-match filter and there
+          # were no matches. This means the filter needs to return false.
+          return false
+        end
+
+        # If we got here it means we got through all param-filters alive so the
+        # filters were all true.
+        true
+      end
+
+      # This method checks the validity of a text-match.
+      #
+      # A single text-match should be specified as well as the specific property
+      # or parameter we need to validate.
+      #
+      # @param VObject\Node|string check Value to check against.
+      # @param array text_match
+      # @return bool
+      def validate_text_match(check, text_match)
+        check = check.value if check.is_a?(VObject::Node)
+
+        is_matching = Dav::StringUtil.text_match(check, text_match['value'], text_match['collation'])
+
+        text_match['negate-condition'] ^ is_matching
+      end
+
+      # Validates if a component matches the given time range.
+      #
+      # This is all based on the rules specified in rfc4791, which are quite
+      # complex.
+      #
+      # @param VObject\Node component
+      # @param DateTime start
+      # @param DateTime end
+      # @return bool
+      def validate_time_range(component, start, ending)
+        start = Time.zone.parse('1900-01-01') unless start
+        ending = Time.zone.parse('3000-01-01') unless ending
+
+        case component.name
+        when 'VEVENT', 'VTODO', 'VJOURNAL'
+          return component.in_time_range?(start, ending)
+        when 'VALARM'
+          # If the valarm is wrapped in a recurring event, we need to
+          # expand the recursions, and validate each.
+          #
+          # Our datamodel doesn't easily allow us to do this straight
+          # in the VALARM component code, so this is a hack, and an
+          # expensive one too.
+          if component.parent.name == 'VEVENT' && component.parent['RRULE']
+            # Fire up the iterator!
+            it = VObject::Recur::EventIterator.new(component.parent.parent, component.parent['UID'].to_s)
+            while it.valid
+              expanded_event = it.event_object
+
+              # We need to check from these expanded alarms, which
+              # one is the first to trigger. Based on this, we can
+              # determine if we can 'give up' expanding events.
+              first_alarm = nil
+              if expanded_event['VALARM']
+                expanded_event['VALARM'].each do |expanded_alarm|
+                  effective_trigger = expanded_alarm.effective_trigger_time
+                  return true if expanded_alarm.in_time_range?(start, ending)
+
+                  if expanded_alarm['TRIGGER']['VALUE'].to_s == 'DATE-TIME'
+                    # This is an alarm with a non-relative trigger
+                    # time, likely created by a buggy client. The
+                    # implication is that every alarm in this
+                    # recurring event trigger at the exact same
+                    # time. It doesn't make sense to traverse
+                    # further.
+                  else
+                    # We store the first alarm as a means to
+                    # figure out when we can stop traversing.
+                    if !first_alarm || effective_trigger < first_alarm
+                      first_alarm = effective_trigger
+                    end
+                  end
+                end
+              end
+
+              unless first_alarm
+                # No alarm was found.
+                #
+                # Or technically: No alarm that will change for
+                # every instance of the recurrence was found,
+                # which means we can assume there was no match.
+                return false
+              end
+
+              return false if first_alarm > ending
+
+              it.next
+            end
+
+            return false
+          else
+            return component.in_time_range?(start, ending)
+          end
+
+        when 'VFREEBUSY'
+          fail Dav::Exception::NotImplemented, "time-range filters are currently not supported on #{component.name} components"
+        when 'COMPLETED', 'CREATED', 'DTEND', 'DTSTAMP', 'DTSTART', 'DUE', 'LAST-MODIFIED'
+          return start <= component.date_time && ending >= component.date_time
+        else
+          fail Dav::Exception::BadRequest, "You cannot create a time-range filter on a #{component.name} component"
+        end
+      end
+    end
+  end
+end

data/lib/tilia/cal_dav/calendar_root.rb

@@ -0,0 +1,57 @@
+module Tilia
+  module CalDav
+    # Calendars collection
+    #
+    # This object is responsible for generating a list of calendar-homes for each
+    # user.
+    #
+    # This is the top-most node for the calendars tree. In most servers this class
+    # represents the "/calendars" path.
+    class CalendarRoot < DavAcl::AbstractPrincipalCollection
+      # @!attribute [r] caldav_backend
+      #   @!visibility private
+      #   CalDAV backend
+      #
+      #   @var Sabre\CalDAV\Backend\BackendInterface
+
+      # Constructor
+      #
+      # This constructor needs both an authentication and a caldav backend.
+      #
+      # By default this class will show a list of calendar collections for
+      # principals in the 'principals' collection. If your main principals are
+      # actually located in a different path, use the principal_prefix argument
+      # to override this.
+      #
+      # @param PrincipalBackend\BackendInterface principal_backend
+      # @param Backend\BackendInterface caldav_backend
+      # @param string principal_prefix
+      def initialize(principal_backend, caldav_backend, principal_prefix = 'principals')
+        super(principal_backend, principal_prefix)
+        @caldav_backend = caldav_backend
+      end
+
+      # Returns the nodename
+      #
+      # We're overriding this, because the default will be the 'principalPrefix',
+      # and we want it to be Sabre\CalDAV\Plugin::CALENDAR_ROOT
+      #
+      # @return string
+      def name
+        Plugin::CALENDAR_ROOT
+      end
+
+      # This method returns a node for a principal.
+      #
+      # The passed array contains principal information, and is guaranteed to
+      # at least contain a uri item. Other properties may or may not be
+      # supplied by the authentication backend.
+      #
+      # @param array principal
+      # @return \Sabre\DAV\INode
+      def child_for_principal(principal)
+        CalendarHome.new(@caldav_backend, principal)
+      end
+    end
+  end
+end

data/lib/tilia/cal_dav/exception.rb

@@ -0,0 +1,7 @@
+module Tilia
+  module CalDav
+    module Exception
+      require 'tilia/cal_dav/exception/invalid_component_type'
+    end
+  end
+end

data/lib/tilia/cal_dav/exception/invalid_component_type.rb

@@ -0,0 +1,21 @@
+module Tilia
+  module CalDav
+    module Exception
+      # InvalidComponentType
+      class InvalidComponentType < Dav::Exception::Forbidden
+        # Adds in extra information in the xml response.
+        #
+        # This method adds the {CALDAV:}supported-calendar-component as defined in rfc4791
+        #
+        # @param DAV\Server server
+        # @param \DOMElement error_node
+        # @return void
+        def serialize(_server, error_node)
+          error = LibXML::XML::Node.new('cal:supported-calendar-component')
+          LibXML::XML::Namespace.new(error, 'cal', Plugin::NS_CALDAV)
+          error_node << error
+        end
+      end
+    end
+  end
+end

data/lib/tilia/cal_dav/i_calendar.rb

@@ -0,0 +1,11 @@
+module Tilia
+  module CalDav
+    # Calendar interface
+    #
+    # Implement this interface to allow a node to be recognized as an calendar.
+    module ICalendar
+      include ICalendarObjectContainer
+      include DavAcl::IAcl
+    end
+  end
+end

data/lib/tilia/cal_dav/i_calendar_object.rb

@@ -0,0 +1,13 @@
+module Tilia
+  module CalDav
+    # CalendarObject interface
+    #
+    # Extend the ICalendarObject interface to allow your custom nodes to be picked up as
+    # CalendarObjects.
+    #
+    # Calendar objects are resources such as Events, Todo's or Journals.
+    module ICalendarObject
+      include Dav::IFile
+    end
+  end
+end

data/lib/tilia/cal_dav/i_calendar_object_container.rb

@@ -0,0 +1,32 @@
+module Tilia
+  module CalDav
+    # This interface represents a node that may contain calendar objects.
+    #
+    # This is the shared parent for both the Inbox collection and calendars
+    # resources.
+    #
+    # In most cases you will likely want to look at ICalendar instead of this
+    # interface.
+    module ICalendarObjectContainer
+      include Dav::ICollection
+
+      # Performs a calendar-query on the contents of this calendar.
+      #
+      # The calendar-query is defined in RFC4791 : CalDAV. Using the
+      # calendar-query it is possible for a client to request a specific set of
+      # object, based on contents of iCalendar properties, date-ranges and
+      # iCalendar component types (VTODO, VEVENT).
+      #
+      # This method should just return a list of (relative) urls that match this
+      # query.
+      #
+      # The list of filters are specified as an array. The exact array is
+      # documented by \Sabre\CalDAV\CalendarQueryParser.
+      #
+      # @param array filters
+      # @return array
+      def calendar_query(filters)
+      end
+    end
+  end
+end

data/lib/tilia/cal_dav/i_shareable_calendar.rb

@@ -0,0 +1,40 @@
+module Tilia
+  module CalDav
+    # This interface represents a Calendar that can be shared with other users.
+    module IShareableCalendar
+      include ICalendar
+
+      # Updates the list of shares.
+      #
+      # The first array is a list of people that are to be added to the
+      # calendar.
+      #
+      # Every element in the add array has the following properties:
+      #   * href - A url. Usually a mailto: address
+      #   * commonName - Usually a first and last name, or false
+      #   * summary - A description of the share, can also be false
+      #   * readOnly - A boolean value
+      #
+      # Every element in the remove array is just the address string.
+      #
+      # @param array add
+      # @param array remove
+      # @return void
+      def update_shares(add, remove)
+      end
+
+      # Returns the list of people whom this calendar is shared with.
+      #
+      # Every element in this array should have the following properties:
+      #   * href - Often a mailto: address
+      #   * commonName - Optional, for example a first + last name
+      #   * status - See the Sabre\CalDAV\SharingPlugin::STATUS_ constants.
+      #   * readOnly - boolean
+      #   * summary - Optional, a description for the share
+      #
+      # @return array
+      def shares
+      end
+    end
+  end
+end