def createTasks(self):
# pylint: disable=W0201
self.task = task.Task('Task to edit')
self.stop_datetime = date.DateTime(2012, 12, 12, 12, 12)
self.task.setRecurrence( \
date.Recurrence('daily', amount=1,
stop_datetime=self.stop_datetime))
return [self.task]
def Offset(self, ts):
kwargs = dict()
if self.task.plannedStartDateTime() != date.DateTime():
start = self.GetStart()
start.AddTS(ts)
command.EditPlannedStartDateTimeCommand(
items=[self.task], newValue=self.tcDateTime(start)).do()
if self.task.completed():
end = self.GetEnd()
end.AddTS(ts)
command.EditCompletionDateTimeCommand(
items=[self.task], newValue=self.tcDateTime(end)).do()
elif self.task.dueDateTime() != date.DateTime():
end = self.GetEnd()
end.AddTS(ts)
command.EditDueDateTimeCommand(items=[self.task],
newValue=self.tcDateTime(end)).do()
def testNoNotificationForStartTrackingIfActiveEffortOutsidePeriod(self):
patterns.Publisher().registerObserver(
self.onEvent, eventType=self.effort3.trackStartEventType())
self.task.addEffort(self.effort3)
self.effort3.setStop(date.DateTime())
self.assertEqual(
[patterns.Event(self.effort3.trackStartEventType(), self.effort3)],
self.events)
def testMarkCompletedTaskInactive(self):
now = date.Now()
self.task1.setCompletionDateTime(now)
self.markInactive([self.task1])
self.assertDoUndoRedo(
lambda: self.assertEqual(date.DateTime(),
self.task1.completionDateTime()),
lambda: self.assertEqual(now, self.task1.completionDateTime()))
def testCreationDateTime(self):
self.parser.parse(
['BEGIN:VNOTE', 'CREATED:20100101T120000', 'END:VNOTE'])
self.assertEqual(
dict(status=0,
subject='',
creationDateTime=date.DateTime(2010, 1, 1, 12, 0, 0)),
self.parser.notes[0])
def testSetInfiniteDueDate(self):
newDueDateTime = date.DateTime()
originalDueDateTime = self.task1.dueDateTime()
self.editDue(newDueDateTime, [self.task1])
self.assertDoUndoRedo(
lambda: self.assertEqual(newDueDateTime, self.task1.dueDateTime()),
lambda: self.assertEqual(originalDueDateTime,
self.task1.dueDateTime()))
def testNotificationForStartTracking(self):
patterns.Publisher().registerObserver(
self.onEvent, eventType=self.composite.trackStartEventType())
self.task.addEffort(self.effort1)
self.effort1.setStop(date.DateTime())
self.failUnless(
patterns.Event(self.composite.trackStartEventType(),
self.composite, self.effort1) in self.events)
def testPlannedStartDateIsNotPushedBackWhenDueDateIsMissing(self):
pushBack = date.ONE_HOUR
newDue = date.Now() + pushBack
expectedStart = self.task1.plannedStartDateTime()
self.task1.setDueDateTime(date.DateTime())
self.editDue(newDue, [self.task1], keep_delta=True)
self.assertDoUndoRedo(\
lambda: self.assertEqual(expectedStart, self.task1.plannedStartDateTime()))
def testModificationDateTime(self):
self.parser.parse(
['BEGIN:VNOTE', 'LAST-MODIFIED:20100101T120000', 'END:VNOTE'])
self.assertEqual(
dict(status=0,
subject='',
modificationDateTime=date.DateTime(2010, 1, 1, 12, 0, 0)),
self.parser.notes[0])
def testMarkActiveTaskInactive(self):
now = date.Now()
self.task1.setActualStartDateTime(now)
self.markInactive([self.task1])
self.assertDoUndoRedo(
lambda: self.assertEqual(date.DateTime(),
self.task1.actualStartDateTime()),
lambda: self.assertEqual(now, self.task1.actualStartDateTime()))
def VCalFromTask(task, encoding=True, doFold=True):
''' This function returns a string representing the task in
iCalendar format. '''
encoding = ';ENCODING=QUOTED-PRINTABLE;CHARSET=UTF-8' if encoding else ''
quote = quoteString if encoding else lambda s: s
components = []
components.append('BEGIN:VTODO') # pylint: disable=W0511
components.append('UID:%s' % task.id().encode('UTF-8'))
if task.creationDateTime() > date.DateTime.min:
components.append('CREATED:%s' % fmtDateTime(task.creationDateTime()))
if task.modificationDateTime() > date.DateTime.min:
components.append('LAST-MODIFIED:%s' % fmtDateTime(task.modificationDateTime()))
if task.plannedStartDateTime() != date.DateTime():
components.append('DTSTART:%s' % fmtDateTime(task.plannedStartDateTime()))
if task.dueDateTime() != date.DateTime():
components.append('DUE:%s' % fmtDateTime(task.dueDateTime()))
if task.completionDateTime() != date.DateTime():
components.append('COMPLETED:%s' % fmtDateTime(task.completionDateTime()))
if task.categories(recursive=True, upwards=True):
categories = ','.join([quote(unicode(c)) for c in task.categories(recursive=True, upwards=True)])
components.append('CATEGORIES%s:%s' % (encoding, categories))
if task.completed():
components.append('STATUS:COMPLETED')
elif task.active():
components.append('STATUS:NEEDS-ACTION')
else:
components.append('STATUS:CANCELLED') # Hum...
components.append('DESCRIPTION%s:%s' % (encoding, quote(task.description())))
components.append('PRIORITY:%d' % min(3, task.priority() + 1))
components.append('PERCENT-COMPLETE:%d' % task.percentageComplete())
components.append('SUMMARY%s:%s' % (encoding, quote(task.subject())))
components.append('END:VTODO') # pylint: disable=W0511
if doFold:
return fold(components)
return '\r\n'.join(components) + '\r\n'
def testMissingDueDateIsNotPushedBack(self):
previousPlannedStart = self.task1.plannedStartDateTime()
pushBack = date.ONE_HOUR
newPlannedStart = previousPlannedStart + pushBack
expectedDue = date.DateTime()
self.task1.setDueDateTime(expectedDue)
self.editPlannedStart(newPlannedStart, [self.task1], keep_delta=True)
self.assertDoUndoRedo(\
lambda: self.assertEqual(expectedDue, self.task1.dueDateTime()))
def testDueDateIsNotPushedBackWhenPlannedStartDateIsMissing(self):
self.task1.setPlannedStartDateTime(date.DateTime())
self.task1.setDueDateTime(date.Now() + date.TWO_HOURS)
pushBack = date.ONE_HOUR
newStart = date.Now() + pushBack
expectedDue = self.task1.dueDateTime()
self.editPlannedStart(newStart, [self.task1], keep_delta=True)
self.assertDoUndoRedo(\
lambda: self.assertEqual(expectedDue, self.task1.dueDateTime()))
def testSetInfinitePlannedStartDate(self):
newPlannedStartDateTime = date.DateTime()
originalPlannedStartDateTime = self.task1.plannedStartDateTime()
self.editPlannedStart(newPlannedStartDateTime, [self.task1])
self.assertDoUndoRedo(
lambda: self.assertEqual(newPlannedStartDateTime,
self.task1.plannedStartDateTime()),
lambda: self.assertEqual(originalPlannedStartDateTime,
self.task1.plannedStartDateTime()))
def testTaskWithFutureActualStartDateTime(self):
tomorrow = date.Tomorrow()
self.task1.setActualStartDateTime(tomorrow)
self.markInactive([self.task1])
self.assertDoUndoRedo(
lambda: self.assertEqual(date.DateTime(),
self.task1.actualStartDateTime()),
lambda: self.assertEqual(tomorrow, self.task1.actualStartDateTime(
)))
def testMarkRecurringTaskCompleted_ActualStartDateIsReset(self):
self.task1.setRecurrence(date.Recurrence('weekly'))
now = date.Now()
self.task1.setActualStartDateTime(now)
self.markCompleted([self.task1])
self.assertDoUndoRedo(
lambda: self.assertEqual(date.DateTime(),
self.task1.actualStartDateTime()),
lambda: self.assertEqual(now, self.task1.actualStartDateTime()))
def testDontWriteInheritedTaskBackgroundColor(self):
self.task.setBackgroundColor(wx.RED)
child = task.Task(subject='child',
id='id',
plannedStartDateTime=date.DateTime())
self.task.addChild(child)
self.taskList.append(child)
self.expectInXML('<task creationDateTime="%s" id="id" status="1" '
'subject="child" />' % child.creationDateTime())
def testEditStartDateTime(self):
edit = command.EditEffortCommand(self.effortList, [self.effort])
expected = date.DateTime(2000, 1, 1)
edit.items[0].setStart(expected)
edit.do()
self.assertDoUndoRedo(
lambda: self.assertEqual(expected, self.effort.getStart()),
lambda: self.assertEqual(self.originalStart, self.effort.getStart(
)))
def testNotificationForStartTracking(self):
events = []
def onEvent(newValue, sender):
events.append((newValue, sender))
pub.subscribe(onEvent, self.effort.trackingChangedEventType())
self.effort.setStop(date.DateTime())
self.assertEqual([(True, self.effort)], events)
def testStartTrackingInactiveTaskSetsActualStartDate(self):
start = command.StartEffortCommand(self.taskList, [self.task2])
start.do()
now = date.Now()
self.assertDoUndoRedo(
lambda: self.
failUnless(now - date.ONE_SECOND < self.task2.actualStartDateTime(
) < now + date.ONE_SECOND), lambda: self.assertEqual(
date.DateTime(), self.task2.actualStartDateTime()))
def RefreshItems(self, *args):
selectionId = None
if self.__selection:
selectionId = self.__selection[0].id()
self.__selection = []
for task in args:
doShow = True
if task.isDeleted():
doShow = False
if task.startDateTime() == date.DateTime() and task.dueDateTime(
) == date.DateTime():
doShow = False
if task.startDateTime() == date.DateTime(
) and not self.__showNoStartDate:
doShow = False
if task.dueDateTime() == date.DateTime(
) and not self.__showNoDueDate:
doShow = False
if doShow:
if self.taskMap.has_key(task.id()):
schedule = self.taskMap[task.id()]
schedule.update()
else:
schedule = TaskSchedule(task, self.iconProvider)
self.taskMap[task.id()] = schedule
self.Add([schedule])
if task.id() == selectionId:
self.__selection = [task]
schedule.SetSelected(True)
else:
if self.taskMap.has_key(task.id()):
self.Delete(self.taskMap[task.id()])
del self.taskMap[task.id()]
if self.__selection and self.__selection[0].id(
) == task.id():
self.__selection = []
wx.CallAfter(self.selectCommand)
def testTaskWithCompletionDateTime(self):
filename = self.createCSVFile('Subject,1:33 am 2011-6-30\n')
self.reader.read(filename=filename,
mappings={
0: 'Subject',
1: 'Completion date'
},
**self.defaultReaderKwArgs)
self.assertEqual(date.DateTime(2011, 6, 30, 1, 33, 0),
list(self.taskList)[0].completionDateTime())
def testNewStartDateTime(self):
oldStart = self.effort.getStart()
newStart = date.DateTime(2000, 1, 1)
edit = command.EditEffortStartDateTimeCommand(self.effortList,
[self.effort],
newValue=newStart)
edit.do()
self.assertDoUndoRedo(
lambda: self.assertEqual(newStart, self.effort.getStart()),
lambda: self.assertEqual(oldStart, self.effort.getStart()))
def testRevenueNotificationForEffortDurationChange_ChangeStart(self):
self.task.setHourlyFee(100)
events = []
def onEvent(newValue, sender):
events.append((newValue, sender))
pub.subscribe(onEvent, effort.Effort.revenueChangedEventType())
self.effort.setStart(date.DateTime(2004, 1, 1, 12, 0, 0))
self.assertEqual([(1200.0, self.effort)], events)
def testTaskWithDueDateTime(self):
filename = self.createCSVFile('Subject,2011-6-30 1:34:01 pm\n')
self.reader.read(filename=filename,
mappings={
0: 'Subject',
1: 'Due date'
},
**self.defaultReaderKwArgs)
self.assertEqual(date.DateTime(2011, 6, 30, 13, 34, 1),
list(self.taskList)[0].dueDateTime())
def setUp(self):
super(EffortViewerForSpecificTasksTest, self).setUp()
self.settings = config.Settings(load=False)
task.Task.settings = self.settings
self.taskFile = persistence.TaskFile()
self.task1 = task.Task('Task 1')
self.task2 = task.Task('Task 2')
self.taskFile.tasks().extend([self.task1, self.task2])
self.effort1 = effort.Effort(self.task1, date.DateTime(2006, 1, 1),
date.DateTime(2006, 1, 2))
self.task1.addEffort(self.effort1)
self.effort2 = effort.Effort(self.task2, date.DateTime(2006, 1, 2),
date.DateTime(2006, 1, 3))
self.task2.addEffort(self.effort2)
self.viewer = EffortViewerUnderTest(self.frame,
self.taskFile,
self.settings,
tasksToShowEffortFor=task.TaskList(
[self.task1]))
def testTaskWithEmptyPlannedStartDate(self):
filename = self.createCSVFile('Subject,\n')
self.reader.read(filename=filename,
mappings={
0: 'Subject',
1: 'Planned start date'
},
**self.defaultReaderKwArgs)
self.assertEqual(date.DateTime(),
list(self.taskList)[0].plannedStartDateTime())
def testTaskWithActualStartDate(self):
filename = self.createCSVFile('Subject,2011-6-30\n')
self.reader.read(filename=filename,
mappings={
0: 'Subject',
1: 'Actual start date'
},
**self.defaultReaderKwArgs)
self.assertEqual(date.DateTime(2011, 6, 30, 0, 0, 0),
list(self.taskList)[0].actualStartDateTime())
def __init__(self, *args, **kwargs):
super(MarkActiveCommand, self).__init__(*args, **kwargs)
self.items = [
item for item in self.items
if item.actualStartDateTime() > date.Now()
or item.completionDateTime() != date.DateTime()
]
itemsToSave = set(
[relative for item in self.items for relative in item.family()])
self.saveStates(itemsToSave)
def testTaskWithReminderDateTime(self):
filename = self.createCSVFile('Subject,12:31 2012-6-30\n')
self.reader.read(filename=filename,
mappings={
0: 'Subject',
1: 'Reminder date'
},
**self.defaultReaderKwArgs)
self.assertEqual(date.DateTime(2012, 6, 30, 12, 31, 0),
list(self.taskList)[0].reminder())
