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 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 parse_for_reminder(self):
if not self.handled_reminder:
startTime, endTime, countFlag, typeFlag = self.parse_tuple
# If there is a date/time range, treat the message as an event
if not has_stamp(self.item, EventStamp) and typeFlag != 0 :
self.item.userReminderTime = startTime
self.handled_reminder = True
def parse_for_event(self):
if not self.handled_event:
startTime, endTime, countFlag, typeFlag = self.parse_tuple
# If there is a date/time range, treat the message as an event
if startTime != endTime and not has_stamp(self.item, EventStamp):
self.set_event_attributes()
self.handled_event = True
def traverseStampSquence(self, item, sequence):
for operation, stampClass in sequence:
if verbose:
message = "stamping %s: %s %s" % \
(item.itsKind.itsName,
operation,
stampClass)
logging.info(message)
stampItem = stampClass(item)
getattr(stampItem, operation)() # i.e. stampClass(item).add() or
# stampClass(item).remove()
self.assertAttributes(item)
if operation == 'add':
self.failUnless(has_stamp(item, stampClass))
def traverseStampSquence(self, item, sequence):
for operation, stampClass in sequence:
if verbose:
message = "stamping %s: %s %s" % \
(item.itsKind.itsName,
operation,
stampClass)
logging.info(message)
stampItem = stampClass(item)
getattr(stampItem, operation)() # i.e. stampClass(item).add() or
# stampClass(item).remove()
self.assertAttributes(item)
if operation == 'add':
self.failUnless(has_stamp(item, stampClass))
def _verifyCalendarEvent(event):
self.failUnless(stamping.has_stamp(event, Calendar.EventStamp))
self.assertEqual(event.summary, uw("simple headline"))
self.assertEqual(event.itsItem.importance, 'fyi')
self.assertEqual(getEventValue(event, 'importance'), 'fyi')
self.assertEqual(event.transparency, "confirmed")
self.assertEqual(getEventValue(event, 'transparency'), "confirmed")
self.assertEqual(event.allDay, False)
self.assertEqual(getEventValue(event, 'allDay'), False)
self.assertEqual(event.anyTime, True)
self.assertEqual(getEventValue(event, 'anyTime'), True)
def _verifyCalendarEvent(event):
self.failUnless(stamping.has_stamp(event, Calendar.EventStamp))
self.assertEqual(event.summary, uw("simple headline"))
self.assertEqual(event.itsItem.importance, "fyi")
self.assertEqual(getEventValue(event, "importance"), "fyi")
self.assertEqual(event.transparency, "confirmed")
self.assertEqual(getEventValue(event, "transparency"), "confirmed")
self.assertEqual(event.allDay, False)
self.assertEqual(getEventValue(event, "allDay"), False)
self.assertEqual(event.anyTime, True)
self.assertEqual(getEventValue(event, "anyTime"), True)
def setUp(self):
super(TestReplyReplyAllForward, self).setUp()
# Set the default timezone so that we'll get correct
# format for dates in forwarded messages
defaultTzinfo = self.view.tzinfo.getInstance("US/Hawaii")
self.savedTzinfo = self.view.tzinfo.setDefault(defaultTzinfo)
self.messageOne = message.messageTextToKind(self.view, self.M1)[1]
self.messageTwo = message.messageTextToKind(self.view, self.M2)[1]
self.messageThree = message.messageTextToKind(self.view, self.M3)[1]
self.messageFour = message.messageTextToKind(self.view, self.M4)[1]
self.assertTrue(isinstance(self.messageOne, MailStamp))
self.assertTrue(isinstance(self.messageTwo, MailStamp))
self.assertTrue(isinstance(self.messageThree, MailStamp))
self.assertTrue(isinstance(self.messageFour, MailStamp))
self.assertTrue(isinstance(self.messageFour, MailStamp))
#This is also an event
self.assertTrue(has_stamp(self.messageFour.itsItem, EventStamp))
def testCalendarEvent(self):
from i18n import ChandlerMessageFactory
event = Calendar.CalendarEvent(itsParent=self.sandbox)
# Call InitOutgoingAttributes() on the created event, the
# hook for item/stamp creation in the Chandler UI.
item = event.itsItem
event.InitOutgoingAttributes()
newEventTitle = ChandlerMessageFactory(u"New Event")
self.failUnless(stamping.has_stamp(event, Calendar.EventStamp))
self.failUnlessEqual(item.displayName, newEventTitle)
newNote = type(item)(itsParent=self.sandbox)
newNote.InitOutgoingAttributes() # Should be _(u"Untitled")
# Make sure the new event title gets reset on unstamp
event.remove()
self.failUnlessEqual(item.displayName, newNote.displayName)
def testCalendarEvent(self):
from i18n import ChandlerMessageFactory
event = Calendar.CalendarEvent(itsParent=self.sandbox, )
# Call InitOutgoingAttributes() on the created event, the
# hook for item/stamp creation in the Chandler UI.
item = event.itsItem
event.InitOutgoingAttributes()
newEventTitle = ChandlerMessageFactory(u"New Event")
self.failUnless(stamping.has_stamp(event, Calendar.EventStamp))
self.failUnlessEqual(item.displayName, newEventTitle)
newNote = type(item)(itsParent=self.sandbox)
newNote.InitOutgoingAttributes() # Should be _(u"Untitled")
# Make sure the new event title gets reset on unstamp
event.remove()
self.failUnlessEqual(item.displayName, newNote.displayName)
def set_event_attributes(self):
if not has_stamp(self.item, EventStamp):
EventStamp(self.item).add()
startTime, endTime, countFlag, typeFlag = self.parse_tuple
setEventDateTime(self.item, startTime, endTime, typeFlag)
def process(cls, state):
for stamp in cls.stamp_types:
if not has_stamp(state.item, stamp):
stamp(state.item).add()
cls.process_stamp(state)
def testStamping(self):
view = self.sandbox.itsView
# Get the stamp kinds
mailStamp = Mail.MailStamp
taskStamp = pim.TaskStamp
eventStamp = Calendar.EventStamp
noteKind = pim.Note.getKind(view)
# start out with a Note
aNote = pim.Note("noteItem1", itsParent=self.sandbox)
self.setAttributes(aNote, doWho=False)
self.assertAttributes(aNote)
add = 'add'
remove = 'remove'
# stamp everything on and off the note
self.traverseStampSquence(aNote, ((add, mailStamp),
(add, taskStamp),
(add, eventStamp),
(remove, eventStamp),
(remove, taskStamp),
(remove, mailStamp)))
# stamp everything on again, remove in a different order
self.traverseStampSquence(aNote, ((add, mailStamp),
(add, taskStamp),
(add, eventStamp),
(remove, mailStamp),
(remove, taskStamp),
(remove, eventStamp)))
self.assertAttributes(aNote)
# Create a Task, and do all kinds of stamping on it
aTask = pim.Task("aTask", itsParent=self.sandbox).itsItem
self.setAttributes(aTask)
self.traverseStampSquence(aTask, ((add, eventStamp),
(remove, taskStamp)))
# now it's an Event
self.traverseStampSquence(aTask, ((add, mailStamp),
(remove, mailStamp)))
self.traverseStampSquence(aTask, ((add, mailStamp),
(add, taskStamp),
(remove, mailStamp),
(remove, taskStamp)))
self.traverseStampSquence(aTask, ((add, taskStamp),
(add, mailStamp),
(remove, mailStamp),
(remove, taskStamp)))
self.traverseStampSquence(aTask, ((add, mailStamp),
(remove, eventStamp)))
# now it's a Mail
self.traverseStampSquence(aTask, ((add, taskStamp),
(remove, mailStamp)))
# it's a Task again
self.traverseStampSquence(aTask, ((add, mailStamp),
(remove, taskStamp)))
self.traverseStampSquence(aTask, ((add, taskStamp),
(remove, mailStamp)))
# it's a Task again
self.traverseStampSquence(aTask, ((add, eventStamp),
(remove, taskStamp),
(add, mailStamp),
(remove, eventStamp),
(add, taskStamp),
(remove, mailStamp)))
self.failUnless(has_stamp(aTask, taskStamp))
# check stamping on an Event
anEvent = Calendar.CalendarEvent("anEvent", itsParent=self.sandbox).itsItem
self.setAttributes(anEvent)
# round-robin its Kind back to event
self.traverseStampSquence(anEvent, ((add, mailStamp),
(remove, eventStamp),
(add, taskStamp),
(remove, mailStamp),
(add, eventStamp),
(remove, taskStamp)))
self.failUnless(has_stamp(anEvent, eventStamp))
# check stamping on a Mail Message
aMessage = Mail.MailMessage("aMessage", itsParent=self.sandbox).itsItem
self.setAttributes(aMessage)
self.traverseStampSquence(aMessage, ((add, eventStamp),
(add, taskStamp),
(remove, eventStamp),
(remove, taskStamp)))
self.failUnless(has_stamp(aMessage, mailStamp))
# now mixin some arbitrary Kind
#anotherKind = view.findPath('//parcels/osaf/framework/blocks/Block')
# stamp an event, mail, task with another kind
#aNote.StampKind(add, anotherKind)
#aTask.StampKind(add, anotherKind)
#anEvent.StampKind(add, anotherKind)
#aMessage.StampKind(add, anotherKind)
#self.assertKinds(aNote, (noteKind, anotherKind))
#self.assertKinds(aTask, (taskKind, anotherKind))
#self.assertKinds(anEvent, (eventKind, anotherKind))
#self.assertKinds(aMessage, (mailKind, anotherKind))
# unstamp with another kind
#aNote.StampKind(remove, anotherKind)
#aTask.StampKind(remove, anotherKind)
#anEvent.StampKind(remove, anotherKind)
#aMessage.StampKind(remove, anotherKind)
# see that they still have their attributes
#self.assertKinds(aNote, (noteKind, ))
#self.assertKinds(aTask, (taskKind, ))
#self.assertKinds(anEvent, (eventKind, ))
#self.assertKinds(aMessage, (mailKind, ))
# Test some failure cases
# These cases should produce suitable warning messages in Chandler.log
if testFailureCases:
anotherEvent = Calendar.CalendarEvent("anotherEvent", itsParent=self.sandbox).itsItem
self.setAttributes(anotherEvent)
self.failUnless(has_stamp(anotherEvent, eventStamp))
# Could use assertRaises here, but it's syntax with respect to parameters is
# not clear with my complex arguments, so try/except/else is more readable.
try:
# double stamping
self.traverseStampSquence(anotherEvent, ((add, mailStamp),
(add, mailStamp)))
except StampAlreadyPresentError:
pass
else:
self.failUnless(False, "Double stamping should raise an exception!")
try:
# unstamping something not present
self.traverseStampSquence(anotherEvent, ((remove, taskStamp), ))
except StampNotPresentError:
pass
else:
self.failUnless(False, "Unstamping a stamp not present should raise an exception!")
# Test for Bug:6151: Make sure items don't disappear
# from the all collection if they're unstamped
#
# Make an email ...
aMessage = Mail.MailMessage("aNewMessage", itsParent=self.sandbox)
self.setAttributes(aMessage.itsItem)
# Make sure it's in "Out"
aMessage.fromMe = True
outCollection = schema.ns("osaf.pim", view).outCollection
self.failUnless(aMessage.itsItem in outCollection)
# unstamp its emailness
self.traverseStampSquence(aMessage.itsItem,
(('add', taskStamp),
('remove', mailStamp)))
allCollection = schema.ns("osaf.pim", view).allCollection
self.failUnless(aMessage.itsItem in allCollection)
def _verifyTask(taskItem):
self.failUnless(has_stamp(taskItem, TaskStamp))
self.failUnlessEqual(taskItem.displayName, uw("test headline"))
self.failUnlessEqual(taskItem.importance, 'important')
def testStamping(self):
view = self.sandbox.itsView
# Get the stamp kinds
mailStamp = Mail.MailStamp
taskStamp = pim.TaskStamp
eventStamp = Calendar.EventStamp
noteKind = pim.Note.getKind(view)
# start out with a Note
aNote = pim.Note("noteItem1", itsParent=self.sandbox)
self.setAttributes(aNote, doWho=False)
self.assertAttributes(aNote)
add = 'add'
remove = 'remove'
# stamp everything on and off the note
self.traverseStampSquence(aNote,
((add, mailStamp), (add, taskStamp),
(add, eventStamp), (remove, eventStamp),
(remove, taskStamp), (remove, mailStamp)))
# stamp everything on again, remove in a different order
self.traverseStampSquence(aNote,
((add, mailStamp), (add, taskStamp),
(add, eventStamp), (remove, mailStamp),
(remove, taskStamp), (remove, eventStamp)))
self.assertAttributes(aNote)
# Create a Task, and do all kinds of stamping on it
aTask = pim.Task("aTask", itsParent=self.sandbox).itsItem
self.setAttributes(aTask)
self.traverseStampSquence(aTask,
((add, eventStamp), (remove, taskStamp)))
# now it's an Event
self.traverseStampSquence(aTask,
((add, mailStamp), (remove, mailStamp)))
self.traverseStampSquence(aTask,
((add, mailStamp), (add, taskStamp),
(remove, mailStamp), (remove, taskStamp)))
self.traverseStampSquence(aTask,
((add, taskStamp), (add, mailStamp),
(remove, mailStamp), (remove, taskStamp)))
self.traverseStampSquence(aTask,
((add, mailStamp), (remove, eventStamp)))
# now it's a Mail
self.traverseStampSquence(aTask,
((add, taskStamp), (remove, mailStamp)))
# it's a Task again
self.traverseStampSquence(aTask,
((add, mailStamp), (remove, taskStamp)))
self.traverseStampSquence(aTask,
((add, taskStamp), (remove, mailStamp)))
# it's a Task again
self.traverseStampSquence(aTask,
((add, eventStamp), (remove, taskStamp),
(add, mailStamp), (remove, eventStamp),
(add, taskStamp), (remove, mailStamp)))
self.failUnless(has_stamp(aTask, taskStamp))
# check stamping on an Event
anEvent = Calendar.CalendarEvent("anEvent",
itsParent=self.sandbox).itsItem
self.setAttributes(anEvent)
# round-robin its Kind back to event
self.traverseStampSquence(anEvent,
((add, mailStamp), (remove, eventStamp),
(add, taskStamp), (remove, mailStamp),
(add, eventStamp), (remove, taskStamp)))
self.failUnless(has_stamp(anEvent, eventStamp))
# check stamping on a Mail Message
aMessage = Mail.MailMessage("aMessage", itsParent=self.sandbox).itsItem
self.setAttributes(aMessage)
self.traverseStampSquence(aMessage,
((add, eventStamp), (add, taskStamp),
(remove, eventStamp), (remove, taskStamp)))
self.failUnless(has_stamp(aMessage, mailStamp))
# now mixin some arbitrary Kind
#anotherKind = view.findPath('//parcels/osaf/framework/blocks/Block')
# stamp an event, mail, task with another kind
#aNote.StampKind(add, anotherKind)
#aTask.StampKind(add, anotherKind)
#anEvent.StampKind(add, anotherKind)
#aMessage.StampKind(add, anotherKind)
#self.assertKinds(aNote, (noteKind, anotherKind))
#self.assertKinds(aTask, (taskKind, anotherKind))
#self.assertKinds(anEvent, (eventKind, anotherKind))
#self.assertKinds(aMessage, (mailKind, anotherKind))
# unstamp with another kind
#aNote.StampKind(remove, anotherKind)
#aTask.StampKind(remove, anotherKind)
#anEvent.StampKind(remove, anotherKind)
#aMessage.StampKind(remove, anotherKind)
# see that they still have their attributes
#self.assertKinds(aNote, (noteKind, ))
#self.assertKinds(aTask, (taskKind, ))
#self.assertKinds(anEvent, (eventKind, ))
#self.assertKinds(aMessage, (mailKind, ))
# Test some failure cases
# These cases should produce suitable warning messages in Chandler.log
if testFailureCases:
anotherEvent = Calendar.CalendarEvent(
"anotherEvent", itsParent=self.sandbox).itsItem
self.setAttributes(anotherEvent)
self.failUnless(has_stamp(anotherEvent, eventStamp))
# Could use assertRaises here, but it's syntax with respect to parameters is
# not clear with my complex arguments, so try/except/else is more readable.
try:
# double stamping
self.traverseStampSquence(anotherEvent,
((add, mailStamp), (add, mailStamp)))
except StampAlreadyPresentError:
pass
else:
self.failUnless(False,
"Double stamping should raise an exception!")
try:
# unstamping something not present
self.traverseStampSquence(anotherEvent,
((remove, taskStamp), ))
except StampNotPresentError:
pass
else:
self.failUnless(
False,
"Unstamping a stamp not present should raise an exception!"
)
# Test for Bug:6151: Make sure items don't disappear
# from the all collection if they're unstamped
#
# Make an email ...
aMessage = Mail.MailMessage("aNewMessage", itsParent=self.sandbox)
self.setAttributes(aMessage.itsItem)
# Make sure it's in "Out"
aMessage.fromMe = True
outCollection = schema.ns("osaf.pim", view).outCollection
self.failUnless(aMessage.itsItem in outCollection)
# unstamp its emailness
self.traverseStampSquence(aMessage.itsItem,
(('add', taskStamp),
('remove', mailStamp)))
allCollection = schema.ns("osaf.pim", view).allCollection
self.failUnless(aMessage.itsItem in allCollection)
def testMessageWithEvent(self):
statusCode, eventMessage = message.messageTextToKind(self.view,
self.__getMultipartMessageText())
self.assertTrue(has_stamp(eventMessage, MailStamp))
self.assertTrue(has_stamp(eventMessage, EventStamp))
def _verifyTask(taskItem):
self.failUnless(has_stamp(taskItem, TaskStamp))
self.failUnlessEqual(taskItem.displayName, uw("test headline"))
self.failUnlessEqual(taskItem.importance, 'important')
