def test_parse_date_dst(self):
tz = datefmt.get_timezone('Europe/Zurich')
t_utc = datetime.datetime(2009, 8, 1, 10, 0, 0, 0, datefmt.utc)
self.assertEqual(t_utc,
datefmt.parse_date('2009-08-01T12:00:00', tz))
self.assertEqual(t_utc,
datefmt.parse_date('2009-08-01 12:00:00', tz))
def expand_macro(self, formatter, name, content, args=None):
hint = '|| yyyy-mm-ddThh:mm:ss || yyyy-mm-ddThh:mm:ss || message'
pattern = "\s*||(.*)||(.*)||(.*)".replace('|', '\|')
pattern = re.compile(pattern)
try:
if content == None:
return tag.div('ShowWhen Macro is not supported. Use WikiProcessor-style instead.', \
class_="system-message")
now = datetime.now(utc)
for line in content.split('\n'):
matched = pattern.match(line)
if matched:
result = matched.groups()
by, to, text = result
by, to = parse_date(by, None,
hint), parse_date(to, None, hint)
self.env.log.debug('parsed time range: %s / %s' % (by, to))
if by <= now and now <= to:
return format_to_html(self.env, formatter.context,
text)
return None
except Exception, e:
return tag.div(tag.strong(e.title),
': ' + e.message,
class_="system-message")
def test_parse_date_dst(self):
tz = datefmt.get_timezone('Europe/Zurich')
t_utc = datetime.datetime(2009, 8, 1, 10, 0, 0, 0, datefmt.utc)
self.assertEqual(t_utc,
datefmt.parse_date('2009-08-01T12:00:00', tz))
self.assertEqual(t_utc,
datefmt.parse_date('2009-08-01 12:00:00', tz))
def test_parse_date_offset(self):
t_utc = datetime.datetime(2009, 12, 1, 11, 0, 0, 0, datefmt.utc)
self.assertEqual(t_utc, datefmt.parse_date('2009-12-01T11:00:00Z'))
self.assertEqual(t_utc,
datefmt.parse_date('2009-12-01T11:00:00+00:00'))
self.assertEqual(t_utc,
datefmt.parse_date('2009-12-01T11:00:00-00:00'))
self.assertEqual(t_utc,
datefmt.parse_date('2009-12-01T09:00:00-02:00'))
self.assertEqual(t_utc,
datefmt.parse_date('2009-12-01T11:30:00+00:30'))
def test_parse_date_offset(self):
t_utc = datetime.datetime(2009, 12, 1, 11, 0, 0, 0, datefmt.utc)
self.assertEqual(t_utc,
datefmt.parse_date('2009-12-01T11:00:00Z'))
self.assertEqual(t_utc,
datefmt.parse_date('2009-12-01T11:00:00+00:00'))
self.assertEqual(t_utc,
datefmt.parse_date('2009-12-01T11:00:00-00:00'))
self.assertEqual(t_utc,
datefmt.parse_date('2009-12-01T09:00:00-02:00'))
self.assertEqual(t_utc,
datefmt.parse_date('2009-12-01T11:30:00+00:30'))
def test_i18n_parse_date_datetime_meridiem(self):
tz = datefmt.timezone('GMT +2:00')
expected_am = datetime.datetime(2011, 2, 22, 0, 45, 56, 0, tz)
expected_pm = datetime.datetime(2011, 2, 22, 12, 45, 56, 0, tz)
en_US = Locale.parse('en_US')
zh_CN = Locale.parse('zh_CN')
self.assertEqual(expected_am,
datefmt.parse_date('Feb 22, 2011 0:45:56 AM', tz,
en_US))
self.assertEqual(expected_am,
datefmt.parse_date('Feb 22, 2011 12:45:56 AM', tz,
en_US))
self.assertEqual(expected_am,
datefmt.parse_date(u'2011-2-22 上午0:45:56', tz,
zh_CN))
self.assertEqual(expected_am,
datefmt.parse_date(u'2011-2-22 上午12:45:56', tz,
zh_CN))
self.assertEqual(expected_pm,
datefmt.parse_date('Feb 22, 2011 0:45:56 PM', tz,
en_US))
self.assertEqual(expected_pm,
datefmt.parse_date('Feb 22, 2011 12:45:56 PM', tz,
en_US))
self.assertEqual(expected_pm,
datefmt.parse_date(u'2011-2-22 下午0:45:56', tz,
zh_CN))
self.assertEqual(expected_pm,
datefmt.parse_date(u'2011-2-22 下午12:45:56', tz,
zh_CN))
def test_i18n_parse_date_datetime_meridiem(self):
tz = datefmt.timezone('GMT +2:00')
expected_am = datetime.datetime(2011, 2, 22, 0, 45, 56, 0, tz)
expected_pm = datetime.datetime(2011, 2, 22, 12, 45, 56, 0, tz)
en_US = Locale.parse('en_US')
zh_CN = Locale.parse('zh_CN')
self.assertEqual(expected_am,
datefmt.parse_date('Feb 22, 2011 0:45:56 AM', tz,
en_US))
self.assertEqual(expected_am,
datefmt.parse_date('Feb 22, 2011 12:45:56 AM', tz,
en_US))
self.assertEqual(expected_am,
datefmt.parse_date(u'2011-2-22 上午0:45:56', tz,
zh_CN))
self.assertEqual(expected_am,
datefmt.parse_date(u'2011-2-22 上午12:45:56', tz,
zh_CN))
self.assertEqual(expected_pm,
datefmt.parse_date('Feb 22, 2011 0:45:56 PM', tz,
en_US))
self.assertEqual(expected_pm,
datefmt.parse_date('Feb 22, 2011 12:45:56 PM', tz,
en_US))
self.assertEqual(expected_pm,
datefmt.parse_date(u'2011-2-22 下午0:45:56', tz,
zh_CN))
self.assertEqual(expected_pm,
datefmt.parse_date(u'2011-2-22 下午12:45:56', tz,
zh_CN))
def _parse_args(self, req):
start = req.args.get('start')
if start:
start = datefmt.parse_date(start, tzinfo=req.tz)
end = req.args.get('end')
if end:
end = datefmt.parse_date(end, tzinfo=req.tz)
duration = req.args.get('duration')
if duration:
try:
duration = int(duration)
except ValueError:
duration = None
return start, end, duration
def valid_date_format(self):
"""
Returns a boolean to indicate if the start and end dates are ISO-8601 format.
We pass these respective values to the trac utils parse_date function,
which will raise a ValueError exception if the date format of the
string is not ISO-8601 compliant.
"""
for date in (self['start'], self['end']):
try:
parse_date(date)
except TracError:
return False
return True
def _parse_args(self, req):
start = req.args.get('start')
if start:
start = datefmt.parse_date(start, tzinfo=req.tz)
end = req.args.get('end')
if end:
end = datefmt.parse_date(end, tzinfo=req.tz)
duration = req.args.get('duration')
if duration:
try:
duration = int(duration)
except ValueError:
duration = None
return start, end, duration
def _validate_add(self, req):
ty = req.args.get('reminder_type')
if ty == 'interval':
try:
req.args['interval'] = int(req.args.get('interval', '').strip())
if req.args['interval'] <= 0:
add_warning(req, "Nonpositive interval value.")
return False
except ValueError:
add_warning(req, "Invalid or missing interval value.")
return False
if req.args.get('unit') not in ['day', 'week', 'month', 'year']:
add_warning(req, "Please select interval unit.")
return False
elif ty == 'date':
try:
time = clear_time(parse_date(req.args.get('date', '').strip()))
req.args['date'] = format_date(time)
now = to_datetime(None)
if time <= now:
add_warning(req, "Date value not in the future.")
return False
except TracError:
add_warning(req, "Invalid or missing date value.")
return False
else:
add_warning(req, "Please select type.")
return False
return True
def _process_add(self, req, ticket):
if req.method == "POST" and self._validate_add(req):
if req.args.get('reminder_type') == 'interval':
time = clear_time(to_datetime(None))
delta = _time_intervals[req.args.get('unit')](req.args.get('interval'))
time += delta
time = to_utimestamp(time)
else:
time = to_utimestamp(parse_date(req.args.get('date')))
origin = to_utimestamp(to_datetime(None))
self.env.db_transaction("""
INSERT INTO ticketreminder
(ticket, time, author, origin, reminded, description)
VALUES (%s, %s, %s, %s, 0, %s)
""", (ticket.id, time, get_reporter_id(req, 'author'),
origin, req.args.get('description')))
add_notice(req, "Reminder has been added.")
req.redirect(get_resource_url(self.env, ticket.resource, req.href) + "#reminders")
add_script(req, 'ticketreminder/js/ticketreminder.js')
data = {
'ticket': ticket,
'date_hint': get_date_format_hint(),
}
return ("ticket_reminder_add.html", data, None)
def testCapacityHours(self):
"""Test the get_capacity_hours() method"""
test_team = self.tm.create(name="Team#1")
self.assert_true(test_team.exists)
test_members = (self.tmm.create(name="Member#1", team=test_team),
self.tmm.create(name="Member#2", team=test_team,
default_capacity=[4,4,4,0,0,0,0]),
self.tmm.create(name="Member#3", team=test_team,
default_capacity=[0,0,0,2,2,0,0]))
for tm in test_members:
self.assert_not_none(tm.team)
self.assert_equals(test_team, tm.team)
# test the default constructor
start_date = parse_date("2008-09-08T08:00:00")
test_sprint = self.teh.create_sprint(name="TestSprint", start=start_date,
duration=10)
# test save and restore
for member in test_members:
self.assert_true(self.tmm.save(member))
test_sprint.team = test_team
test_sprint.save()
weekly_hours = (5 * 6) + (4 + 4 + 4) + (2 + 2)
self.assert_equals(weekly_hours, test_team.capacity().default_hours_of_capacity_per_week())
sprint_hours = 2 * weekly_hours
actual = test_team.capacity().hourly_capacities_in_sprint(test_sprint)
capacity = sum(map(lambda each: each.capacity, actual))
self.assert_almost_equals(sprint_hours, capacity, max_delta=.01)
def _init_defaults(self):
for field in self.fields:
default = None
if field["name"] in self.protected_fields:
# Ignore for new - only change through workflow
pass
elif not field.get("custom"):
default = self.env.config.get("ticket", "default_" + field["name"])
else:
default = field.get("value")
options = field.get("options")
if default and options and default not in options:
try:
default = options[int(default)]
except (ValueError, IndexError):
self.env.log.warning(
'Invalid default value "%s" ' 'for custom field "%s"' % (default, field["name"])
)
if default and field.get("type") == "time":
try:
default = parse_date(default, hint=field.get("format"))
except TracError, e:
self.env.log.warning(
'Invalid default value "%s" ' 'for custom field "%s": %s' % (default, field["name"], e)
)
default = None
if default:
self.values.setdefault(field["name"], default)
def generate_remaining_time_data(self, task, start_date, end_date=None):
def create_burndown_data_change(remaining_time, when):
task[Key.REMAINING_TIME] = str(remaining_time)
task.save_changes(author=task[Key.OWNER], comment='Updated time...', when=when)
# Reset time of the last burndown data change
changes = BurndownDataChangeModelManager(self.env).select(limit=1, order_by=['-id'])
last_burndown_change = changes[0]
last_burndown_change.update_values(when=when).save()
if task.get_type() != Type.TASK:
return
if not end_date:
end_date = parse_date('now')
remaining_time = randint(4,12)
create_burndown_data_change(remaining_time, start_date)
if not task.has_owner:
return
when = start_date + timedelta(hours=randint(4,16))
while when < end_date:
remaining_time += randint(-3,0)
# if the remaining time is set to 0, the task will be closed!
if remaining_time <= 0:
remaining_time = 1
create_burndown_data_change(remaining_time, when)
when += timedelta(hours=randint(4,16))
def _do_add(self, name, time=None):
version = model.Version(self.env)
version.name = name
version.time = parse_date(time, hint='datetime',
locale=get_console_locale(self.env)) \
if time else None
version.insert()
def generate_remaining_time_data(self, task, start_date, end_date=None):
def create_burndown_data_change(remaining_time, when):
task[Key.REMAINING_TIME] = str(remaining_time)
task.save_changes(author=task[Key.OWNER],
comment='Updated time...',
when=when)
# Reset time of the last burndown data change
changes = BurndownDataChangeModelManager(self.env).select(
limit=1, order_by=['-id'])
last_burndown_change = changes[0]
last_burndown_change.update_values(when=when).save()
if task.get_type() != Type.TASK:
return
if not end_date:
end_date = parse_date('now')
remaining_time = randint(4, 12)
create_burndown_data_change(remaining_time, start_date)
if not task.has_owner:
return
when = start_date + timedelta(hours=randint(4, 16))
while when < end_date:
remaining_time += randint(-3, 0)
# if the remaining time is set to 0, the task will be closed!
if remaining_time <= 0:
remaining_time = 1
create_burndown_data_change(remaining_time, when)
when += timedelta(hours=randint(4, 16))
def _init_defaults(self):
for field in self.fields:
default = None
if field['name'] in self.protected_fields:
# Ignore for new - only change through workflow
pass
elif not field.get('custom'):
default = self.env.config.get('ticket',
'default_' + field['name'])
else:
default = field.get('value')
options = field.get('options')
if default and options and default not in options:
try:
default = options[int(default)]
except (ValueError, IndexError):
self.env.log.warning('Invalid default value "%s" '
'for custom field "%s"'
% (default, field['name']))
if default and field.get('type') == 'time':
try:
default = parse_date(default,
hint=field.get('format'))
except TracError, e:
self.env.log.warning('Invalid default value "%s" '
'for custom field "%s": %s'
% (default, field['name'], e))
default = None
if default:
self.values.setdefault(field['name'], default)
def _parse_date_value(self, req, a_formatted_date):
"""Returns the datetime shifted to UTC timezone for the given
formatted date."""
if a_formatted_date:
the_datetime = datefmt.parse_date(a_formatted_date, tzinfo=req.tz)
the_datetime = days_time.shift_to_utc(the_datetime)
return the_datetime
def test_changeset_others(self):
cset = self.repos.get_changeset('0ee9cfd')
self.assert_(isinstance(cset, Changeset), repr(cset))
self.assertEquals(u'0ee9cfd6538b7b994b94a45ed173d9d45272b0c5',
cset.rev)
if self.cached_repository:
self.assertEquals(parse_date('2013-02-15T01:02:07+09:00'),
cset.date)
else:
self.assertEquals('2013-02-15T01:02:07+09:00',
cset.date.isoformat())
self.assertEquals(u'delete, modify, rename, copy\n', cset.message)
self.assertEquals(u'Joé <*****@*****.**>', cset.author)
changes = cset.get_changes()
self.assertEquals((u'dir/tété.txt', Node.FILE, Changeset.DELETE,
u'dir/tété.txt', ROOT_REV), changes.next())
self.assertEquals(
(u'dir2/simple-another.txt', Node.FILE, Changeset.ADD, None, None),
changes.next())
self.assertEquals(
(u'dir2/simple.txt', Node.FILE, Changeset.ADD, None, None),
changes.next())
# Copy root-sample.txt <- dir/sample.txt
self.assertEquals(
(u'root-sample.txt', Node.FILE, Changeset.ADD, None, None),
changes.next())
self.assertEquals((u'root-tété.txt', Node.FILE, Changeset.EDIT,
u'root-tété.txt', ROOT_REV), changes.next())
# Rename āāā-file.txt <- āāā/file.txt
self.assertEquals((u'āāā-file.txt', Node.FILE, Changeset.MOVE,
u'āāā/file.txt', ROOT_REV), changes.next())
self.assertRaises(StopIteration, changes.next)
def testSprintClosedAndIsCurrentlyRunning(self):
"""Tests the is_closed and is_started"""
start = now() - timedelta(days=3) # no risk to get a weekend
s = self.teh.create_sprint("Test", start=start)
self.assert_true(s.is_currently_running)
self.assert_false(s.is_closed)
s.start += timedelta(days=5) # Move 5 to make sure that we will overcome also a normalization over a weekend
self.assert_false(s.is_currently_running, "%s <= %s < %s" % \
(s.start, start, s.end))
self.assert_false(s.is_closed)
# check functions for an old, closed sprint
s.start = parse_date("2008-01-01")
s.end = parse_date("2008-01-31")
self.assert_false(s.is_currently_running)
self.assert_true(s.is_closed)
def testSprintSelect(self):
"""Test the Sprint select function"""
self.manager.create(name="Test Sprint 1",
start=self.start,
end=self.end)
self.manager.create(name="Test Sprint 2",
start=self.start,
end=self.end)
self.manager.create(name="Test Sprint 3",
start=parse_date("2008-06-10"),
end=parse_date("2008-06-30"))
# Now test the select
sprints = self.manager.select(criteria={'end': '> %d' % to_timestamp(now())})
self.assert_equals(len(sprints), 2)
sprints = self.manager.select()
self.assert_equals(len(sprints), 3)
def _init_defaults(self):
for field in self.fields:
default = None
if field['name'] in self.protected_fields:
# Ignore for new - only change through workflow
pass
elif not field.get('custom'):
default = self.env.config.get('ticket',
'default_' + field['name'])
else:
default = field.get('value')
options = field.get('options')
if default and options and default not in options:
try:
default = options[int(default)]
except (ValueError, IndexError):
self.env.log.warning('Invalid default value "%s" '
'for custom field "%s"' %
(default, field['name']))
if default and field.get('type') == 'time':
try:
default = parse_date(default, hint=field.get('format'))
except TracError, e:
self.env.log.warning('Invalid default value "%s" '
'for custom field "%s": %s' %
(default, field['name'], e))
default = None
if default:
self.values.setdefault(field['name'], default)
def _validate_add(self, req):
ty = req.args.get('reminder_type')
if ty == 'interval':
try:
req.args['interval'] = int(
req.args.get('interval', '').strip())
if req.args['interval'] <= 0:
add_warning(req, "Nonpositive interval value.")
return False
except ValueError:
add_warning(req, "Invalid or missing interval value.")
return False
if req.args.get('unit') not in ['day', 'week', 'month', 'year']:
add_warning(req, "Please select interval unit.")
return False
elif ty == 'date':
try:
time = clear_time(parse_date(req.args.get('date', '').strip()))
req.args['date'] = format_date(time)
now = to_datetime(None)
if time <= now:
add_warning(req, "Date value not in the future.")
return False
except TracError:
add_warning(req, "Invalid or missing date value.")
return False
else:
add_warning(req, "Please select type.")
return False
return True
def _do_add(self, name, due=None):
milestone = model.Milestone(self.env)
milestone.name = name
if due is not None:
milestone.due = parse_date(due, hint='datetime',
locale=get_console_locale(self.env))
milestone.insert()
def test_changeset_add(self):
cset = self.repos.get_changeset(ROOT_ABBREV)
self.assert_(isinstance(cset, Changeset), repr(cset))
self.assertEquals(ROOT_REV, cset.rev)
if self.cached_repository:
self.assertEquals(parse_date('2013-02-14T23:01:25+09:00'),
cset.date)
else:
self.assertEquals('2013-02-14T23:01:25+09:00',
cset.date.isoformat())
self.assertEquals(u'Add some files\n', cset.message)
self.assertEquals(u'Joé <*****@*****.**>', cset.author)
changes = cset.get_changes()
self.assertEquals(
(u'.gitignore', Node.FILE, Changeset.ADD, None, None),
changes.next())
self.assertEquals(
(u'dir/sample.txt', Node.FILE, Changeset.ADD, None, None),
changes.next())
self.assertEquals(
(u'dir/tété.txt', Node.FILE, Changeset.ADD, None, None),
changes.next())
self.assertEquals(
(u'root-tété.txt', Node.FILE, Changeset.ADD, None, None),
changes.next())
self.assertEquals(
(u'āāā/file.txt', Node.FILE, Changeset.ADD, None, None),
changes.next())
self.assertRaises(StopIteration, changes.next)
def _process_add(self, req, ticket):
if req.method == "POST" and self._validate_add(req):
if req.args.get('reminder_type') == 'interval':
time = clear_time(to_datetime(None))
delta = _time_intervals[req.args.get('unit')](
req.args.get('interval'))
time += delta
time = to_utimestamp(time)
else:
time = to_utimestamp(parse_date(req.args.get('date')))
origin = to_utimestamp(to_datetime(None))
self.env.db_transaction(
"""
INSERT INTO ticketreminder
(ticket, time, author, origin, reminded, description)
VALUES (%s, %s, %s, %s, 0, %s)
""", (ticket.id, time, get_reporter_id(
req, 'author'), origin, req.args.get('description')))
add_notice(req, "Reminder has been added.")
req.redirect(
get_resource_url(self.env, ticket.resource, req.href) +
"#reminders")
add_script(req, 'ticketreminder/js/ticketreminder.js')
data = {
'ticket': ticket,
'date_hint': get_date_format_hint(),
}
return ("ticket_reminder_add.html", data, None)
def test_parse_date_usec(self):
tz = datefmt.get_timezone('GMT +1:00')
t_utc = datetime.datetime(2009, 12, 1, 11, 0, 0, 98765, datefmt.utc)
self.assertEqual(t_utc,
datefmt.parse_date('2009-12-01T12:00:00.098765', tz))
self.assertEqual(t_utc,
datefmt.parse_date('2009-12-01T12:00:00,098765', tz))
self.assertEqual(datetime.datetime(2009, 12, 1, 11, 0, 0, 98700,
datefmt.utc),
datefmt.parse_date('2009-12-01T12:00:00.0987', tz))
self.assertEqual(datetime.datetime(2009, 12, 1, 11, 0, 0, 90000,
datefmt.utc),
datefmt.parse_date('2009-12-01T12:00:00.09', tz))
self.assertEqual(datetime.datetime(2009, 12, 1, 11, 0, 0, 0,
datefmt.utc),
datefmt.parse_date('2009-12-01T12:00:00.0', tz))
def _do_add(self, name, due=None):
milestone = model.Milestone(self.env)
milestone.name = name
if due is not None:
milestone.due = parse_date(due, hint='datetime',
locale=get_console_locale(self.env))
milestone.insert()
def insert(self):
"""
Insert a new project message row into the database table.
Before any insert transaction is committed, we validate the data.
After a successful insert, appropriate caches are invalidated.
"""
if self.validate():
args = []
for key in self.message_keys:
if key == 'groups':
args.append(json.dumps(self[key]))
elif key in ['start', 'end']:
args.append(to_utimestamp(parse_date(self[key])))
else:
args.append(self[key])
@self.env.with_transaction()
def do_insert(db):
cursor = db.cursor()
self.env.log.debug("Creating new projet message - %s", self['name'])
cursor.execute("""INSERT INTO project_message (name, message,
button, mode, groups,
start, "end", author, created_at)
VALUES (%s, %s, %s, %s, %s,
%s, %s, %s, %s)
""", args)
del self._get_all_messages
def test_parse_date_usec(self):
tz = datefmt.get_timezone('GMT +1:00')
t_utc = datetime.datetime(2009, 12, 1, 11, 0, 0, 98765, datefmt.utc)
self.assertEqual(t_utc,
datefmt.parse_date('2009-12-01T12:00:00.098765', tz))
self.assertEqual(t_utc,
datefmt.parse_date('2009-12-01T12:00:00,098765', tz))
self.assertEqual(
datetime.datetime(2009, 12, 1, 11, 0, 0, 98700, datefmt.utc),
datefmt.parse_date('2009-12-01T12:00:00.0987', tz))
self.assertEqual(
datetime.datetime(2009, 12, 1, 11, 0, 0, 90000, datefmt.utc),
datefmt.parse_date('2009-12-01T12:00:00.09', tz))
self.assertEqual(
datetime.datetime(2009, 12, 1, 11, 0, 0, 0, datefmt.utc),
datefmt.parse_date('2009-12-01T12:00:00.0', tz))
def expand_macro(self, formatter, name, content):
offset = +1
label = None
if content is not None:
if ',' in content:
offset, label = content.split(',', 1)
elif content and content[0] in '+-':
offset = content
else:
label = content
try:
offset = int(offset)
except ValueError:
offset = 0
mp = MyPageModule(self.env)
base = mp.get_mypage_base(formatter.perm.username)
all_mypages = mp.get_all_mypages(base)
r = formatter.resource
if r.realm == 'wiki' and r.id.startswith(base):
mypage = r.id
else:
tzinfo = getattr(formatter.context.req, 'tz', None)
now = datetime.now(tzinfo or localtz)
today = format_date(now, 'iso8601', tzinfo)
mypage = '/'.join([base, today])
selected = base
idx = bisect(all_mypages, mypage)
# adjust to actual position if mypage exists
if 0 <= idx - 1 < len(all_mypages) and all_mypages[idx -1] == mypage:
idx -= 1
self.log.debug("Reference is %s, pos %d in %r",
mypage, idx, all_mypages)
# Special cases: at the beginning or at the end, the
# predecessors resp. successors are "missing"
missing = False
if idx >= len(all_mypages) - 1 and offset > 0:
missing, tooltip = True, _("(at the end)")
elif idx < 1 and offset < 0:
missing, tooltip = True, _("(at the beginning)")
if missing:
if not label:
label, tooltip = tooltip, None
return tag.a(label, title=tooltip, class_='missing')
# Link to the targeted `MyPage` page
idx += offset
selected = all_mypages[max(0, min(idx, len(all_mypages) - 1))]
self.log.debug("With offset %d, going to %d (adjusted to %d)",
offset, idx, max(0, min(idx, len(all_mypages) - 1)))
selected_day = selected.split('/')[-1]
try:
tooltip = _("MyPage for %(day)s",
day=format_date(parse_date(selected_day)))
except TracError:
tooltip = _("non-day page '%(special)'", special=selected_day)
return tag.a(label if label is not None else selected, title=tooltip,
href=formatter.href.wiki(selected))
def _date_convert(self, date_str):
try:
locale = get_console_locale(self._env)
return to_timestamp(parse_date(date_str, hint='date',
locale=locale))
except Exception as excpt:
self._env.log.exception(excpt)
raise EmptyRangeError(excpt.message)
def _do_checkdates(self):
ts = TicketSystem(self.env)
now = datetime.now(utc)
hard_mail = []
soft_mail = []
with self.env.db_query as db:
cursor = db.cursor()
cursor.execute("SELECT id FROM ticket WHERE status != 'closed'")
for row in cursor:
ticket_id = row[0]
t = Ticket(self.env, ticket_id, db)
t['id'] = ticket_id
if t['due_date']:
due_diff = parse_date(t['due_date']) - now
if due_diff <= self.diff_threshold:
hard_mail.append(t)
if t['soft_due_date']:
soft_due_diff = parse_date(t['soft_due_date']) - now
if soft_due_diff <= self.soft_diff_threshold:
soft_mail.append(t)
if len(hard_mail) == 0 and len(soft_mail) == 0:
return
mail_body = "This is your friendly Ticket Due Date Mailer for today.\n\n"
hard_mail=sorted(hard_mail, key=lambda ticket: ticket['due_date'])
soft_mail=sorted(soft_mail, key=lambda ticket: ticket['soft_due_date'])
if len(hard_mail) != 0:
mail_body += "The following tickets are nearing their HARD DEADLINE:\n"
mail_body += " id due_date component summary\n"
for ticket in hard_mail:
mail_body += " % 4d %s % 12s %s\n" % (ticket['id'], ticket['due_date'], ticket['component'], ticket['summary'])
mail_body += "\n"
if len(soft_mail) != 0:
mail_body += "The following tickets are nearing their SOFT DEADLINE:\n"
mail_body += " id soft_due_date component summary\n"
for ticket in soft_mail:
mail_body += " % 4d %s % 12s %s\n" % (ticket['id'], ticket['soft_due_date'], ticket['component'], ticket['summary'])
mail_body += "\n"
mail_body += "See you next time!\n"
mail_body += "Trac Assistent"
print mail_body.encode('utf-8')
def test_parse_date_across_dst_boundary(self):
tz = datefmt.get_timezone('Europe/Zurich')
# DST start - 31 March, 02:00
format = '%Y-%m-%d %H:%M:%S %Z%z'
expected = '2002-03-31 03:30:00 CEST+0200'
# iso8601
t = datefmt.parse_date('2002-03-31T02:30:00', tz)
self.assertEqual(expected, t.strftime(format))
# strptime
t = datetime.datetime(2002, 3, 31, 2, 30)
t = datefmt.parse_date(t.strftime('%x %X'), tz)
self.assertEqual(expected, t.strftime(format))
# i18n datetime
if Locale:
en_US = Locale.parse('en_US')
t = datefmt.parse_date('Mar 31, 2002 02:30', tz, en_US)
self.assertEqual(expected, t.strftime(format))
def test_parse_date_across_dst_boundary(self):
tz = datefmt.get_timezone("Europe/Zurich")
# DST start - 31 March, 02:00
format = "%Y-%m-%d %H:%M:%S %Z%z"
expected = "2002-03-31 03:30:00 CEST+0200"
# iso8601
t = datefmt.parse_date("2002-03-31T02:30:00", tz)
self.assertEqual(expected, t.strftime(format))
# strptime
t = datetime.datetime(2002, 3, 31, 2, 30)
t = datefmt.parse_date(t.strftime("%x %X"), tz)
self.assertEqual(expected, t.strftime(format))
# i18n datetime
if Locale:
en_US = Locale.parse("en_US")
t = datefmt.parse_date("Mar 31, 2002 02:30", tz, en_US)
self.assertEqual(expected, t.strftime(format))
def _do_add(self, name, time=None):
version = model.Version(self.env)
version.name = name
if time is not None:
version.time = time and \
parse_date(time, hint='datetime',
locale=get_console_locale(self.env))
version.insert()
def set_date(name, attr_name = None):
val = attributes.get(name)
if val is None:
return
val = val and parse_date(val, tzinfo=req.tz) or None
if attr_name is not None:
setattr(milestone, attr_name, val)
milestone.ticket[name] = val and str(to_timestamp(val))
def _do_add(self, name, time=None):
version = model.Version(self.env)
version.name = name
if time is not None:
version.time = parse_date(time, hint='datetime',
locale=get_console_locale(self.env)) \
if time else None
version.insert()
def testSprintSelect(self):
"""Test the Sprint select function"""
self.manager.create(name="Test Sprint 1",
start=self.start,
end=self.end)
self.manager.create(name="Test Sprint 2",
start=self.start,
end=self.end)
self.manager.create(name="Test Sprint 3",
start=parse_date("2008-06-10"),
end=parse_date("2008-06-30"))
# Now test the select
sprints = self.manager.select(
criteria={'end': '> %d' % to_timestamp(now())})
self.assert_equals(len(sprints), 2)
sprints = self.manager.select()
self.assert_equals(len(sprints), 3)
def set_date(name, attr_name=None):
val = attributes.get(name)
if val is None:
return
val = val and parse_date(val, tzinfo=req.tz) or None
if attr_name is not None:
setattr(milestone, attr_name, val)
milestone.ticket[name] = val and str(to_timestamp(val))
def test_parse_date_across_dst_boundary(self):
tz = datefmt.get_timezone('Europe/Zurich')
# DST start - 31 March, 02:00
format = '%Y-%m-%d %H:%M:%S %Z%z'
expected = '2002-03-31 03:30:00 CEST+0200'
# iso8601
t = datefmt.parse_date('2002-03-31T02:30:00', tz)
self.assertEqual(expected, t.strftime(format))
# strptime
t = datetime.datetime(2002, 3, 31, 2, 30)
t = datefmt.parse_date(t.strftime('%x %X'), tz)
self.assertEqual(expected, t.strftime(format))
# i18n datetime
if Locale:
en_US = Locale.parse('en_US')
t = datefmt.parse_date('Mar 31, 2002 02:30', tz, en_US)
self.assertEqual(expected, t.strftime(format))
def _parse_date_value(self, req, a_formatted_date):
"""Returns the datetime shifted to UTC timezone for the given
formatted date."""
if a_formatted_date:
the_datetime = datefmt.parse_date(a_formatted_date,
tzinfo=req.tz)
the_datetime = days_time.shift_to_utc(the_datetime)
return the_datetime
def roundtrip(locale):
locale = Locale.parse(locale)
formatted = datefmt.format_datetime(t, tzinfo=tz,
locale=locale)
self.assertEqual(expected,
datefmt.parse_date(formatted, tz, locale))
self.assertEqual(formatted,
datefmt.format_datetime(expected, tzinfo=tz,
locale=locale))
def roundtrip(locale):
locale = Locale.parse(locale)
formatted = datefmt.format_datetime(t, tzinfo=tz,
locale=locale)
self.assertEqual(expected,
datefmt.parse_date(formatted, tz, locale))
self.assertEqual(formatted,
datefmt.format_datetime(expected, tzinfo=tz,
locale=locale))
def testSprintClosedAndIsCurrentlyRunning(self):
"""Tests the is_closed and is_started"""
start = now() - timedelta(days=3) # no risk to get a weekend
s = self.teh.create_sprint("Test", start=start)
self.assert_true(s.is_currently_running)
self.assert_false(s.is_closed)
s.start += timedelta(
days=5
) # Move 5 to make sure that we will overcome also a normalization over a weekend
self.assert_false(s.is_currently_running, "%s <= %s < %s" % \
(s.start, start, s.end))
self.assert_false(s.is_closed)
# check functions for an old, closed sprint
s.start = parse_date("2008-01-01")
s.end = parse_date("2008-01-31")
self.assert_false(s.is_currently_running)
self.assert_true(s.is_closed)
def test_get_node_file(self):
node = self.repos.get_node(u'/dir/sample.txt', '0ee9cfd')
self.assertEquals(u'sample.txt', node.name)
self.assertEquals(u'dir/sample.txt', node.path)
self.assertEquals(Node.FILE, node.kind)
self.assertEquals(u'0ee9cfd6538b7b994b94a45ed173d9d45272b0c5',
node.rev)
self.assertEquals(ROOT_REV, node.created_rev)
self.assertRaises(StopIteration, node.get_entries().next)
self.assertEquals('', node.content_type)
self.assertEquals(465, node.content_length)
content = node.get_content().read()
self.assertEquals(str, type(content))
self.assertEquals(465, len(content))
if self.cached_repository:
self.assertEquals(parse_date('2013-02-14T23:01:25+09:00'),
node.last_modified)
else:
self.assertEquals('2013-02-14T23:01:25+09:00',
node.last_modified.isoformat())
self.assertEquals({'mode': '100644'}, node.get_properties())
node = self.repos.get_node(u'/āāā-file.txt', '0ee9cfd')
self.assertEquals(u'āāā-file.txt', node.name)
self.assertEquals(u'āāā-file.txt', node.path)
self.assertEquals(Node.FILE, node.kind)
self.assertEquals(u'0ee9cfd6538b7b994b94a45ed173d9d45272b0c5',
node.rev)
self.assertEquals(u'0ee9cfd6538b7b994b94a45ed173d9d45272b0c5',
node.created_rev)
self.assertRaises(StopIteration, node.get_entries().next)
self.assertEquals('', node.content_type)
self.assertEquals(37, node.content_length)
content = node.get_content().read()
self.assertEquals(str, type(content))
self.assertEquals(37, len(content))
self.assertEquals('The directory has unicode characters\n', content)
if self.cached_repository:
self.assertEquals(parse_date('2013-02-15T01:02:07+09:00'),
node.last_modified)
else:
self.assertEquals('2013-02-15T01:02:07+09:00',
node.last_modified.isoformat())
self.assertEquals({'mode': '100644'}, node.get_properties())
def parseable_date(date):
"""Determines if the passed date can be parsed and converted
to a valid date
"""
parseable = True
try:
day = parse_date(date)
except TracError:
parseable = False
return parseable
def test_contingents_are_removed_from_capacity(self):
team, member = self.team_with_one_member()
start = parse_date("2008-09-08T08:00:00")
sprint = self.teh.create_sprint(name="SprintWithContingent", start=start, duration=10, team=team)
self.teh.add_contingent_to_sprint('Contingent', 100, sprint)
self._set_default_capacity_for_member(9, member)
capacities = team.capacity().hourly_capacities_in_sprint(sprint)
capacity = sum(map(lambda each: each.capacity, capacities))
self.assert_almost_equals(108 - 100, capacity, max_delta=.01)
def _db_str_to_datetime(value):
if value is None:
return None
try:
return from_utimestamp(long(value))
except ValueError:
pass
try:
return parse_date(value.strip(), utc, 'datetime')
except Exception:
return None
def _db_str_to_datetime(value):
if value is None:
return None
try:
return from_utimestamp(long(value))
except ValueError:
pass
try:
return parse_date(value.strip(), utc, 'datetime')
except Exception:
return None
def expand_macro(self, formatter, name, content, args=None):
hint = '|| yyyy-mm-ddThh:mm:ss || yyyy-mm-ddThh:mm:ss || message'
pattern = "\s*||(.*)||(.*)||(.*)".replace('|', '\|')
pattern = re.compile(pattern)
try:
if content == None:
return tag.div('ShowWhen Macro is not supported. Use WikiProcessor-style instead.', \
class_="system-message")
now = datetime.now(utc)
for line in content.split('\n'):
matched = pattern.match(line)
if matched:
result = matched.groups()
by, to, text = result
by, to = parse_date(by, None, hint), parse_date(to, None, hint)
self.env.log.debug('parsed time range: %s / %s' % (by, to))
if by <= now and now <= to:
return format_to_html(self.env, formatter.context, text)
return None
except Exception, e:
return tag.div(tag.strong(e.title), ': ' + e.message, class_="system-message")
def get_events_from_page(self, page):
event = self.get_raw_event_from_page(page)
if event["date"] is None:
return []
frequency = event.get("frequency")
if frequency:
return self.expand_event(event, frequency)
if event["date"].date() < parse_date("now").date():
return []
return [event]
def import_milestones(self, template_path):
"""Create project milestones from milestone.xml template file.
Deletes existing trac default milestones and creates new ones
based on the information in milestone XML template.
"""
@self.env.with_transaction()
def clear_milestones(db):
"""Clears all rows in milestone table. This value is hard coded
as you can't pass a table name with parameter substitution."""
cursor = db.cursor()
cursor.execute("""DELETE FROM milestone""")
# Parse the XML tree and create milestones
path = os.path.join(template_path, "milestone.xml")
try:
tree = ET.ElementTree(file=path)
for m in tree.getroot():
milestone = model.Milestone(self.env)
if 'name' in m.attrib:
milestone.name = m.attrib['name']
if 'start' in m.attrib:
milestone.start = parse_date(m.attrib['start'])
if 'due' in m.attrib:
milestone.due = parse_date(m.attrib['due'])
if 'completed' in m.attrib:
milestone.completed = parse_date(m.attrib['completed'])
if 'parent' in m.attrib:
milestone.parent = m.attrib['parent']
if m.text:
milestone.description = m.text
# save the milestone
milestone.insert()
except IOError as exception:
if exception.errno == errno.ENOENT:
self.log.info("Path to milestone.xml at %s does not exist. "
"Unable to import milestone data from tempalte.", path)
class ISO8601TestCase(unittest.TestCase):
def test_default(self):
tz = datefmt.timezone('GMT +2:00')
t = datetime.datetime(2010, 8, 28, 11, 45, 56, 123456, tz)
self.assertEqual('2010-08-28',
datefmt.format_date(t, tzinfo=tz, locale='iso8601'))
self.assertEqual('11:45:56+02:00',
datefmt.format_time(t, tzinfo=tz, locale='iso8601'))
self.assertEqual('2010-08-28T11:45:56+02:00',
datefmt.format_datetime(t, tzinfo=tz,
locale='iso8601'))
def test_with_iso8601(self):
tz = datefmt.timezone('GMT +2:00')
t = datetime.datetime(2010, 8, 28, 11, 45, 56, 123456, tz)
self.assertEqual('2010-08-28',
datefmt.format_date(t, 'iso8601', tz, 'iso8601'))
self.assertEqual('11:45:56+02:00',
datefmt.format_time(t, 'iso8601', tz, 'iso8601'))
self.assertEqual('2010-08-28T11:45:56+02:00',
datefmt.format_datetime(t, 'iso8601', tz, 'iso8601'))
def test_with_babel_format(self):
tz = datefmt.timezone('GMT +2:00')
t = datetime.datetime(2010, 8, 28, 11, 45, 56, 123456, tz)
for f in ('short', 'medium', 'long', 'full'):
self.assertEqual('2010-08-28',
datefmt.format_date(t, f, tz, 'iso8601'))
self.assertEqual('11:45',
datefmt.format_time(t, 'short', tz, 'iso8601'))
self.assertEqual('2010-08-28T11:45',
datefmt.format_datetime(t, 'short', tz, 'iso8601'))
self.assertEqual('11:45:56',
datefmt.format_time(t, 'medium', tz, 'iso8601'))
self.assertEqual('2010-08-28T11:45:56',
datefmt.format_datetime(t, 'medium', tz, 'iso8601'))
for f in ('long', 'full'):
self.assertEqual('11:45:56+02:00',
datefmt.format_time(t, f, tz, 'iso8601'))
self.assertEqual('2010-08-28T11:45:56+02:00',
datefmt.format_datetime(t, f, tz, 'iso8601'))
def test_hint(self):
try:
datefmt.parse_date('***', locale='iso8601', hint='date')
except TracError, e:
self.assert_('"YYYY-MM-DD"' in unicode(e))
try:
datefmt.parse_date('***', locale='iso8601', hint='datetime')
except TracError, e:
self.assert_(u'"YYYY-MM-DDThh:mm:ss±hh:mm"' in unicode(e))
def _do_purge(self, age):
when = parse_date(age)
with self.env.db_transaction as db:
ts = to_timestamp(when)
db("""
DELETE FROM session
WHERE authenticated=0 AND last_visit<%s
""", (ts,))
db("""
DELETE FROM session_attribute
WHERE authenticated=0
AND sid NOT IN (SELECT sid FROM session
WHERE authenticated=0)
""")
def _do_save(self, req, db, milestone):
if milestone.exists:
req.perm.assert_permission('MILESTONE_MODIFY')
else:
req.perm.assert_permission('MILESTONE_CREATE')
if not req.args.has_key('name'):
raise TracError('You must provide a name for the milestone.',
'Required Field Missing')
due = req.args.get('duedate', '')
try:
milestone.due = due and parse_date(due) or 0
except ValueError, e:
raise TracError(to_unicode(e), 'Invalid Date Format')