def outbound(peers, item, filter=None, debug=False):
rv = peers[0].itsView
if filter is None:
filter = lambda rs: rs
else:
filter = filter.sync_filter
# At some point, which serializer and translator to use should be
# configurable
serializer = eimml.EIMMLSerializer # only using class methods
trans = translator.SharingTranslator(rv)
rsInternal = {}
items = [item]
version = str(item.itsVersion)
if pim.has_stamp(item, pim.EventStamp):
for mod in pim.EventStamp(item).modifications or []:
# modifications that have been changed purely by
# auto-triage shouldn't have recordsets created for them
if not (isinstance(mod, pim.Note)
and pim.EventStamp(mod).isTriageOnlyModification()
and pim.EventStamp(mod).simpleAutoTriage()
== mod._triageStatus):
items.append(mod)
for item in items:
alias = trans.getAliasForItem(item)
rsInternal[alias] = filter(eim.RecordSet(trans.exportItem(item)))
if not pim.has_stamp(item, shares.SharedItem):
shares.SharedItem(item).add()
shared = shares.SharedItem(item)
# Abort if pending conflicts
if shared.conflictingStates:
raise errors.ConflictsPending(_(u"Conflicts pending."))
for peer in peers:
state = shared.getPeerState(peer)
# Set agreed state to what we have locally
state.agreed = rsInternal[alias]
# Repository identifier:
if rv.repository is not None:
repoId = rv.repository.getSchemaInfo()[0].str16()
else:
repoId = ""
text = serializer.serialize(rv,
rsInternal,
rootName="item",
repo=repoId,
version=version)
return text
def testOrdering(self):
def key(item):
return (item._triageStatus, item._triageStatusChanged)
items = sorted(schema.ns("osaf.pim", self.view).allCollection, key=key)
displayNames = list(item.displayName for item in items
if pim.EventStamp(item).rruleset is None
or pim.EventStamp(item).occurrenceFor is not None)
# Don't test exact item order, since the recurring events (plus
# auto-triage) make the exact order complicated. Rather, check the
# first few (non-recurring) items ...
def failUnlessItemMatches(itemName, index):
item = self.getItem(itemName)
self.failUnlessEqual(displayNames[index], item.displayName)
failUnlessItemMatches(u'Welcome to Chandler\u2122', 0)
failUnlessItemMatches(u'Next dentist appointment?', 1)
failUnlessItemMatches(u'Tell a friend about Chandler', 2)
failUnlessItemMatches(u'Write-up...', 3)
failUnlessItemMatches(u'Follow up with...on...', 4)
failUnlessItemMatches(u'Start planning vacation', 5)
# ... as well as the very last item
failUnlessItemMatches(u'Download Chandler!', -1)
def testSalsaClass(self):
item = self.getItem(u"Salsa Class")
self.checkStampness(item, pim.EventStamp)
masterEvent = pim.EventStamp(item).getMaster()
self.failIf(masterEvent.anyTime)
self.failIf(masterEvent.allDay)
self.failUnless(masterEvent.userReminderInterval is None)
self.failIfEqual(item.body, u'')
# Sundays at 2:30 PM
self.failUnlessEqual(masterEvent.effectiveStartTime.weekday(), 6)
self.failUnlessEqual(masterEvent.effectiveStartTime.time(),
time(14, 30))
self.failUnless(item in self.getCollection(u"Home"))
self.failUnless(item in self.getCollection(u"Fun"))
self.failUnless(item in schema.ns("osaf.pim", self.view).allCollection)
self.failUnlessEqual(len(list(item.appearsIn)), 3)
rruleset = masterEvent.rruleset
self.failUnlessEqual(len(list(rruleset.rrules)), 1)
self.failUnlessEqual(rruleset.rrules.first().freq, 'weekly')
self.failUnlessEqual(rruleset.rrules.first().interval, 1)
# Should have 2 or 3 DONE modifications (in the past) and
# one LATER or NOW
events = sorted(masterEvent.modifications,
key=lambda item: pim.EventStamp(item).startTime)
self.failUnless(len(events) in (3, 4))
ts = [x.triageStatus for x in events]
self.failUnless(ts[-1] in (pim.TriageEnum.later, pim.TriageEnum.now))
self.failUnlessEqual(set(ts[:-1]), set([pim.TriageEnum.done]))
def testCustomWeekly(self):
self.Import(self.view, 'CustomRecurWeekly.ics')
event = pim.EventStamp(
sharing.findUID(self.view, '431391D1-5CEB-4326-9AE2-7D87B8494E63'))
#### this one is fri/sat every other week
params = self.makeParams(event)
weekly = CustomRecurrenceDialog.extractIsWeekly(params)
self.failUnlessEqual(True, weekly)
days = CustomRecurrenceDialog.extractGuiWeekdays(params)
self.failUnlessEqual([5, 6], days) # assumes i18n first day is Sun
self.failUnlessEqual(2, CustomRecurrenceDialog.extractInterval(params))
#### every monday, weekly
event = pim.EventStamp(
sharing.findUID(self.view, 'A2A6E03B-18D6-4364-9455-6155FD2B7F1A'))
params = self.makeParams(event)
weekly = CustomRecurrenceDialog.extractIsWeekly(params)
self.failUnlessEqual(True, weekly)
days = CustomRecurrenceDialog.extractGuiWeekdays(params)
guiEventDay = CustomRecurrenceDialog._rr_weekday_to_gui(
event.startTime.weekday())
self.failUnless([1] == days or guiEventDay == 1)
self.failUnlessEqual(1, CustomRecurrenceDialog.extractInterval(params))
#### every sun/tue/thu
event = pim.EventStamp(
sharing.findUID(self.view, '00516393-29AF-4DF6-A786-51C7DDBDCCF8'))
params = self.makeParams(event)
weekly = CustomRecurrenceDialog.extractIsWeekly(params)
self.failUnlessEqual(True, weekly)
days = CustomRecurrenceDialog.extractGuiWeekdays(params)
self.failUnlessEqual([0, 2, 4], days)
self.failUnlessEqual(1, CustomRecurrenceDialog.extractInterval(params))
def testCustomMonthly(self):
self.Import(self.view, 'CustomRecurMonthly.ics')
event = pim.EventStamp(
sharing.findUID(self.view, 'AFAF34CC-827E-43EE-A7BB-004F7685E09E'))
#### monthly, first wed
params = self.makeParams(event)
weekly = CustomRecurrenceDialog.extractIsWeekly(params)
self.failUnlessEqual(False, weekly)
monthly = CustomRecurrenceDialog.extractIsMonthly(params)
self.failUnlessEqual(True, monthly)
tuples = CustomRecurrenceDialog.extractGuiByWeekday(params)
self.failUnlessEqual([(3, 1)], tuples)
self.failUnlessEqual(1, CustomRecurrenceDialog.extractInterval(params))
#### monthly, last thu
event = pim.EventStamp(
sharing.findUID(self.view, '1F9963CE-56D6-4C76-8C8A-444A9DF6A4C5'))
params = self.makeParams(event)
weekly = CustomRecurrenceDialog.extractIsWeekly(params)
self.failUnlessEqual(False, weekly)
monthly = CustomRecurrenceDialog.extractIsMonthly(params)
self.failUnlessEqual(True, monthly)
tuples = CustomRecurrenceDialog.extractGuiByWeekday(params)
self.failUnlessEqual([(4, -1)], tuples)
self.failUnlessEqual(1, CustomRecurrenceDialog.extractInterval(params))
def doRoundTripRecurrenceCountTest(self, tzName):
from osaf.pim.calendar.TimeZone import TimeZoneInfo
tzinfo = TimeZoneInfo.get(self.view)
tzPrefs = schema.ns('osaf.pim', self.view).TimezonePrefs
saveTz = tzinfo.default
saveShowUI = tzPrefs.showUI
tzinfo.default = self.view.tzinfo.getInstance(tzName)
try:
self.Import(self.view, u'Recurrence.ics')
event = pim.EventStamp(
sharing.findUID(self.view,
'5B30A574-02A3-11DA-AA66-000A95DA3228'))
third = event.getFirstOccurrence().getNextOccurrence(
).getNextOccurrence()
self.assertEqual(third.summary, u'\u00FCChanged title')
self.assertEqual(
third.recurrenceID,
datetime.datetime(2005,
8,
10,
tzinfo=self.view.tzinfo.floating))
# while were at it, test bug 3509, all day event duration is off by one
self.assertEqual(event.duration, datetime.timedelta(0))
# make sure we imported the floating EXDATE
event = pim.EventStamp(
sharing.findUID(self.view,
'07f3d6f0-4c04-11da-b671-0013ce40e90f'))
self.assertEqual(
event.rruleset.exdates[0],
datetime.datetime(2005,
12,
6,
12,
30,
tzinfo=self.view.tzinfo.floating))
# test count export, no timezones
vcalendar = getVObjectData(self.view, [event.itsItem])
self.assertEqual(vcalendar.vevent.rruleset._rrule[0]._count, 10)
# turn on timezones, putting event in Pacific time
pacific = self.view.tzinfo.getInstance("America/Los_Angeles")
TimeZoneInfo.get(self.view).default = pacific
schema.ns('osaf.pim', self.view).TimezonePrefs.showUI = True
self.assertEqual(event.startTime.tzinfo, pacific)
# test count export, with timezones turned on
vcalendar = getVObjectData(self.view, [event.itsItem])
self.assertEqual(vcalendar.vevent.rruleset._rrule[0]._count, 10)
finally:
# Restore global settings
tzPrefs.showUI = saveShowUI
tzinfo.default = saveTz
def checkTriageOnly(item):
"""
Return true if item is a triage-only modification whose triage matches its
startTime.
"""
return (isinstance(item, pim.Note) and
pim.EventStamp(item).isTriageOnlyModification() and
pim.EventStamp(item).simpleAutoTriage() == item._triageStatus)
def testNextDentist(self):
item = self.getItem(u"Next dentist appointment?")
self.checkStampness(item, pim.EventStamp)
self.failUnless(pim.EventStamp(item).anyTime)
self.failIf(pim.EventStamp(item).allDay)
self.failUnlessEqual(item.triageStatus, pim.TriageEnum.now)
self.failUnless(item.userReminderTime is None)
self.failUnless(item in self.getCollection(u"Home"))
self.failUnless(item in schema.ns("osaf.pim", self.view).allCollection)
self.failUnlessEqual(len(list(item.appearsIn)), 2)
def testSoundExhibit(self):
item = self.getItem(u"Class Trip: Exhibit on Sound!")
self.checkStampness(item, pim.EventStamp)
self.failUnless(pim.EventStamp(item).anyTime)
self.failIf(pim.EventStamp(item).allDay)
self.failUnlessEqual(
pim.EventStamp(item).effectiveStartTime.date().weekday(), 6)
self.failUnless(pim.EventStamp(item).location is not None)
self.failUnless(item.userReminderTime is None)
self.failUnless(item in self.getCollection(u"Fun"))
self.failUnless(item in schema.ns("osaf.pim", self.view).allCollection)
self.failUnlessEqual(len(list(item.appearsIn)), 2)
def testTaxes(self):
item = self.getItem(u"File taxes!")
self.checkStampness(item, pim.EventStamp, pim.TaskStamp)
self.failUnlessEqual(item.triageStatus, pim.TriageEnum.later)
self.failUnlessEqual(item.lastModification, pim.Modification.created)
self.failIf(item.userReminderTime is None)
self.failUnless(pim.EventStamp(item).userReminderInterval is None)
self.failIf(pim.EventStamp(item).allDay)
self.failUnless(pim.EventStamp(item).anyTime)
self.failUnless(item in self.getCollection(u"Home"))
self.failUnless(item in schema.ns("osaf.pim", self.view).allCollection)
self.failUnlessEqual(len(list(item.appearsIn)), 2)
def setAttributes(self, item, doWho=True):
try:
savedItems = self.savedAttrs
except AttributeError:
self.savedAttrs = {}
savedAttrs = SavedAttrs()
self.savedAttrs[item.itsName] = savedAttrs
displayName = 'aTitleOrHeadline'
item.displayName = displayName
savedAttrs.displayName = displayName
item.createdOn = self.savedAttrs[
item.itsName].createdOn = datetime.now(item.itsView.tzinfo.default)
if has_stamp(item, pim.TaskStamp):
task = pim.TaskStamp(item)
# Add some attributes here...
if has_stamp(item, pim.EventStamp):
event = pim.EventStamp(item)
if has_stamp(item, Mail.MailStamp):
mail = Mail.MailStamp(item)
"""
def testBiweeklyStatusReport(self):
item = self.getItem(u"Bi-Weekly Status Report")
self.checkStampness(item, pim.TaskStamp, pim.EventStamp)
self.failUnless(item in self.getCollection(u"Work"))
self.failUnless(item in schema.ns("osaf.pim", self.view).allCollection)
self.failUnlessEqual(len(list(item.appearsIn)), 2)
masterEvent = pim.EventStamp(item).getMaster()
self.failUnless(masterEvent.anyTime)
self.failIf(masterEvent.allDay)
self.failUnless(masterEvent.userReminderInterval is None)
firstOccurrence = masterEvent.getFirstOccurrence()
self.failUnlessEqual(firstOccurrence.itsItem.triageStatus,
pim.TriageEnum.now)
rruleset = masterEvent.rruleset
self.failUnlessEqual(len(list(rruleset.rrules)), 1)
self.failUnlessEqual(rruleset.rrules.first().freq, 'weekly')
self.failUnlessEqual(rruleset.rrules.first().interval, 2)
# Double-check the bi-weekly thing
delta = (firstOccurrence.getNextOccurrence().effectiveStartTime -
firstOccurrence.effectiveStartTime)
self.failUnlessEqual(delta, timedelta(days=14))
def onTriageEvent(self, event):
#import hotshot
#print 'triaging'
#prof = hotshot.Profile('triage.log')
#prof.runcall(self._onTriageEvent, event)
#prof.close()
#print 'done triaging'
#def _onTriageEvent(self, event):
if False:
# Messages previously added to support a triage progress box
boxTitle = _(u"Triage Progress")
progress1 = _(u"Triaging items...")
progress2 = _(u"Triaging recurring events...")
progress3 = _(u"Saving...")
failureMsg = _(u"Unable to triage. See chandler.log for details.")
failureTitle = _(u"Triage Error")
# Don't fire all the observers (until we're done, that is).
recurringEventsToHandle = set()
mastersToPurge = set()
attrsToFind = ((pim.EventStamp.modificationFor.name,
None), ('_sectionTriageStatus', None),
('_sectionTriageStatusChanged', None))
view = self.itsView
with view.observersDeferred():
with view.reindexingDeferred():
for key in self.contents.iterkeys():
master, sectionTS, sectionTSChanged = \
view.findValues(key, *attrsToFind)
hasSectionTS = sectionTS or sectionTSChanged
mastersToPurge.add(master)
if hasSectionTS:
item = view[key]
item.purgeSectionTriageStatus()
if master is not None:
recurringEventsToHandle.add(master)
for master in mastersToPurge:
# don't let masters keep their _sectionTriageStatus, if
# they do it'll be inherited inappropriately by
# modifications
if isinstance(master, UUID):
sectionTS, sectionTSChanged = view.findValues(
master, ('_sectionTriageStatus', None),
('_sectionTriageStatusChanged', None))
if sectionTS or sectionTSChanged:
view[master].purgeSectionTriageStatus()
elif hasattr(master, '_sectionTriageStatus') or \
hasattr(master, '_sectionTriageStatusChanged'):
master.purgeSectionTriageStatus()
# (We do this outside the deferrals because this depends on the indexes...
for master in recurringEventsToHandle:
if isinstance(master, UUID):
master = view[master]
pim.EventStamp(master).updateTriageStatus()
def testImportReminders(self):
# @@@ [grant] Check for that reminders end up expired or not, as
# appropriate.
self.Import(self.view, u'RecurrenceWithAlarm.ics')
future = pim.EventStamp(
sharing.findUID(self.view, 'RecurringAlarmFuture'))
reminder = future.itsItem.getUserReminder()
# this will start failing in 2015...
self.assertEqual(reminder.delta, datetime.timedelta(minutes=-5))
second = future.getFirstOccurrence().getNextOccurrence()
self.failUnless(second.itsItem.reminders is future.itsItem.reminders)
past = pim.EventStamp(sharing.findUID(self.view, 'RecurringAlarmPast'))
reminder = past.itsItem.getUserReminder()
self.assertEqual(reminder.delta, datetime.timedelta(hours=-1))
second = past.getFirstOccurrence().getNextOccurrence()
self.failUnless(second.itsItem.reminders is past.itsItem.reminders)
def testImportRecurrenceWithTimezone(self):
self.Import(self.view, u'RecurrenceWithTimezone.ics')
event = pim.EventStamp(
sharing.findUID(self.view, 'FF14A660-02A3-11DA-AA66-000A95DA3228'))
mods = [
evt for evt in event.modifications
if not pim.EventStamp(evt).isTriageOnlyModification()
]
# The old ICalendar import code would handle THISANDFUTURE changes by
# creating a new series, so there would be no modifications to the
# original. The current code just ignores THISANDFUTURE changes,
# so there should still be no modifications
self.assertEqual(len(mods), 0)
# Bug 6994, EXDATEs need to have ICU timezones, or they won't commit
# (unless we're suffering from Bug 7023, in which case tzinfos are
# changed silently, often to GMT, without raising an exception)
self.assertEqual(event.rruleset.exdates[0].tzinfo,
self.view.tzinfo.getInstance('US/Central'))
def testNoMaster(self):
"""
Treat a modification without a master as a normal event, because Google
exports events like this, bug 10821.
"""
self.Import(self.view, u'NoMaster.ics')
event = pim.EventStamp(sharing.findUID(self.view, 'no_master'))
rruleset = getattr(event, 'rruleset', None)
self.assertEqual(rruleset, None)
def testMidnightToMidnight(self):
"""
When importing iCalendar data, treat floating midnight-to-midnight
events as all-day, bug 9579.
"""
self.Import(self.view, u'MidnightToMidnight.ics')
event = pim.EventStamp(sharing.findUID(self.view, 'midnight'))
endTime = datetime.datetime(2007, 6, 20)
self.assert_(event.effectiveEndTime.replace(tzinfo=None) == endTime)
self.assert_(event.allDay == True)
def testYearly(self):
for eventItem in self.getCollection(u"U.S. Holidays"):
start = datetime.combine(date(2011, 1, 1),
time(0, tzinfo=self.view.tzinfo.default))
end = datetime.combine(date(2012, 1, 1),
time(0, tzinfo=self.view.tzinfo.default))
# Skip inauguration day, which is the only non-annual event in there
if eventItem.icalUID != 'e25af817-2b0c-928e-30b6-bd3feab7db72':
master = pim.EventStamp(eventItem)
events = master.getOccurrencesBetween(start, end)
self.failUnlessEqual(len(events), 1)
def _makeEvent(self, displayName, startTime):
note = pim.Note(itsView=self.app_ns.itsView)
note.displayName = displayName
note.setTriageStatus(pim.TriageEnum.later)
self.collection.item.add(note)
evt = pim.EventStamp(note)
evt.add()
evt.allDay = False
evt.anyTime = False
evt.startTime = startTime
return evt
def testSummaryAndDateTimeImported(self):
self.Import(self.view, u'Chandler.ics')
event = pim.EventStamp(
sharing.findUID(self.view, 'BED962E5-6042-11D9-BE74-000A95BB2738'))
self.assertEqual(
event.summary, u'3 ho\u00FCr event',
u"SUMMARY of first VEVENT not imported correctly, displayName is %s"
% event.summary)
evtime = datetime.datetime(2005, 1, 1, hour=23, tzinfo=self.utc)
self.assert_(
event.startTime == evtime,
"startTime not set properly, startTime is %s" % event.startTime)
def Modify(self):
# change one of the items in both shares
view0 = self.views[0]
sandbox0 = view0.findPath("//sandbox")
coll0 = sandbox0.findPath("testCollection")
view1 = self.views[1]
coll1 = view1.findUUID(coll0.itsUUID)
for item in coll0:
if item.displayName == u"meeting":
uuid = item.itsUUID
break
item0 = view0.findUUID(uuid)
event0 = pim.EventStamp(item0)
item0.displayName = u"meeting rescheduled"
oldStart = event0.startTime
tzinfo = view1.tzinfo.default
newStart = datetime.datetime(2005, 11, 1, 12, 0, 0, 0, tzinfo)
item1 = view1.findUUID(uuid)
event1 = pim.EventStamp(item1)
event1.startTime = newStart
sharing.sync(coll0)
sharing.sync(coll1)
sharing.sync(coll0)
# Make sure our changes were merged:
self.assertEqual(item0.displayName, u"meeting rescheduled",
u"displayName is %s" % (item0.displayName))
self.assertEqual(item1.displayName, u"meeting rescheduled",
u"displayName is %s" % (item1.displayName))
self.assertEqual(event0.startTime, newStart,
u"startTime is %s" % (event0.startTime))
self.assertEqual(event1.startTime, newStart,
u"startTime is %s" % (event1.startTime))
def xmlrpc_note(self, title, body, viewName=None):
view = getServletView(self.repositoryView.repository, viewName)
view.refresh()
note = pim.Note(itsView=view, displayName=title, body=body)
event = pim.EventStamp(note)
event.add()
event.startTime = datetime.datetime.now(tz=view.tzinfo.floating)
event.duration = datetime.timedelta(minutes=60)
event.anyTime = False
allCollection = schema.ns('osaf.pim', view).allCollection
allCollection.add(note)
view.commit()
return "OK" # ???
def testDateImportAsAllDay(self):
self.Import(self.view, u'AllDay.ics')
event = pim.EventStamp(sharing.findUID(self.view, 'testAllDay'))
self.failUnless(pim.has_stamp(event, pim.EventStamp))
self.assert_(
event.startTime == datetime.datetime(
2005, 1, 1, tzinfo=self.view.tzinfo.floating),
"startTime not set properly for all day event, startTime is %s" %
event.startTime)
self.assert_(
event.allDay == True,
"allDay not set properly for all day event, allDay is %s" %
event.allDay)
def testUpdate(self):
self.runImport(
"BEGIN:VCALENDAR",
"VERSION:2.0",
"CALSCALE:GREGORIAN",
"METHOD:PUBLISH",
"BEGIN:VTODO",
"DTSTART:20060214T000000",
"SUMMARY:To Do (Initial)",
"UID:ED5CAC89-4BEE-4903-8DE8-1AEF6FC1D431",
"DTSTAMP:20060227T233332Z",
"SEQUENCE:11",
"DESCRIPTION:How will I ever get this done?",
"END:VTODO",
"END:VCALENDAR",
)
self.runImport(
"BEGIN:VCALENDAR",
"VERSION:2.0",
"CALSCALE:GREGORIAN",
"METHOD:PUBLISH",
"BEGIN:VTODO",
"DTSTART:20060214T000000",
"SUMMARY:To Do (Initial)",
"X-OSAF-STARRED:TRUE",
"UID:ED5CAC89-4BEE-4903-8DE8-1AEF6FC1D431",
"DTSTAMP:20060227T233332Z",
"SEQUENCE:12",
"DESCRIPTION:Phew!",
"STATUS:COMPLETED",
"DUE;VALUE=DATE:20060327",
"END:VTODO",
"END:VCALENDAR",
)
self.failUnlessEqual(1, len(self.items))
item = self.items[0]
task = pim.TaskStamp(item)
self.failUnless(pim.has_stamp(task, pim.TaskStamp))
self.failUnless(pim.has_stamp(task, pim.EventStamp))
self.failUnlessEqual(item.body, u"Phew!")
self.failUnlessEqual(
pim.EventStamp(task).startTime.date(), datetime.date(2006, 3, 27))
# the update causes a (spurious, but such is life) conflict
self.failUnlessEqual(task.itsItem.triageStatus, pim.TriageEnum.now)
# resolve the conflicts
for c in sharing.getConflicts(task.itsItem):
c.apply()
self.failUnlessEqual(task.itsItem.triageStatus, pim.TriageEnum.done)
def processSharingQueue(rv):
# Called during OnIdle, this method looks for occurrences in this queue
# (which is populated by recordset_conduit's sync( ) method) to check for
# duplicate recurrenceIDs, caused by two views simultaneously creating
# the same event modification. (bug 8213)
q = schema.ns('osaf.sharing', rv).newItems
for item in q:
q.remove(item)
if isinstance(item, pim.Occurrence):
event = pim.EventStamp(item)
id = event.recurrenceID
for sibling in pim.EventStamp(item.inheritFrom).occurrences:
if sibling is not item:
occurrence = pim.EventStamp(sibling)
if occurrence.recurrenceID == id:
# This occurrence is a locally-created duplicate of the
# one the sharing layer brought in. For now, just
# delete it. Later we can try to merge differences.
occurrence._safeDelete()
logger.info(
"Duplicate recurrenceID %s:%s, item: %s" %
(item.inheritFrom.itsUUID, id, sibling.itsUUID))
def failUnlessHolidayMatches(self, uid, year, month, day):
holidays = self.getCollection(u"U.S. Holidays")
event = pim.EventStamp(sharing.findUID(self.view, uid))
self.failUnless(event.itsItem in holidays)
targetDate = date(year, month, day)
d = datetime.combine(targetDate,
time(0, tzinfo=self.view.tzinfo.default))
matches = event.getOccurrencesBetween(d - timedelta(days=1),
d + timedelta(days=1))
self.failUnlessEqual(len(matches), 1)
matchEvent = matches[0]
self.failUnlessEqual(matchEvent.startTime.date(), targetDate)
self.failUnless(matchEvent.allDay)
def advanceState(self, item, attributeName):
# changes to read/unread/needs reply should apply to all occurrences
item = getattr(item, 'proxiedItem', item)
item = pim.EventStamp(item).getMaster().itsItem
oldState = self.GetAttributeValue(item, attributeName)
if oldState.find("NeedsReply") != -1:
item.read = False
item.needsReply = False
elif oldState.find("Unread") != -1:
item.read = True
item.needsReply = False
else: # make it needs-reply (and make sure it's read).
item.read = True
item.needsReply = True
def exportFile(rv,
path,
collection,
activity=None,
translatorClass=translator.SharingTranslator,
serializerClass=ics.ICSSerializer,
filters=None,
debug=False):
if filters is None:
filter = lambda rs: rs
else:
filter = eim.Filter(None, u'Temporary filter')
for uri in filters:
filter += eim.lookupSchemaURI(uri)
filter = filter.sync_filter
trans = translatorClass(rv)
trans.startImport()
total = len(collection)
if activity:
activity.update(totalWork=total)
outbound = {}
for item in collection:
if (isinstance(item, pim.Note)
and pim.EventStamp(item).isTriageOnlyModification()):
continue # skip triage-only modifications
alias = trans.getAliasForItem(item)
outbound[alias] = filter(eim.RecordSet(trans.exportItem(item)))
if activity:
activity.update(work=1, msg=_(u"Exporting items..."))
text = serializerClass.serialize(rv,
outbound,
name=collection.displayName,
monolithic=True)
output = open(path, "wb")
output.write(text)
output.close()
if activity:
activity.update(totalWork=None, msg=_(u"Exporting complete."))
def testOfficeSupplies(self):
item = self.getItem(u"Office supplies order")
self.checkStampness(item, pim.EventStamp)
masterEvent = pim.EventStamp(item).getMaster()
self.failUnless(masterEvent.anyTime)
self.failIf(masterEvent.allDay)
self.failUnless(masterEvent.userReminderInterval is None)
self.failIfEqual(item.body, u'')
self.failUnless(item in self.getCollection(u"Work"))
self.failUnless(item in schema.ns("osaf.pim", self.view).allCollection)
self.failUnlessEqual(len(list(item.appearsIn)), 2)
rruleset = masterEvent.rruleset
self.failUnlessEqual(len(list(rruleset.rrules)), 1)
self.failUnlessEqual(rruleset.rrules.first().freq, 'monthly')
self.failUnlessEqual(rruleset.rrules.first().interval, 1)
def testWeekdayEvent(self):
self.Import(self.view, 'WeekdayEvent.ics')
event = pim.EventStamp(
sharing.findUID(self.view, '5fc9f9a2-0655-11dd-8f5a-0016cbca6aed'))
rruleset = event.rruleset
self.failUnless(rruleset is not None)
self.failUnlessEqual(len(list(rruleset.rrules)), 1)
rrule = rruleset.rrules.first()
self.failUnlessEqual(rrule.freq, 'weekly')
self.failUnlessEqual(rrule.interval, 1)
self.failUnlessEqual([(ws.weekday, ws.selector)
for ws in rrule.byweekday], [('monday', 0),
('tuesday', 0),
('wednesday', 0),
('thursday', 0),
('friday', 0)])
self.failUnless(rrule.isWeekdayRule())
