def _addAvailabilityComponent(self, component, lowerLimit, upperLimit):
"""
Add the specified master VAVAILABILITY Component to the instance list, expanding it
within the supplied time range. VAVAILABILITY components are not recurring, they have an
optional DTSTART and DTEND/DURATION defining a single time-range which may be bounded
depending on the presence of the properties. If unbounded at one or both ends, we will
set the time to 1/1/1900 in the past and 1/1/3000 in the future.
@param component: the Component to expand
@param limit: the end L{DateTime} for expansion
"""
start = component.getStartDateUTC()
if start:
lowerLimit, upperLimit = self._setupLimits(start, lowerLimit,
upperLimit)
if start is not None and start >= upperLimit:
# If the availability is beyond the end of the range we want, ignore it
return
if start is None:
start = DateTime(1900, 1, 1, 0, 0, 0, tzid=Timezone(utc=True))
start = self.normalizeFunction(start)
end = component.getEndDateUTC()
if lowerLimit is not None and end is not None and end < lowerLimit:
# If the availability is before the start of the range we want, ignore it
return
if end is None:
end = DateTime(2100, 1, 1, 0, 0, 0, tzid=Timezone(utc=True))
end = self.normalizeFunction(end)
self.addInstance(Instance(component, start, end))
def _deserialize(self, data):
"""
Convert a JSON compatible serialization of this object into the actual object.
"""
self.start = DateTime.parseText(data["start"]) if data["start"] else None
self.end = DateTime.parseText(data["end"]) if data["end"] else None
self.tzinfo = Timezone(tzid=data["tzinfo"]) if data["tzinfo"] else None
def timeZoneSecondsOffset(self, relative_to_utc=False):
if self.mTZUTC:
return 0
if self.mTZOffset is None:
tz = Timezone(utc=self.mTZUTC, tzid=self.mTZID)
self.mTZOffset = tz.timeZoneSecondsOffset(self, relative_to_utc)
return self.mTZOffset
def timeZoneSecondsOffset(self, relative_to_utc=False):
if self.mTZUTC:
return 0
if self.mTZOffset is None:
tz = Timezone(utc=self.mTZUTC, tzid=self.mTZID)
self.mTZOffset = tz.timeZoneSecondsOffset(self, relative_to_utc)
return self.mTZOffset
def setDefaultTimezoneID(self, tzid):
# Check for UTC
if tzid == "UTC":
temp = Timezone(utc=True)
self.setDefaultTimezone(temp)
else:
temp = Timezone(utc=False, tzid=tzid)
self.setDefaultTimezone(temp)
def testDuplicateInSet(self):
s = set((
DateTime(2011, 1, 1, 0, 0, 0, tzid=Timezone(utc=True)),
DateTime(2011, 1, 2, 0, 0, 0, tzid=Timezone(utc=True)),
))
self.assertTrue(
DateTime(2011, 1, 1, 0, 0, 0, tzid=Timezone(utc=True)) in s)
self.assertFalse(
DateTime(2011, 1, 3, 0, 0, 0, tzid=Timezone(utc=True)) in s)
def test_truncatedApr(self):
"""
Custom VTZ with truncated standard time - 2006. Daylight 2007 OK.
"""
TimezoneCache.create(empty=True)
TimezoneCache.clear()
self.doTest("TruncatedApr01.ics",
DateTime(2007, 04, 01, 16, 0, 0, Timezone(utc=True)),
DateTime(2007, 04, 01, 17, 0, 0, Timezone(utc=True)))
def test_truncatedDec(self):
"""
Custom VTZ valid from 2007. Daylight 2007 OK.
"""
TimezoneCache.create(empty=True)
TimezoneCache.clear()
self.doTest("TruncatedDec10.ics",
DateTime(2007, 12, 10, 17, 0, 0, Timezone(utc=True)),
DateTime(2007, 12, 10, 18, 0, 0, Timezone(utc=True)))
def test_truncatedDecThenApr(self):
"""
Custom VTZ valid from 2007 loaded first. Daylight 2007 OK.
"""
TimezoneCache.create(empty=True)
TimezoneCache.clear()
self.doTest("TruncatedDec10.ics",
DateTime(2007, 12, 10, 17, 0, 0, Timezone(utc=True)),
DateTime(2007, 12, 10, 18, 0, 0, Timezone(utc=True)))
self.doTest("TruncatedApr01.ics",
DateTime(2007, 04, 01, 16, 0, 0, Timezone(utc=True)),
DateTime(2007, 04, 01, 17, 0, 0, Timezone(utc=True)))
def test_normalizeForExpand(self):
"""
Test that dateops.normalizeForExpand works correctly on all four types of date/time: date only, floating, UTC and local time.
"""
data = (
(DateTime(2012, 1, 1), DateTime(2012, 1, 1)),
(DateTime(2012, 1, 1, 10, 0, 0), DateTime(2012, 1, 1, 10, 0, 0)),
(DateTime(2012, 1, 1, 11, 0, 0, tzid=Timezone(utc=True)), DateTime(2012, 1, 1, 11, 0, 0, tzid=Timezone(utc=True))),
(DateTime(2012, 1, 1, 12, 0, 0, tzid=Timezone(tzid="America/New_York")), DateTime(2012, 1, 1, 17, 0, 0, tzid=Timezone(utc=True))),
)
for value, result in data:
self.assertEqual(normalizeForExpand(value), result)
def _deserialize(self, data):
"""
Convert a JSON compatible serialization of this object into the actual object.
"""
self.start = DateTime.parseText(data["start"]) if data["start"] else None
self.end = DateTime.parseText(data["end"]) if data["end"] else None
self.tzinfo = Timezone(tzid=data["tzinfo"]) if data["tzinfo"] else None
def getNowUTC():
# Get from posix time
now = time.time()
now_tm = time.gmtime(now)
tzid = Timezone(utc=True)
return DateTime(year=now_tm.tm_year, month=now_tm.tm_mon, day=now_tm.tm_mday, hours=now_tm.tm_hour, minutes=now_tm.tm_min, seconds=now_tm.tm_sec, tzid=tzid)
def compareDateTime(self, comp):
if comp is None:
return 1
# If either are date only, then just do date compare
if self.mDateOnly or comp.mDateOnly:
c = cmp(self.mYear, comp.mYear)
if c == 0:
c = cmp(self.mMonth, comp.mMonth)
if c == 0:
c = cmp(self.mDay, comp.mDay)
return c
# If they have the same timezone do simple compare - no posix calc
# needed
elif (Timezone.same(self.mTZUTC, self.mTZID, comp.mTZUTC, comp.mTZID)):
c = cmp(self.mYear, comp.mYear)
if c == 0:
c = cmp(self.mMonth, comp.mMonth)
if c == 0:
c = cmp(self.mDay, comp.mDay)
if c == 0:
c = cmp(self.mHours, comp.mHours)
if c == 0:
c = cmp(self.mMinutes, comp.mMinutes)
if c == 0:
c = cmp(self.mSeconds, comp.mSeconds)
return c
else:
return cmp(self.getPosixTime(), comp.getPosixTime())
def compareDateTime(self, comp):
if comp is None:
return 1
# If either are date only, then just do date compare
if self.mDateOnly or comp.mDateOnly:
c = cmp(self.mYear, comp.mYear)
if c == 0:
c = cmp(self.mMonth, comp.mMonth)
if c == 0:
c = cmp(self.mDay, comp.mDay)
return c
# If they have the same timezone do simple compare - no posix calc
# needed
elif (Timezone.same(self.mTZUTC, self.mTZID, comp.mTZUTC, comp.mTZID)):
c = cmp(self.mYear, comp.mYear)
if c == 0:
c = cmp(self.mMonth, comp.mMonth)
if c == 0:
c = cmp(self.mDay, comp.mDay)
if c == 0:
c = cmp(self.mHours, comp.mHours)
if c == 0:
c = cmp(self.mMinutes, comp.mMinutes)
if c == 0:
c = cmp(self.mSeconds, comp.mSeconds)
return c
else:
return cmp(self.getPosixTime(), comp.getPosixTime())
def test_query_not_extended(self):
"""
Query test - two terms not anyof
"""
filter = caldavxml.Filter(
caldavxml.ComponentFilter(
*[
caldavxml.ComponentFilter(**{"name": ("VEVENT")}),
caldavxml.ComponentFilter(**{"name": ("VTODO")}),
], **{"name": "VCALENDAR"}))
filter = Filter(filter)
filter.child.settzinfo(Timezone(tzid="America/New_York"))
expression = buildExpression(filter, self._queryFields)
sql = CalDAVSQLQueryGenerator(expression, self, 1234)
select, args, usedtimerange = sql.generate()
self.assertEqual(
select.toSQL(),
SQLFragment(
"select distinct RESOURCE_NAME, ICALENDAR_UID, ICALENDAR_TYPE from CALENDAR_OBJECT where CALENDAR_RESOURCE_ID = ? and ICALENDAR_TYPE = ? and ICALENDAR_TYPE = ?",
[1234, "VEVENT", "VTODO"]))
self.assertEqual(args, {})
self.assertEqual(usedtimerange, False)
def test_timerange_query(self):
"""
Basic query test with time range
"""
filter = caldavxml.Filter(
caldavxml.ComponentFilter(
*[
caldavxml.ComponentFilter(
*[
caldavxml.TimeRange(
**{
"start": "20060605T160000Z",
"end": "20060605T170000Z"
})
],
**{"name": ("VEVENT", "VFREEBUSY", "VAVAILABILITY")})
], **{"name": "VCALENDAR"}))
filter = Filter(filter)
filter.child.settzinfo(Timezone(tzid="America/New_York"))
j = filter.serialize()
self.assertEqual(j["type"], "Filter")
f = FilterBase.deserialize(j)
self.assertTrue(isinstance(f, Filter))
self.assertTrue(isinstance(f.child.filters[0].qualifier, TimeRange))
self.assertTrue(
isinstance(f.child.filters[0].qualifier.tzinfo, Timezone))
self.assertEqual(f.child.filters[0].qualifier.tzinfo.getTimezoneID(),
"America/New_York")
def test_query(self):
"""
Basic query test - no time range
"""
filter = caldavxml.Filter(
caldavxml.ComponentFilter(
*[
caldavxml.ComponentFilter(
**{"name": ("VEVENT", "VFREEBUSY", "VAVAILABILITY")})
], **{"name": "VCALENDAR"}))
filter = Filter(filter)
filter.child.settzinfo(Timezone(tzid="America/New_York"))
expression = buildExpression(filter, self._queryFields)
sql = CalDAVSQLQueryGenerator(expression, self, 1234)
select, args, usedtimerange = sql.generate()
self.assertEqual(
select.toSQL(),
SQLFragment(
"select distinct RESOURCE_NAME, ICALENDAR_UID, ICALENDAR_TYPE from CALENDAR_OBJECT where CALENDAR_RESOURCE_ID = ? and ICALENDAR_TYPE in (?, ?, ?)",
[1234, Parameter('arg1', 3)]))
self.assertEqual(args,
{"arg1": ("VEVENT", "VFREEBUSY", "VAVAILABILITY")})
self.assertEqual(usedtimerange, False)
def match(self, component, access=None):
"""
Returns True if the given calendar component matches this filter, False
otherwise.
"""
# We only care about certain access restrictions.
if access not in (Component.ACCESS_CONFIDENTIAL,
Component.ACCESS_RESTRICTED):
access = None
# We need to prepare ourselves for a time-range query by pre-calculating
# the set of instances up to the latest time-range limit. That way we can
# avoid having to do some form of recurrence expansion for each query sub-part.
maxend, isStartTime = self.getmaxtimerange()
if maxend:
if isStartTime:
if component.isRecurringUnbounded():
# Unbounded recurrence is always within a start-only time-range
instances = None
else:
# Expand the instances up to infinity
instances = component.expandTimeRanges(
DateTime(2100, 1, 1, 0, 0, 0, tzid=Timezone(utc=True)),
ignoreInvalidInstances=True)
else:
instances = component.expandTimeRanges(
maxend, ignoreInvalidInstances=True)
else:
instances = None
self.child.setInstances(instances)
# <filter> contains exactly one <comp-filter>
return self.child.match(component, access)
def test_query_text(self):
"""
Basic query test with time range
"""
filter = caldavxml.Filter(
caldavxml.ComponentFilter(
*[
caldavxml.ComponentFilter(
caldavxml.PropertyFilter(
caldavxml.TextMatch.fromString("1234", False),
name="UID",
), **{"name": ("VEVENT")}),
], **{
"name": "VCALENDAR",
"test": "anyof"
}))
filter = Filter(filter)
filter.child.settzinfo(Timezone(tzid="America/New_York"))
j = filter.serialize()
self.assertEqual(j["type"], "Filter")
f = FilterBase.deserialize(j)
self.assertTrue(isinstance(f, Filter))
self.assertTrue(
isinstance(f.child.filters[0].filters[0], PropertyFilter))
self.assertTrue(
isinstance(f.child.filters[0].filters[0].qualifier, TextMatch))
self.assertEqual(f.child.filters[0].filters[0].qualifier.text, "1234")
def test_query_extended(self):
"""
Basic query test with time range
"""
filter = caldavxml.Filter(
caldavxml.ComponentFilter(
*[
caldavxml.ComponentFilter(
*[
caldavxml.TimeRange(**{
"start": "20060605T160000Z",
})
], **{"name": ("VEVENT")}),
caldavxml.ComponentFilter(**{"name": ("VTODO")}),
], **{
"name": "VCALENDAR",
"test": "anyof"
}))
filter = Filter(filter)
filter.child.settzinfo(Timezone(tzid="America/New_York"))
j = filter.serialize()
self.assertEqual(j["type"], "Filter")
f = FilterBase.deserialize(j)
self.assertTrue(isinstance(f, Filter))
self.assertEqual(len(f.child.filters), 2)
self.assertTrue(isinstance(f.child.filters[0].qualifier, TimeRange))
def test_not_in_cache(self):
TimezoneCache.create()
data = """BEGIN:VCALENDAR
VERSION:2.0
BEGIN:VTIMEZONE
TZID:US-Eastern
LAST-MODIFIED:19870101T000000Z
BEGIN:STANDARD
DTSTART:19671029T020000
RRULE:FREQ=YEARLY;BYDAY=-1SU;BYMONTH=10
TZOFFSETFROM:-0400
TZOFFSETTO:-0500
TZNAME:Eastern Standard Time (US & Canada)
END:STANDARD
BEGIN:DAYLIGHT
DTSTART:19870405T020000
RRULE:FREQ=YEARLY;BYDAY=1SU;BYMONTH=4
TZOFFSETFROM:-0500
TZOFFSETTO:-0400
TZNAME:Eastern Daylight Time (US & Canada)
END:DAYLIGHT
END:VTIMEZONE
BEGIN:VEVENT
UID:12345-67890
DTSTART;TZID="US-Eastern":20071225T000000
DTEND;TZID="US-Eastern":20071225T010000
ATTENDEE:mailto:[email protected]
ATTENDEE:mailto:[email protected]
END:VEVENT
END:VCALENDAR
"""
calendar = Component.fromString(data)
if calendar.name() != "VCALENDAR":
self.fail("Calendar is not a VCALENDAR")
instances = calendar.expandTimeRanges(DateTime(2100, 1, 1))
for key in instances:
instance = instances[key]
start = instance.start
end = instance.end
self.assertEqual(
start, DateTime(2007, 12, 25, 05, 0, 0, Timezone(utc=True)))
self.assertEqual(
end, DateTime(2007, 12, 25, 06, 0, 0, Timezone(utc=True)))
break
def testDuplicateASUTC(self):
items = ((
DateTime(2011, 1, 1, 0, 0, 0, tzid=Timezone(utc=True)),
DateTime(2011, 1, 1, 0, 0, 0, tzid=Timezone(utc=True)),
), (
DateTime(2011, 1, 1, 0, 0, 0),
DateTime(2011, 1, 1, 0, 0, 0),
), (
DateTime(2011, 1, 1),
DateTime(2011, 1, 1),
))
for item, result in items:
dup = item.duplicateAsUTC()
self.assertEqual(str(dup), str(result),
"Failed to convert '%s'" % (item, ))
def test_truncatedAprThenDecOK(self):
"""
VTZ loaded from std timezone DB. 2007 OK.
"""
TimezoneCache.create()
self.doTest(
"TruncatedApr01.ics",
DateTime(2007, 04, 01, 16, 0, 0, Timezone(utc=True)),
DateTime(2007, 04, 01, 17, 0, 0, Timezone(utc=True)),
)
self.doTest(
"TruncatedDec10.ics",
DateTime(2007, 12, 10, 17, 0, 0, Timezone(utc=True)),
DateTime(2007, 12, 10, 18, 0, 0, Timezone(utc=True)),
)
def test_truncatedAprThenDecFail(self):
"""
Custom VTZ with truncated standard time - 2006 loaded first. Daylight 2007 OK, standard 2007 wrong.
"""
TimezoneCache.create(empty=True)
TimezoneCache.clear()
self.doTest(
"TruncatedApr01.ics",
DateTime(2007, 04, 01, 16, 0, 0, Timezone(utc=True)),
DateTime(2007, 04, 01, 17, 0, 0, Timezone(utc=True)),
)
self.doTest("TruncatedDec10.ics",
DateTime(2007, 12, 10, 17, 0, 0, Timezone(utc=True)),
DateTime(2007, 12, 10, 18, 0, 0, Timezone(utc=True)),
testEqual=False)
def processAvailabilityFreeBusy(calendar, fbinfo, timerange):
"""
Extract free-busy data from a VAVAILABILITY component.
@param calendar: the L{Component} that is the VCALENDAR containing the VAVAILABILITY's.
@param fbinfo: the tuple used to store the three types of fb data.
@param timerange: the time range to restrict free busy data to.
"""
for vav in [
x for x in calendar.subcomponents() if x.name() == "VAVAILABILITY"
]:
# Get overall start/end
start = vav.getStartDateUTC()
if start is None:
start = DateTime(1900, 1, 1, 0, 0, 0, tzid=Timezone(utc=True))
end = vav.getEndDateUTC()
if end is None:
end = DateTime(2100, 1, 1, 0, 0, 0, tzid=Timezone(utc=True))
period = Period(start, end)
overall = clipPeriod(period, Period(timerange.start, timerange.end))
if overall is None:
continue
# Now get periods for each instance of AVAILABLE sub-components
periods = processAvailablePeriods(vav, timerange)
# Now invert the periods and store in accumulator
busyperiods = []
last_end = timerange.start
for period in periods:
if last_end < period.getStart():
busyperiods.append(Period(last_end, period.getStart()))
last_end = period.getEnd()
if last_end < timerange.end:
busyperiods.append(Period(last_end, timerange.end))
# Add to actual results mapped by busy type
fbtype = vav.propertyValue("BUSYTYPE")
if fbtype is None:
fbtype = "BUSY-UNAVAILABLE"
fbinfo[fbtype_mapper.get(fbtype, 2)].extend(busyperiods)
def test_vlarm_undefined(self):
filter = caldavxml.Filter(
caldavxml.ComponentFilter(
*[
caldavxml.ComponentFilter(
*[
caldavxml.ComponentFilter(caldavxml.IsNotDefined(),
**{"name": "VALARM"})
], **{"name": "VEVENT"})
], **{"name": "VCALENDAR"}))
filter = Filter(filter)
filter.child.settzinfo(Timezone(tzid="America/New_York"))
self.assertFalse(
filter.match(
Component.fromString("""BEGIN:VCALENDAR
CALSCALE:GREGORIAN
PRODID:-//Example Inc.//Example Calendar//EN
VERSION:2.0
BEGIN:VTIMEZONE
LAST-MODIFIED:20040110T032845Z
TZID:US/Eastern
BEGIN:DAYLIGHT
DTSTART:20000404T020000
RRULE:FREQ=YEARLY;BYDAY=1SU;BYMONTH=4
TZNAME:EDT
TZOFFSETFROM:-0500
TZOFFSETTO:-0400
END:DAYLIGHT
BEGIN:STANDARD
DTSTART:20001026T020000
RRULE:FREQ=YEARLY;BYDAY=-1SU;BYMONTH=10
TZNAME:EST
TZOFFSETFROM:-0400
TZOFFSETTO:-0500
END:STANDARD
END:VTIMEZONE
BEGIN:VEVENT
DTSTAMP:20051222T210412Z
CREATED:20060102T150000Z
DTSTART;TZID=US/Eastern:20130102T100000
DURATION:PT1H
RRULE:FREQ=DAILY;COUNT=5
SUMMARY:event 5
UID:[email protected]
CATEGORIES:cool,hot
CATEGORIES:warm
BEGIN:VALARM
ACTION:AUDIO
TRIGGER;RELATED=START:-PT10M
END:VALARM
END:VEVENT
END:VCALENDAR
""")))
def sample(self):
offset = PyDuration(seconds=int(self._helperDistribution.sample()))
beginning = self.now(Timezone(tzid=self._tzname))
while offset:
start, end = self._findWorkAfter(beginning)
if end - start > offset:
result = start + offset
result.setMinutes(result.getMinutes() // 15 * 15)
result.setSeconds(0)
return result
offset.setDuration(offset.getTotalSeconds() - (end - start).getTotalSeconds())
beginning = end
def gettimezone(self):
"""
Get the timezone to use. If none, return UTC timezone.
@return: the L{Timezone} derived from the VTIMEZONE or utc.
"""
calendar = self.calendar()
if calendar is not None:
tz = calendar.gettimezone()
if tz is not None:
return tz
# Default to using utc tzinfo
return Timezone(utc=True)
def floatoffset(dt, pytz):
"""
Apply the timezone offset to the supplied time, then force tz to utc. This gives the local
date-time as if the local tz were UTC. It can be used in floating time comparisons with UTC date-times.
@param dt: a L{DateTime} object to normalize
@param pytz: a L{Timezone} object to apply offset from
@return: the normalized DateTime
"""
if pytz is None:
pytz = Timezone(utc=True)
dt = dt.duplicate()
dt.adjustTimezone(pytz)
dt.setTimezoneUTC(True)
return dt
def test_query(self):
"""
Basic query test - no time range
"""
filter = caldavxml.Filter(
caldavxml.ComponentFilter(
*[
caldavxml.ComponentFilter(
**{"name": ("VEVENT", "VFREEBUSY", "VAVAILABILITY")})
], **{"name": "VCALENDAR"}))
filter = Filter(filter)
filter.child.settzinfo(Timezone(tzid="America/New_York"))
j = filter.serialize()
self.assertEqual(j["type"], "Filter")
f = FilterBase.deserialize(j)
self.assertTrue(isinstance(f, Filter))
def settimezone(self, tzelement):
"""
Set the default timezone to use with this query.
@param calendar: a L{Component} for the VCALENDAR containing the one
VTIMEZONE that we want
@return: the L{Timezone} derived from the VTIMEZONE or utc.
"""
if tzelement is None:
tz = None
elif isinstance(tzelement, CalDAVTimeZoneElement):
tz = tzelement.gettimezone()
elif isinstance(tzelement, Component):
tz = tzelement.gettimezone()
if tz is None:
tz = Timezone(utc=True)
self.child.settzinfo(tz)
return tz
def adjustToUTC(self):
if self.local() and not self.mDateOnly:
# Cache and restore and adjust the posix value to avoid a recalc since it won't change during this adjust
tempPosix = self.mPosixTime if self.mPosixTimeCached else None
utc = Timezone(utc=True)
offset_from = self.timeZoneSecondsOffset()
self.setTimezone(utc)
self.offsetSeconds(-offset_from)
if tempPosix is not None:
self.mPosixTimeCached = True
self.mPosixTime = tempPosix
self.mTZOffset = 0
return self
def test_workdistribution(self):
tzname = "US/Eastern"
dist = WorkDistribution(["mon", "wed", "thu", "sat"], 10, 20, tzname)
dist._helperDistribution = UniformDiscreteDistribution([35 * 60 * 60 + 30 * 60])
dist.now = lambda tzname = None: DateTime(2011, 5, 29, 18, 5, 36, tzid=tzname)
value = dist.sample()
self.assertEqual(
# Move past three workdays - monday, wednesday, thursday - using 30
# of the hours, and then five and a half hours into the fourth
# workday, saturday. Workday starts at 10am, so the sample value
# is 3:30pm, ie 1530 hours.
DateTime(2011, 6, 4, 15, 30, 0, tzid=Timezone(tzid=tzname)),
value
)
dist = WorkDistribution(["mon", "tue", "wed", "thu", "fri"], 10, 20, tzname)
dist._helperDistribution = UniformDiscreteDistribution([35 * 60 * 60 + 30 * 60])
value = dist.sample()
self.assertTrue(isinstance(value, DateTime))
class TimeRange (FilterBase):
"""
Specifies a time for testing components against.
"""
serialized_name = "TimeRange"
def __init__(self, xml_element):
super(TimeRange, self).__init__(xml_element)
if xml_element is None:
return
# One of start or end must be present
if "start" not in xml_element.attributes and "end" not in xml_element.attributes:
raise ValueError("One of 'start' or 'end' must be present in CALDAV:time-range")
self.start = DateTime.parseText(xml_element.attributes["start"]) if "start" in xml_element.attributes else None
self.end = DateTime.parseText(xml_element.attributes["end"]) if "end" in xml_element.attributes else None
self.tzinfo = None
def _deserialize(self, data):
"""
Convert a JSON compatible serialization of this object into the actual object.
"""
self.start = DateTime.parseText(data["start"]) if data["start"] else None
self.end = DateTime.parseText(data["end"]) if data["end"] else None
self.tzinfo = Timezone(tzid=data["tzinfo"]) if data["tzinfo"] else None
def serialize(self):
"""
Create a JSON compatible serialization of this object - will be used in a cross-pod request.
"""
result = super(TimeRange, self).serialize()
result.update({
"start": self.start.getText() if self.start else None,
"end": self.end.getText() if self.end else None,
"tzinfo": self.tzinfo.getTimezoneID() if self.tzinfo else None,
})
return result
def settzinfo(self, tzinfo):
"""
Set the default timezone to use with this query.
@param tzinfo: a L{Timezone} to use.
"""
# Give tzinfo to any TimeRange we have
self.tzinfo = tzinfo
def valid(self, level=0):
"""
Indicate whether the time-range is valid (must be date-time in UTC).
@return: True if valid, False otherwise
"""
if self.start is not None and self.start.isDateOnly():
log.info("start attribute in <time-range> is not a date-time: %s" % (self.start,))
return False
if self.end is not None and self.end.isDateOnly():
log.info("end attribute in <time-range> is not a date-time: %s" % (self.end,))
return False
if self.start is not None and not self.start.utc():
log.info("start attribute in <time-range> is not UTC: %s" % (self.start,))
return False
if self.end is not None and not self.end.utc():
log.info("end attribute in <time-range> is not UTC: %s" % (self.end,))
return False
# No other tests
return True
def match(self, property, access=None):
"""
NB This is only called when doing a time-range match on a property.
"""
if property is None:
return False
else:
return property.containsTimeRange(self.start, self.end, self.tzinfo)
def matchinstance(self, component, instances):
"""
Test whether this time-range element causes a match to the specified component
using the specified set of instances to determine the expanded time ranges.
@param component: the L{Component} to test.
@param instances: the list of expanded instances.
@return: True if the time-range query matches, False otherwise.
"""
if component is None:
return False
assert instances is not None or self.end is None, "Failure to expand instance for time-range filter: %r" % (self,)
# Special case open-ended unbounded
if instances is None:
if component.getRecurrenceIDUTC() is None:
return True
else:
# See if the overridden component's start is past the start
start, _ignore_end = component.getEffectiveStartEnd()
if start is None:
return True
else:
return start >= self.start
# Handle alarms as a special case
alarms = (component.name() == "VALARM")
if alarms:
testcomponent = component._parent
else:
testcomponent = component
for key in instances:
instance = instances[key]
# First make sure components match
if not testcomponent.same(instance.component):
continue
if alarms:
# Get all the alarm triggers for this instance and test each one
triggers = instance.getAlarmTriggers()
for trigger in triggers:
if timeRangesOverlap(trigger, None, self.start, self.end, self.tzinfo):
return True
else:
# Regular instance overlap test
if timeRangesOverlap(instance.start, instance.end, self.start, self.end, self.tzinfo):
return True
return False
def timeZoneDescriptor(self):
tz = Timezone(utc=self.mTZUTC, tzid=self.mTZID)
return tz.timeZoneDescriptor(self)