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_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 _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 _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 _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 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 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 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')