def process_result_value(self, value, dialect):
if value:
dct = json.loads(value)
value = RecurrenceRule.fromDict(dct)
else:
value = RecurrenceRule()
return value
def testFromHumaneString(self):
testData = [
("daily 10:00", RecurrenceRule(rrule.DAILY, byhour=10)),
("weekly FR 23:00",
RecurrenceRule(rrule.WEEKLY, byweekday=4, byhour=23)),
("none", RecurrenceRule()),
("weekly fr 23:00",
RecurrenceRule(rrule.WEEKLY, byweekday=4, byhour=23)),
("weekly Fr 23:00",
RecurrenceRule(rrule.WEEKLY, byweekday=4, byhour=23)),
("weekly Friday 23:00",
RecurrenceRule(rrule.WEEKLY, byweekday=4, byhour=23)),
("monthly 3 13:00",
RecurrenceRule(rrule.MONTHLY, bymonthday=3, byhour=13)),
("monthly second friday 13:00",
RecurrenceRule(rrule.MONTHLY,
byweekday=RecurrenceRule.createWeekDay(weekday=4,
pos=2),
byhour=13)),
("yearly 3/07 11:20",
RecurrenceRule(
rrule.YEARLY, bymonth=7, bymonthday=3, byhour=11,
byminute=20)),
("quarterly 14 11:20",
RecurrenceRule(rrule.YEARLY,
bymonth=(1, 4, 7, 10),
bymonthday=14,
byhour=11,
byminute=20)),
("quarterly first monday 23:20",
RecurrenceRule(rrule.YEARLY,
bymonth=(1, 4, 7, 10),
byweekday=RecurrenceRule.createWeekDay(weekday=0,
pos=1),
byhour=23,
byminute=20)),
] + [(x.text, x.rule) for x in TEST_DATA]
for text, expected in testData:
with self.subTest(text=text):
output = RecurrenceRule.fromHumaneString(text)
self.assertEqual(
output, expected,
'\ninput: {}\noutput: {}\nexpected: {}'.format(
text, output, expected))
from yokadi.core.recurrencerule import RecurrenceRule
from yokadi.core.yokadiexception import YokadiException
# Use a date far away in the future because rrule does not work with dates in
# the past.
# This is a wednesday.
REF_DATE = datetime(2200, 3, 19, 21, 30)
TestRow = namedtuple("TestRow", ("text", "dct", "rule", "nextDate"))
TEST_DATA = [
TestRow(
"none",
{},
RecurrenceRule(),
None,
),
TestRow(
"daily 17:15", {
"freq": rrule.DAILY,
"bymonth": (),
"bymonthday": (),
"byweekday": (),
"byhour": (17, ),
"byminute": (15, )
}, RecurrenceRule(rrule.DAILY, byhour=17, byminute=15),
REF_DATE.replace(day=20, hour=17, minute=15)),
TestRow(
"weekly monday 10:00", {
"freq": rrule.WEEKLY,
class Task(Base):
__tablename__ = "task"
id = Column(Integer, primary_key=True)
uuid = Column(Unicode, unique=True, default=uuidGenerator, nullable=False)
title = Column(Unicode)
creationDate = Column("creation_date",
DateTime,
nullable=False,
default=datetime.now)
dueDate = Column("due_date", DateTime, default=None)
doneDate = Column("done_date", DateTime, default=None)
description = Column(Unicode, default="", nullable=False)
urgency = Column(Integer, default=0, nullable=False)
status = Column(Enum("new", "started", "done"), default="new")
recurrence = Column(RecurrenceRuleColumnType,
nullable=False,
default=RecurrenceRule())
projectId = Column("project_id",
Integer,
ForeignKey("project.id"),
nullable=False)
taskKeywords = relationship("TaskKeyword", cascade="all", backref="task")
lock = relationship("TaskLock", cascade="all", backref="task")
def setKeywordDict(self, dct):
"""
Defines keywords of a task.
Dict is of the form: keywordName => value
"""
session = getSession()
for taskKeyword in self.taskKeywords:
session.delete(taskKeyword)
for name, value in list(dct.items()):
keyword = session.query(Keyword).filter_by(name=name).one()
session.add(TaskKeyword(task=self, keyword=keyword, value=value))
def getKeywordDict(self):
"""
Returns all keywords of a task as a dict of the form:
keywordName => value
"""
dct = {}
for taskKeyword in self.taskKeywords:
dct[taskKeyword.keyword.name] = taskKeyword.value
return dct
def getKeywordsAsString(self):
"""
Returns all keywords as a string like "key1=value1, key2=value2..."
"""
return ", ".join(
list(("%s=%s" % k for k in list(self.getKeywordDict().items()))))
def getUserKeywordsNameAsString(self):
"""
Returns all keywords keys as a string like "key1, key2, key3...".
Internal keywords (starting with _) are ignored.
"""
keywords = [
k for k in list(self.getKeywordDict().keys())
if not k.startswith("_")
]
keywords.sort()
if keywords:
return ", ".join(keywords)
else:
return ""
def setStatus(self, status):
"""
Defines the status of the task, taking care of updating the done date
and doing the right thing for recurrent tasks
"""
if self.recurrence and status == "done":
self.dueDate = self.recurrence.getNext(self.dueDate)
else:
self.status = status
if status == "done":
self.doneDate = datetime.now().replace(second=0, microsecond=0)
else:
self.doneDate = None
session = getSession()
session.merge(self)
def setRecurrenceRule(self, rule):
"""Set recurrence and update the due date accordingly"""
self.recurrence = rule
self.dueDate = rule.getNext()
def __repr__(self):
return "<Task id={} title={}>".format(self.id, self.title)
