Ejemplo n.º 1
0
    def test_format_compatibility(self):
        tz = datefmt.timezone('GMT +2:00')
        t = datetime.datetime(2010, 8, 28, 11, 45, 56, 123456, datefmt.utc)
        tz_t = datetime.datetime(2010, 8, 28, 13, 45, 56, 123456, tz)

        # Converting babel's format to strftime format
        self.assertEqual(
            tz_t.strftime('%x %H:%M').decode('utf-8'),
            datefmt.format_datetime(t, 'short', tz))
        self.assertEqual(
            tz_t.strftime('%x').decode('utf-8'),
            datefmt.format_date(t, 'short', tz))
        self.assertEqual(
            tz_t.strftime('%H:%M').decode('utf-8'),
            datefmt.format_time(t, 'short', tz))
        for f in ('medium', 'long', 'full'):
            self.assertEqual(
                tz_t.strftime('%x %X').decode('utf-8'),
                datefmt.format_datetime(t, f, tz))
            self.assertEqual(
                tz_t.strftime('%x').decode('utf-8'),
                datefmt.format_date(t, f, tz))
            self.assertEqual(
                tz_t.strftime('%X').decode('utf-8'),
                datefmt.format_time(t, f, tz))
Ejemplo n.º 2
0
 def test_format_datetime_utc(self):
     t = datetime.datetime(1970, 1, 1, 1, 0, 23, 0, datefmt.utc)
     expected = "1970-01-01T01:00:23Z"
     self.assertEqual(datefmt.format_datetime(t, "%Y-%m-%dT%H:%M:%SZ", datefmt.utc), expected)
     self.assertEqual(datefmt.format_datetime(t, "iso8601", datefmt.utc), expected)
     self.assertEqual(datefmt.format_datetime(t, "iso8601date", datefmt.utc), expected.split("T")[0])
     self.assertEqual(datefmt.format_datetime(t, "iso8601time", datefmt.utc), expected.split("T")[1])
Ejemplo n.º 3
0
def event_as_dict(event, own=False):
    tt = event.time_track
    time = 0
    if tt and tt.exists:
        time = tt.time
    else:
        if event.allday:
            time = 24 * 60  #all day event is 24 hours long
        else:
            time = (event.dtend - event.dtstart).seconds / 60

    e = {
        'id': event.id,
        'start': format_datetime(event.dtstart, 'iso8601', utc),
        'end': format_datetime(event.dtend, 'iso8601', utc),
        'allDay': event.allday == 1,
        'name': event.title,
        'own': own,
        'calendar': event.calendar,
        'description': event.description,
        'ticket': event.ticket,
        'timetrack': tt and True or False,
        'auto': (tt and tt.auto and True) or (tt is None and True) or False,
        'time': '%02d:%02d' % (time / 60, time % 60)
    }
    return e
Ejemplo n.º 4
0
    def _all_my_projects(self,owner):
        all_my_projects=[]
        cnx=self.env.get_db_cnx()
        cur=cnx.cursor()
        cur.execute("select * from project where owner='%s'order by id desc;"%owner)
        cur.close()
        cnx.commit()
        cnx.close()
        for i in cur:
            tmp={}
            tmp['proj_full_name']=i[4]
            tmp['proj_name']=i[3]
            if len(i[5])>20:
                tmp['short_description']=i[5][:19]+'...'
            else:
                tmp['short_description']=i[5]
            tmp['description']=i[5]
            tmp['apply_time']=format_datetime(i[6]) #format_datatime(None) is  equal to format_date
            if i[7] is None:
                tmp['exam_time']=''
            else:
                tmp['exam_time']=format_datetime(i[7])
            if i[8]==0:
                tmp['stat']='pending'
            elif i[8]==1:
                tmp['stat']='approved'
            else:
                tmp['stat']='rejected'

            all_my_projects.append(tmp)
        return all_my_projects
Ejemplo n.º 5
0
def event_as_dict(event, own=False):
    tt = event.time_track
    time = 0
    if tt and tt.exists:
        time = tt.time
    else:
        if event.allday:
            time = 24 * 60  # all day event is 24 hours long
        else:
            time = (event.dtend - event.dtstart).seconds / 60

    e = {
        "id": event.id,
        "start": format_datetime(event.dtstart, "iso8601", utc),
        "end": format_datetime(event.dtend, "iso8601", utc),
        "allDay": event.allday == 1,
        "name": event.title,
        "own": own,
        "calendar": event.calendar,
        "description": event.description,
        "ticket": event.ticket,
        "timetrack": tt and True or False,
        "auto": (tt and tt.auto and True) or (tt is None and True) or False,
        "time": "%02d:%02d" % (time / 60, time % 60),
    }
    return e
Ejemplo n.º 6
0
    def expand_macro(self, formatter, name, content):
        env = formatter.env
        req = formatter.req
        if not 'VOTE_VIEW' in req.perm:
            return
        # Simplify function calls.
        format_author = partial(Chrome(self.env).format_author, req)
        if not content:
            args = []
            compact = None
            kw = {}
            top = 5
        else:
            args, kw = parse_args(content)
            compact = 'compact' in args and True
            top = as_int(kw.get('top'), 5, min=0)

        if name == 'LastVoted':
            lst = tag.ul()
            for i in self.get_votes(req, top=top):
                resource = Resource(i[0], i[1])
                # Anotate who and when.
                voted = ('by %s at %s'
                         % (format_author(i[3]),
                            format_datetime(to_datetime(i[4]))))
                lst(tag.li(tag.a(
                    get_resource_description(env, resource, compact and
                                             'compact' or 'default'),
                    href=get_resource_url(env, resource, formatter.href),
                    title=(compact and '%+i %s' % (i[2], voted) or None)),
                    (not compact and Markup(' %s %s' % (tag.b('%+i' % i[2]),
                                                        voted)) or '')))
            return lst

        elif name == 'TopVoted':
            realm = kw.get('realm')
            lst = tag.ul()
            for i in self.get_top_voted(req, realm=realm, top=top):
                if 'up-only' in args and i[2] < 1:
                    break
                resource = Resource(i[0], i[1])
                lst(tag.li(tag.a(
                    get_resource_description(env, resource, compact and
                                             'compact' or 'default'),
                    href=get_resource_url(env, resource, formatter.href),
                    title=(compact and '%+i' % i[2] or None)),
                    (not compact and ' (%+i)' % i[2] or '')))
            return lst

        elif name == 'VoteList':
            lst = tag.ul()
            resource = resource_from_path(env, req.path_info)
            for i in self.get_votes(req, resource, top=top):
                vote = ('at %s' % format_datetime(to_datetime(i[4])))
                lst(tag.li(
                    compact and format_author(i[3]) or
                    Markup(u'%s by %s %s' % (tag.b('%+i' % i[2]),
                                             tag(format_author(i[3])), vote)),
                    title=(compact and '%+i %s' % (i[2], vote) or None)))
            return lst
Ejemplo n.º 7
0
 def test_format_datetime_gmt01(self):
     gmt01 = datefmt.FixedOffset(60, "GMT +1:00")
     t = datetime.datetime(1970, 1, 1, 1, 0, 23, 0, gmt01)
     self.assertEqual("1970-01-01T01:00:23+0100", datefmt.format_datetime(t, "%Y-%m-%dT%H:%M:%S%z", gmt01))
     expected = "1970-01-01T01:00:23+01:00"
     self.assertEqual(datefmt.format_datetime(t, "iso8601", gmt01), expected)
     self.assertEqual(datefmt.format_datetime(t, "iso8601date", gmt01), expected.split("T")[0])
     self.assertEqual(datefmt.format_datetime(t, "iso8601time", gmt01), expected.split("T")[1])
    def render_admin_panel(self, req, cat, page, path_info):
        req.perm.require('SVNVERIFY_REPORT')
        
        rm = RepositoryManager(self.env)
        all_repos = rm.get_all_repositories()
        db = self.env.get_read_db()
        cursor = db.cursor()
        
        if path_info:
            # detailed
            reponame = not is_default(path_info) and path_info or ''
            info = all_repos.get(reponame)
            if info is None:
                raise TracError(_("Repository '%(repo)s' not found",
                                  repo=path_info))

            cursor.execute("SELECT type, time, result, log "
                           "FROM svnverify_log WHERE repository_id = %s "
                           "ORDER BY time DESC LIMIT 1",
                           (info['id'],))
            row = cursor.fetchone()
            if row:
                info['check_type'] = row[0]
                info['time_checked'] = format_datetime(from_utimestamp(row[1]))
                info['pretty_status'] = int(row[2]) == 0 and "OK" or "Warning"
                info['status'] = row[2]
                info['log'] = row[3]
            info['prettydir'] = breakable_path(info['dir'])
            if info['name'] == '':
                info['name'] = "(default)"
            return 'svnverify.html', {"info": info}
        else:
            repositories = {}
            for reponame, info in all_repos.iteritems():
                if info.get('type',rm.repository_type) == "svn" or (rm.repository_type == 'svn' and info.get('type') == ''):
                    info['prettydir'] = breakable_path(info['dir'])
                    try:
                        r = RepositoryManager(self.env).get_repository(reponame)
                        info['rev'] = r.get_youngest_rev()
                        info['display_rev'] = r.display_rev(info['rev'])
                    except:
                        pass
                    cursor.execute("SELECT type, time, result "
                                   "FROM svnverify_log "
                                   "WHERE repository_id = %s "
                                   "ORDER BY time DESC LIMIT 1",
                                   (info['id'],))
                    row = cursor.fetchone()
                    if row:
                        info['check_type'] = row[0]
                        info['time_checked'] = format_datetime(from_utimestamp(row[1]))
                        info['pretty_status'] = int(row[2]) == 0 and "OK" or "Warning"
                        info['status'] = row[2]

                    repositories[reponame] = info

            add_stylesheet(req, 'svnverify/css/svnverify.css')
            return 'svnverifylist.html', {"repositories": repositories}
Ejemplo n.º 9
0
 def runTest(self):
     self._tester.login_as(Usernames.admin)
     # Create the milestone first
     self._tester.create_milestone('milestone2')
     
     # get sprint listing, should be empty
     page_url = self._tester.url + '/admin/agilo/sprints'
     tc.go(page_url)
     tc.url(page_url)
     tc.code(200)
     
     # add new sprint
     sprint_start = normalize_date(now())
     sprint_name = 'Test sprint'
     tc.formvalue('addsprint', 'name', sprint_name)
     tc.formvalue('addsprint', 'start', format_datetime(sprint_start, format='iso8601'))
     tc.formvalue('addsprint', 'duration', '1')
     tc.formvalue('addsprint', 'milestone', 'milestone2')
     tc.submit('add')
     # add redirects to list view, new sprint should be in there
     tc.find(sprint_name)
     # go to detail page
     tc.go("%s/%s" % (page_url, quote(sprint_name)))
     # see if milestone is set correctly
     tc.find('<option selected="selected">\s*milestone2')
     
     # test setting end date, not duration
     tc.formvalue('modcomp', 'description', '[http://www.example.com]')
     tomorrow = sprint_start + timedelta(days=1)
     tc.formvalue('modcomp', 'end', format_datetime(tomorrow, format='iso8601'))
     tc.formvalue('modcomp', 'duration', '')
     tc.submit('save')
     tc.url(page_url)
     
     # duration of the new sprint should be 2
     tc.find('"duration">2</td>')
     
     # --- test invalid values when adding sprint ---
     # no values, should redirect to list view
     tc.formvalue('addsprint', 'name', '')
     tc.submit('add')
     tc.url(page_url)
     
     # invalid date, should throw an error
     tc.formvalue('addsprint', 'name', 'Testsprint 2')
     tc.formvalue('addsprint', 'start', '2008 May 13')
     tc.formvalue('addsprint', 'duration', '1')
     tc.submit('add')
     tc.find('Error: Invalid Date')
     
     # no end date or duration
     tc.go(page_url)
     tc.formvalue('addsprint', 'name', 'Testsprint 2')
     yesterday = now() - timedelta(days=3)
     tc.formvalue('addsprint', 'start', 
                  format_datetime(yesterday, format='iso8601'))
     tc.submit('add')
     tc.url(page_url)
Ejemplo n.º 10
0
 def get_timeline_link(self, req, date, label=None, precision='hours'):
     iso_date = display_date = format_datetime(date, 'iso8601', req.tz)
     fmt = req.session.get('datefmt')
     if fmt and fmt != 'iso8601':
         display_date = format_datetime(date, fmt, req.tz)
     return tag.a(label or iso_date, class_='timeline',
                  title=_("%(date)s in Timeline", date=display_date),
                  href=req.href.timeline(from_=iso_date,
                                         precision=precision))
Ejemplo n.º 11
0
 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))
Ejemplo n.º 12
0
 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))
Ejemplo n.º 13
0
    def get_work_log(self, pid, username=None, mode='all'):
        db = self.env.get_read_db()
        cursor = db.cursor()
        if mode == 'user':
            assert username is not None
            cursor.execute('SELECT wl.worker, wl.starttime, wl.endtime, wl.ticket, t.summary, t.status, wl.comment '
                           'FROM work_log wl '
                           'JOIN ticket t ON wl.ticket=t.id '
                           'WHERE t.project_id=%s AND wl.worker=%s '
                           'ORDER BY wl.lastchange DESC',
                           (pid, username))
        elif mode == 'latest':
            cursor.execute('''
                SELECT worker, starttime, endtime, ticket, summary, status, comment 
                FROM (
                    SELECT wl.worker, wl.starttime, wl.endtime, wl.ticket, wl.comment, wl.lastchange,
                    MAX(wl.lastchange) OVER (PARTITION BY wl.worker) latest,
                    t.summary, t.status
                    FROM work_log wl
                    JOIN ticket t ON wl.ticket=t.id AND project_id=%s
                ) wll
                WHERE lastchange=latest
                ORDER BY lastchange DESC, worker
               ''', (pid,))
        else:
            cursor.execute('SELECT wl.worker, wl.starttime, wl.endtime, wl.ticket, t.summary, t.status, wl.comment '
                           'FROM work_log wl '
                           'JOIN ticket t ON wl.ticket=t.id '
                           'WHERE t.project_id=%s '
                           'ORDER BY wl.lastchange DESC, wl.worker',
                           (pid,))

        rv = []
        for user,starttime,endtime,ticket,summary,status,comment in cursor:
            started = to_datetime(starttime)

            if endtime != 0:
                finished = to_datetime(endtime)
                delta = 'Worked for %s (between %s and %s)' % (
                         pretty_timedelta(started, finished),
                         format_datetime(started), format_datetime(finished))
            else:
                finished = 0
                delta = 'Started %s ago (%s)' % (
                         pretty_timedelta(started),
                         format_datetime(started))

            rv.append({'user': user,
                       'starttime': started,
                       'endtime': finished,
                       'delta': delta,
                       'ticket': ticket,
                       'summary': summary,
                       'status': status,
                       'comment': comment})
        return rv
        
Ejemplo n.º 14
0
 def get_timeline_link(self, req, date, label=None, precision='hours'):
     iso_date = display_date = format_datetime(date, 'iso8601', req.tz)
     fmt = req.session.get('datefmt')
     if fmt and fmt != 'iso8601':
         display_date = format_datetime(date, fmt, req.tz)
     return tag.a(label or iso_date,
                  class_='timeline',
                  title=_("%(date)s in Timeline", date=display_date),
                  href=req.href.timeline(from_=iso_date,
                                         precision=precision))
Ejemplo n.º 15
0
 def get_timeline_link(self, req, date, label=None, precision="hours"):
     iso_date = display_date = format_datetime(date, "iso8601", req.tz)
     fmt = req.session.get("datefmt")
     if fmt and fmt != "iso8601":
         display_date = format_datetime(date, fmt, req.tz)
     return tag.a(
         label or iso_date,
         class_="timeline",
         title=_("%(date)s in Timeline", date=display_date),
         href=req.href.timeline(from_=iso_date, precision=precision),
     )
Ejemplo n.º 16
0
 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"))
Ejemplo n.º 17
0
 def test_format_datetime_gmt01(self):
     gmt01 = datefmt.FixedOffset(60, 'GMT +1:00')
     t = datetime.datetime(1970,1,1,1,0,23,0,gmt01)
     expected = '1970-01-01T01:00:23+0100'
     self.assertEqual(datefmt.format_datetime(t, '%Y-%m-%dT%H:%M:%S%z',
                                              gmt01), expected)
     self.assertEqual(datefmt.format_datetime(t, 'iso8601',
                                              gmt01), expected)
     self.assertEqual(datefmt.format_datetime(t, 'iso8601date', gmt01),
                                              expected.split('T')[0])
     self.assertEqual(datefmt.format_datetime(t, 'iso8601time', gmt01),
                                              expected.split('T')[1])
Ejemplo n.º 18
0
        def test_format_compatibility(self):
            tz = datefmt.timezone("GMT +2:00")
            t = datetime.datetime(2010, 8, 28, 11, 45, 56, 123456, datefmt.utc)
            tz_t = datetime.datetime(2010, 8, 28, 13, 45, 56, 123456, tz)
            en_US = Locale.parse("en_US")

            # Converting default format to babel's format
            self.assertEqual("Aug 28, 2010 1:45:56 PM", datefmt.format_datetime(t, "%x %X", tz, en_US))
            self.assertEqual("Aug 28, 2010", datefmt.format_datetime(t, "%x", tz, en_US))
            self.assertEqual("1:45:56 PM", datefmt.format_datetime(t, "%X", tz, en_US))
            self.assertEqual("Aug 28, 2010", datefmt.format_date(t, "%x", tz, en_US))
            self.assertEqual("1:45:56 PM", datefmt.format_time(t, "%X", tz, en_US))
Ejemplo n.º 19
0
    def process_request(self, req):
        req.perm.assert_permission('REQUIREMENT_VIEW')
        
        if req.perm.has_permission('REQUIREMENT_CREATE'):
            req.hdf['report.add_requirement_href'] = req.href.newrequirement()

        req.hdf['report.edit_fphyp_href'] = req.href('editdict', 'fp')

        db = self.env.get_db_cnx()

        report = req.args.get('report', '')

        # only for use in reports showing (nearly) all requirements
        if (report == '1' or report == '2' or report == '3'):
            # flag the report to use the validation button
            req.hdf['report.is_all_reqs_report'] = 1

            myreq = Requirement(self.env)
            req.hdf['report.currently_validated'] = \
                myreq.get_current_reqs_validated()
            validation_time = myreq.get_most_recent_validation()
            if validation_time is not None:
                req.hdf['report.latest_validation'] = \
                    format_datetime(validation_time)
            else:
                req.hdf['report.latest_validation'] = '(None)'

            # get the value from the validation button if it exists:
            if req.method == 'POST':
                validate = req.args.get('ValidateSubmit', '')
                if validate == 'Validate':
                    # set this flag...
                    # ... and validate the current set of requirements:
                    if myreq.validate_requirements():
                        req.hdf['report.validate'] = 2
                        req.hdf['report.latest_validation'] = format_datetime()
                    else:
                        req.hdf['report.validate'] = 1
                        
                    
        if report is not '':
            add_link(req, 'up', req.href('requirements', 'report'))

        resp = self._render_view(req, db, report)
        if not resp:
           return None
        template, content_type = resp
        if content_type:
           return resp

        add_stylesheet(req, 'hw/css/req_report.css')
        return 'req_report.cs', None
Ejemplo n.º 20
0
 def test_format_datetime_utc(self):
     t = datetime.datetime(1970, 1, 1, 1, 0, 23, 0, datefmt.utc)
     expected = '1970-01-01T01:00:23Z'
     self.assertEqual(datefmt.format_datetime(t, '%Y-%m-%dT%H:%M:%SZ',
                                              datefmt.utc), expected)
     self.assertEqual(datefmt.format_datetime(t, 'iso8601',
                                              datefmt.utc), expected)
     self.assertEqual(datefmt.format_datetime(t, 'iso8601date',
                                              datefmt.utc), 
                                              expected.split('T')[0])
     self.assertEqual(datefmt.format_datetime(t, 'iso8601time',
                                              datefmt.utc), 
                                              expected.split('T')[1])
Ejemplo n.º 21
0
 def _get_sprint(self, req, sprint_name):
     """Retrieve the Sprint for the given name"""
     get_sprint = SprintController.GetSprintCommand(self.env,
                                                    sprint=sprint_name)
     sprint = SprintController(self.env).process_command(get_sprint)
     # we need to convert sprint dates into local timezone
     sprint.start = format_datetime(sprint.start, tzinfo=req.tz)
     sprint.end = format_datetime(sprint.end, tzinfo=req.tz)
     if sprint.team is None:
         msg = _("No Team has been assigned to this Sprint...")
         if not msg in req.chrome['warnings']:
             add_warning(req, msg)
     return sprint
Ejemplo n.º 22
0
 def test_format_datetime_utc(self):
     t = datetime.datetime(1970, 1, 1, 1, 0, 23, 0, datefmt.utc)
     expected = '1970-01-01T01:00:23Z'
     self.assertEqual(datefmt.format_datetime(t, '%Y-%m-%dT%H:%M:%SZ',
                                              datefmt.utc), expected)
     self.assertEqual(datefmt.format_datetime(t, 'iso8601',
                                              datefmt.utc), expected)
     self.assertEqual(datefmt.format_datetime(t, 'iso8601date',
                                              datefmt.utc), 
                                              expected.split('T')[0])
     self.assertEqual(datefmt.format_datetime(t, 'iso8601time',
                                              datefmt.utc), 
                                              expected.split('T')[1])
Ejemplo n.º 23
0
    def test_format_compatibility(self):
        tz = datefmt.timezone("GMT +2:00")
        t = datetime.datetime(2010, 8, 28, 11, 45, 56, 123456, datefmt.utc)
        tz_t = datetime.datetime(2010, 8, 28, 13, 45, 56, 123456, tz)

        # Converting babel's format to strftime format
        self.assertEqual(tz_t.strftime("%x %H:%M").decode("utf-8"), datefmt.format_datetime(t, "short", tz))
        self.assertEqual(tz_t.strftime("%x").decode("utf-8"), datefmt.format_date(t, "short", tz))
        self.assertEqual(tz_t.strftime("%H:%M").decode("utf-8"), datefmt.format_time(t, "short", tz))
        for f in ("medium", "long", "full"):
            self.assertEqual(tz_t.strftime("%x %X").decode("utf-8"), datefmt.format_datetime(t, f, tz))
            self.assertEqual(tz_t.strftime("%x").decode("utf-8"), datefmt.format_date(t, f, tz))
            self.assertEqual(tz_t.strftime("%X").decode("utf-8"), datefmt.format_time(t, f, tz))
Ejemplo n.º 24
0
 def test_format_datetime_gmt01(self):
     gmt01 = datefmt.FixedOffset(60, 'GMT +1:00')
     t = datetime.datetime(1970, 1, 1, 1, 0, 23, 0, gmt01)
     self.assertEqual(
         '1970-01-01T01:00:23+0100',
         datefmt.format_datetime(t, '%Y-%m-%dT%H:%M:%S%z', gmt01))
     expected = '1970-01-01T01:00:23+01:00'
     self.assertEqual(datefmt.format_datetime(t, 'iso8601', gmt01),
                      expected)
     self.assertEqual(datefmt.format_datetime(t, 'iso8601date', gmt01),
                      expected.split('T')[0])
     self.assertEqual(datefmt.format_datetime(t, 'iso8601time', gmt01),
                      expected.split('T')[1])
Ejemplo n.º 25
0
 def _get_sprint(self, req, sprint_name):
     """Retrieve the Sprint for the given name"""
     get_sprint = SprintController.GetSprintCommand(self.env,
                                                    sprint=sprint_name)
     sprint = SprintController(self.env).process_command(get_sprint)
     # we need to convert sprint dates into local timezone
     sprint.start = format_datetime(sprint.start, tzinfo=req.tz)
     sprint.end = format_datetime(sprint.end, tzinfo=req.tz)
     if sprint.team is None:
         msg = _("No Team has been assigned to this Sprint...")
         if not msg in req.chrome['warnings']:
             add_warning(req, msg)
     return sprint
Ejemplo n.º 26
0
 def _do_list(self):
     print_table(
         [(m.name, m.due
           and format_date(m.due, console_date_format), m.completed
           and format_datetime(m.completed, console_datetime_format))
          for m in model.Milestone.select(self.env)],
         [_("Name"), _("Due"), _("Completed")])
Ejemplo n.º 27
0
def send_project_index(environ,
                       start_response,
                       parent_dir=None,
                       env_paths=None):
    req = Request(environ, start_response)

    loadpaths = [pkg_resources.resource_filename('trac', 'templates')]
    use_clearsilver = False
    if req.environ.get('trac.env_index_template'):
        tmpl_path, template = os.path.split(
            req.environ['trac.env_index_template'])
        loadpaths.insert(0, tmpl_path)
        use_clearsilver = template.endswith('.cs')  # assume Clearsilver
        if use_clearsilver:
            req.hdf = HDFWrapper(
                loadpaths)  # keep that for custom .cs templates
    else:
        template = 'index.html'

    data = {
        'trac': {
            'version': TRAC_VERSION,
            'time': format_datetime()
        },
        'req': req
    }
    if req.environ.get('trac.template_vars'):
        for pair in req.environ['trac.template_vars'].split(','):
            key, val = pair.split('=')
            data[key] = val
            if use_clearsilver:
                req.hdf[key] = val
    try:
        href = Href(req.base_path)
        projects = []
        for env_name, env_path in get_environments(environ).items():
            try:
                env = open_environment(env_path,
                                       use_cache=not environ['wsgi.run_once'])
                proj = {
                    'env': env,
                    'name': env.project_name,
                    'description': env.project_description,
                    'href': href(env_name)
                }
            except Exception, e:
                proj = {'name': env_name, 'description': to_unicode(e)}
            projects.append(proj)
        projects.sort(lambda x, y: cmp(x['name'].lower(), y['name'].lower()))

        data['projects'] = projects
        if use_clearsilver:
            req.hdf['projects'] = projects
            req.display(template)

        loader = TemplateLoader(loadpaths, variable_lookup='lenient')
        tmpl = loader.load(template)
        stream = tmpl.generate(**data)
        output = stream.render('xhtml', doctype=DocType.XHTML_STRICT)
        req.send(output, 'text/html')
Ejemplo n.º 28
0
    def convert_content(self, req, input_type, text, output_type):
        page_name = req.args.get('page', 'WikiStart')
        wikipage = WikiPage(self.env, page_name)
        
        wikiprint = WikiPrint(self.env)
        
        page = wikiprint.wikipage_to_html(text, page_name, req)
        
        #Get page title from first header in outline
        out = StringIO.StringIO()
        context = Context(Resource('wiki', page_name), req.abs_href, req.perm)
        context.req = req

        outline = OutlineFormatter(self.env, context)
        outline.format(text, out, 1, 1)
        
        title = wikipage.name
        for depth, anchor, text in outline.outline:
            if depth == 1:
                title = text
                break
        
        out = wikiprint.html_to_pdf(req, [page], book = (output_type == 'pdfbook'),
            title=title,
            subject="%s - %s" % (self.env.project_name, page_name),
            version=str(wikipage.version),
            date=format_datetime(to_datetime(None)))
        return (out, 'application/pdf')
Ejemplo n.º 29
0
 def _format_sprint_and_metrics(self, req, metrics_by_sprint, available_metrics, team):
     def build_url(sprint):
         return TeamSprintPlanningView(self.env).get_url(req, team.name,
                                                         sprint.name)
     
     sprints = []
     for sprint, metrics in metrics_by_sprint:
         sprint.start = format_datetime(sprint.start, tzinfo=req.tz)
         sprint.end = format_datetime(sprint.end, tzinfo=req.tz)
         sprint.metrics = {}
         for name in available_metrics:
             formatted_value = Renderer(metrics.get(name), name, env=self.env).render()
             sprint.metrics[name] = formatted_value
         sprint.url = build_url(sprint)
         sprints.append(sprint)
     return sprints
Ejemplo n.º 30
0
 def expand_macro(self, formatter, name, content):
     
     if not content:
         return ''
     
     args, kwargs = parse_args(content)        
     if len(args) > 1:
         return system_message("Number of args can't be greater than 1")
     
     if args[0] == 'author':
         page = WikiPage(self.env, formatter.context.resource, 1)
         text = page.author 
     elif args[0] == 'version':
         page = WikiPage(self.env, formatter.context.resource)
         text = str(page.version)
     elif args[0] == 'changed_by':
         page = WikiPage(self.env, formatter.context.resource)
         text = page.author
     elif args[0] == 'comment':
         page = WikiPage(self.env, formatter.context.resource)
         text = page.comment
     elif args[0] == 'changed_ts':
         page = WikiPage(self.env, formatter.context.resource)
         text = format_datetime(page.time)
     else:
         return system_message("Unkwown argument %s" % args[0])
     
     return format_to_oneliner(self.env, formatter.context, text)
Ejemplo n.º 31
0
    def convert_content(self, req, input_type, text, output_type):
        page_name = req.args.get('page', 'WikiStart')
        wikipage = WikiPage(self.env, page_name)

        wikiprint = WikiPrint(self.env)

        page = wikiprint.wikipage_to_html(text, page_name, req)

        #Get page title from first header in outline
        out = StringIO.StringIO()
        context = Context(Resource('wiki', page_name), req.abs_href, req.perm)
        context.req = req

        outline = OutlineFormatter(self.env, context)
        outline.format(text, out, 1, 1)

        title = wikipage.name
        for depth, anchor, text in outline.outline:
            if depth == 1:
                title = text
                break

        out = wikiprint.html_to_pdf(req, [page],
                                    book=(output_type == 'pdfbook'),
                                    title=title,
                                    subject="%s - %s" %
                                    (self.env.project_name, page_name),
                                    version=str(wikipage.version),
                                    date=format_datetime(to_datetime(None)))
        return (out, 'application/pdf')
Ejemplo n.º 32
0
    def _render_history(self, req, db, page):
        """Extract the complete history for a given page and stores it in the
        HDF.

        This information is used to present a changelog/history for a given
        page.
        """
        req.perm.assert_permission('WIKI_VIEW')

        if not page.exists:
            raise TracError, "Page %s does not exist" % page.name

        self._set_title(req, page, u'历史')

        history = []
        for version, t, author, comment, ipnr in page.get_history():
            history.append({
                'url':
                req.href.wiki(page.name, version=version),
                'diff_url':
                req.href.wiki(page.name, version=version, action='diff'),
                'version':
                version,
                'time':
                format_datetime(t),
                'time_delta':
                pretty_timedelta(t),
                'author':
                author,
                'comment':
                wiki_to_oneliner(comment or '', self.env, db),
                'ipaddr':
                ipnr
            })
        req.hdf['wiki.history'] = history
Ejemplo n.º 33
0
    def _get_script_data(self, req, data, dateinfo):
        plural_forms = self._get_plural_forms()
        script_data = {
            'units': self._get_units(plural_forms[0]),
            'pluralexpr': plural_forms[1],
            'starttime': format_datetime(format='iso8601', tzinfo=req.tz),
        }
        if data.get('pretty_dateinfo'): # 1.0+
            in_future = datetime.now(req.tz) + timedelta(days=1)
            in_future = data['pretty_dateinfo'](in_future, format='absolute',
                                                dateonly=True).tag != 'a'
            absolute = {'past': dgettext('messages',
                                         "See timeline %(relativetime)s ago") \
                                .replace('%(relativetime)s', '%(relative)s')}
            if in_future:
                # 1.1+
                relative = {'past': dgettext('messages', "%(relative)s ago")}
                absolute['future'] = relative['future'] = \
                                        dgettext('messages', "in %(relative)s")
            else:
                absolute['future'] = absolute['past']
                relative = dgettext('messages', "%(relativetime)s ago") \
                           .replace('%(relativetime)s', '%(relative)s')
                relative = {'future': relative, 'past': relative}

            script_data.update({'format': dateinfo, 'relative': relative,
                                'absolute': absolute})
        return script_data
Ejemplo n.º 34
0
 def _do_list(self):
     print_table([(m.name, m.due and
                     format_date(m.due, console_date_format),
                   m.completed and
                     format_datetime(m.completed, console_datetime_format))
                  for m in model.Milestone.select(self.env)],
                 [_("Name"), _("Due"), _("Completed")])
Ejemplo n.º 35
0
    def process_downloads(self, context):
        # Clear data for next request.
        self.data = {}

        # Get database access.
        db = self.env.get_db_cnx()
        context.cursor = db.cursor()

        # Get request mode
        modes = self._get_modes(context)
        self.log.debug('modes: %s' % modes)

        # Perform mode actions
        self._do_action(context, modes)

        # Fill up HDF structure and return template
        self.data['authname'] = context.req.authname
        self.data['time'] = format_datetime(datetime.now(utc))
        self.data['realm'] = context.resource.realm

        # Add CSS styles
        add_stylesheet(context.req, 'common/css/wiki.css')
        add_stylesheet(context.req, 'downloads/css/downloads.css')
        add_stylesheet(context.req, 'downloads/css/admin.css')

        # Add JavaScripts
        add_script(context.req, 'common/js/trac.js')
        add_script(context.req, 'common/js/wikitoolbar.js')

        # Commit database changes and return template and data.
        db.commit()
        self.env.log.debug(self.data)
        return modes[-1] + '.html', {'downloads' : self.data}
Ejemplo n.º 36
0
 def pretty_release_time(self, req, user):
     """Convenience method for formatting lock time to string."""
     ts_release = self.release_time(user)
     if ts_release is None:
         return None
     return format_datetime(to_datetime(
         self.release_time(user)), tzinfo=req.tz)
Ejemplo n.º 37
0
    def _render_history(self, req, db, page):
        """Extract the complete history for a given page and stores it in the
        HDF.

        This information is used to present a changelog/history for a given
        page.
        """
        req.perm.assert_permission('WIKI_VIEW')

        if not page.exists:
            raise TracError, "Page %s does not exist" % page.name

        self._set_title(req, page, u'历史')

        history = []
        for version, t, author, comment, ipnr in page.get_history():
            history.append({
                'url': req.href.wiki(page.name, version=version),
                'diff_url': req.href.wiki(page.name, version=version,
                                          action='diff'),
                'version': version,
                'time': format_datetime(t),
                'time_delta': pretty_timedelta(t),
                'author': author,
                'comment': wiki_to_oneliner(comment or '', self.env, db),
                'ipaddr': ipnr
            })
        req.hdf['wiki.history'] = history
Ejemplo n.º 38
0
    def _format_reminder(self,
                         req,
                         ticket,
                         id,
                         time,
                         author,
                         origin,
                         description,
                         delete_button=True):
        now = to_datetime(None)
        time = to_datetime(time)
        if now >= time:
            when = tag(tag.strong("Right now"), " (pending)")
        else:
            when = tag("In ", tag.strong(pretty_timedelta(time)), " (",
                       format_date(time), ")")

        if description:
            context = Context.from_request(req, ticket.resource)
            desc = tag.div(format_to_oneliner(self.env, context, description),
                           class_="description")
        else:
            desc = tag()

        return tag(
            self._reminder_delete_form(req, id) if delete_button else None,
            when, " - added by ",
            tag.em(Chrome(self.env).authorinfo(req, author)), " ",
            tag.span(pretty_timedelta(origin),
                     title=format_datetime(
                         origin, req.session.get('datefmt', 'iso8601'),
                         req.tz)), " ago.", desc)
Ejemplo n.º 39
0
def attachment_to_hdf(env, req, db, attachment):
    """
    This function have been removed from 0.11, this is copied from 0.10, then modified to 
    work with 0.11
    """
    if not db:
        db = env.get_db_cnx()
    hdf = {
        'filename':
        attachment.filename,
        'description':
        wiki_to_oneliner(attachment.description, env, db, req=req),
        'author':
        attachment.author,
        'ipnr':
        attachment.ipnr,
        'size':
        pretty_size(attachment.size),
        'time':
        format_datetime(attachment.date),
        'age':
        pretty_timedelta(attachment.date),
        'href':
        AttachmentModule(env).get_resource_url(attachment.resource, req.href)
    }
    return hdf
Ejemplo n.º 40
0
 def pretty_release_time(self, req, user):
     """Convenience method for formatting lock time to string."""
     ts_release = self.release_time(user)
     if ts_release is None:
         return None
     return format_datetime(to_datetime(
         self.release_time(user)), tzinfo=req.tz)
Ejemplo n.º 41
0
 def runTest(self):
     """Admin milestone duedate"""
     name = "DueMilestone"
     duedate = datetime_now(tz=utc)
     duedate_string = format_datetime(duedate, tzinfo=utc, locale=locale_en)
     self._tester.create_milestone(name, due=duedate_string)
     tc.find(duedate_string)
Ejemplo n.º 42
0
    def expand_macro(self, formatter, name, content):
        args, kw = parse_args(content)
        page = kw.get('page', '')
        sort = kw.get('sort', 'DESC')
        order = kw.get('order', 'time')

        self.env.log.error('sort %s, order %s' % (sort, order))

        attachment_type = ""
        wiki_path = ""
        if content:
            argv = [arg.strip() for arg in content.split(',')]
            if len(argv) > 0:
                attachment_type = argv[0]

        db = self.env.get_db_cnx()
        if db == None:
            return "No DB connection"

        attachmentFormattedList = ""

        cursor = db.cursor()

        if attachment_type == None or attachment_type == "":
            cursor.execute("SELECT type,id,filename,size,time,description,"
                           "author,ipnr FROM attachment")

        elif page == None or page == "":
            cursor.execute(
                "SELECT type,id,filename,size,time,description,"
                "author,ipnr FROM attachment WHERE type=%s ORDER "
                "BY " + order + " " + sort, (attachment_type, ))

        else:
            cursor.execute(
                "SELECT type,id,filename,size,time,description,"
                "author,ipnr FROM attachment WHERE type=%s and "
                "id=%s ORDER BY " + order + " " + sort,
                (attachment_type, page))

        formatters = {
            "wiki": formatter.href.wiki,
            "ticket": formatter.href.ticket
        }
        types = {"wiki": "", "ticket": "ticket "}

        return tag.ul([
            tag.li(
                tag.a(filename,
                      href=formatter.href.attachment(type + "/" + id + "/" +
                                                     filename)), " (",
                tag.span(pretty_size(size), title=size), ") - ",
                tag.em(format_datetime(time)), " - added by ", tag.em(author),
                " to ", tag.a(types[type] + " " + id,
                              href=formatters[type](id)), " ") for type, id,
            filename, size, time, description, author, ipnr in cursor
        ])

        return attachmentFormattedList
Ejemplo n.º 43
0
 def _do_list(self):
     print_table(
         [(title, int(edits), format_datetime(from_utimestamp(modified),
                                              console_datetime_format))
          for title, edits, modified in self.env.db_query("""
                 SELECT name, max(version), max(time)
                 FROM wiki GROUP BY name ORDER BY name""")
          ], [_("Title"), _("Edits"), _("Modified")])
Ejemplo n.º 44
0
        def test_format_compatibility(self):
            tz = datefmt.timezone('GMT +2:00')
            t = datetime.datetime(2010, 8, 28, 11, 45, 56, 123456, datefmt.utc)
            tz_t = datetime.datetime(2010, 8, 28, 13, 45, 56, 123456, tz)
            en_US = Locale.parse('en_US')

            # Converting default format to babel's format
            self.assertEqual('Aug 28, 2010 1:45:56 PM',
                             datefmt.format_datetime(t, '%x %X', tz, en_US))
            self.assertEqual('Aug 28, 2010',
                             datefmt.format_datetime(t, '%x', tz, en_US))
            self.assertEqual('1:45:56 PM',
                             datefmt.format_datetime(t, '%X', tz, en_US))
            self.assertEqual('Aug 28, 2010',
                             datefmt.format_date(t, '%x', tz, en_US))
            self.assertEqual('1:45:56 PM',
                             datefmt.format_time(t, '%X', tz, en_US))
Ejemplo n.º 45
0
 def _do_list(self, resource):
     (realm, id) = self.split_resource(resource)
     print_table([(a.filename, pretty_size(a.size), a.author,
                   format_datetime(a.date, console_datetime_format),
                   a.description)
                  for a in Attachment.select(self.env, realm, id)],
                 [_('Name'), _('Size'), _('Author'), _('Date'),
                  _('Description')])
Ejemplo n.º 46
0
        def test_format_compatibility(self):
            tz = datefmt.timezone('GMT +2:00')
            t = datetime.datetime(2010, 8, 28, 11, 45, 56, 123456, datefmt.utc)
            tz_t = datetime.datetime(2010, 8, 28, 13, 45, 56, 123456, tz)
            en_US = Locale.parse('en_US')

            # Converting default format to babel's format
            self.assertEqual('Aug 28, 2010 1:45:56 PM',
                             datefmt.format_datetime(t, '%x %X', tz, en_US))
            self.assertEqual('Aug 28, 2010',
                             datefmt.format_datetime(t, '%x', tz, en_US))
            self.assertEqual('1:45:56 PM',
                             datefmt.format_datetime(t, '%X', tz, en_US))
            self.assertEqual('Aug 28, 2010',
                             datefmt.format_date(t, '%x', tz, en_US))
            self.assertEqual('1:45:56 PM',
                             datefmt.format_time(t, '%X', tz, en_US))
Ejemplo n.º 47
0
 def get_timeline_link(self, req, date, label=None, precision='hours',
                       query=None, fragment=None, title=None):
     iso_date = format_datetime(date, 'iso8601', req.tz)
     href = req.href.timeline(from_=iso_date, precision=precision)
     return tag.a(label or iso_date, class_='timeline',
                  title=title or _("See timeline at %(absolutetime)s",
                                   absolutetime=iso_date),
                  href=concat_path_query_fragment(href, query, fragment))
Ejemplo n.º 48
0
 def render(self):
     """Returns a formatted string representing the datetime"""
     if isinstance(self.value, (datetime.date, 
                                datetime.datetime,
                                datetime.time)):
         return datefmt.format_datetime(self.value, 
                                        tzinfo=self.tzinfo)
     return self.value
Ejemplo n.º 49
0
 def _do_list(self, resource):
     realm, id_ = self.split_resource(resource)
     print_table([(a.filename, pretty_size(a.size), a.author,
                   format_datetime(a.date, console_datetime_format),
                   a.description)
                  for a in Attachment.select(self.env, realm, id_)],
                 [_("Name"), _("Size"), _("Author"), _("Date"),
                  _("Description")])
Ejemplo n.º 50
0
 def get_timeline_link(self, req, date, label=None, precision='hours',
                       query=None, fragment=None, title=None):
     iso_date = format_datetime(date, 'iso8601', req.tz)
     href = req.href.timeline(from_=iso_date, precision=precision)
     return tag.a(label or iso_date, class_='timeline',
                  title=title or _("See timeline at %(absolutetime)s",
                                   absolutetime=iso_date),
                  href=concat_path_query_fragment(href, query, fragment))
Ejemplo n.º 51
0
 def _do_list(self):
     print_table(
         [(title, int(edits), format_datetime(from_utimestamp(modified),
                                              console_datetime_format))
          for title, edits, modified in self.env.db_query("""
                 SELECT name, max(version), max(time)
                 FROM wiki GROUP BY name ORDER BY name""")
          ], [_("Title"), _("Edits"), _("Modified")])
Ejemplo n.º 52
0
 def test_attachment_list(self):
     """Attachment list command."""
     attachment = Attachment(self.env, 'wiki', 'SomePage')
     attachment.insert('foo.txt', io.BytesIO(), 0)
     rv, output = self.execute('attachment list wiki:SomePage')
     self.assertEqual(0, rv, output)
     self.assertExpectedResult(output, {
         'date': format_datetime(attachment.date, console_datetime_format)
     })
Ejemplo n.º 53
0
 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'))
Ejemplo n.º 54
0
 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'))
Ejemplo n.º 55
0
 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'))