def handle_submit(self, converted):
        try:
            context = self.context
            request = self.request
            key = request.params.get('key')
            if not key or len(key) != 40:
                e = ResetFailed()
                e.page_title = 'Password Reset URL Problem'
                raise e
            users = find_users(context)
            user = users.get_by_login(converted['login'])
            if user is None:
                # XXX should be part of form validation
                raise Exception(login='No such user account exists')
            userid = user.get('id')
            if userid is None:
                userid = user['login']

            profiles = find_profiles(context)
            profile = profiles.get(userid)
            if profile is None:
                # XXX should be part of form validation
                raise Exception(login='No such profile exists')

            if key != getattr(profile, 'password_reset_key', None):
                e = ResetFailed()
                e.page_title = 'Password Reset Confirmation Problem'
                raise e

            now = datetime.datetime.now()
            t = getattr(profile, 'password_reset_time', None)
            if t is None or now - t > max_reset_timedelta:
                e = ResetFailed()
                e.page_title = 'Password Reset Confirmation Key Expired'
                raise e

            # The key matched.  Clear the key and reset the password.
            profile.password_reset_key = None
            profile.password_reset_time = None
            password = converted['password'].encode('UTF-8')
            users.change_password(userid, password)

            page_title = 'Password Reset Complete'
            api = request.api
            api.page_title = page_title
            return render_template_to_response(
                'templates/reset_complete.pt',
                api=api,
                login=converted['login'],
                password=converted['password'],
                )

        except ResetFailed, e:
            api = request.api
            api.page_title = e.page_title
            return render_template_to_response('templates/reset_failed.pt',
                                               api=api)

    def __call__(self, environ, start_response):

        req = Request(environ)
        try:
            resp = req.get_response(self.app)
        except:
            # General failures get wrapped into a General KARL Error
            static_url = req.relative_url(self._static_url, to_application=True)
            home_url = req.relative_url(self._home_url, to_application=True)
            if self._errorlog_url is None:
                errorlog_url = None
            else:
                errorlog_url = req.relative_url(
                    self._errorlog_url, to_application=True
                )

            traceback_info = format_exc()
            resp = render_template_to_response(
                'karl.views:templates/wsgi_errormsg.pt',
                error_message='General Error',
                error_text=GENERAL_MESSAGE %
                           {'system_name': self._system_name},
                static_url=static_url,
                errorlog_url=errorlog_url,
                home_url=home_url,
                traceback_info=traceback_info,
                )
            resp.status = 500
            return resp(environ, start_response)

        status = resp.status_int
        if status in (404, 500):
            static_url = req.relative_url(self._static_url, to_application=True)
            home_url = req.relative_url(self._home_url, to_application=True)
            if self._errorlog_url is None:
                errorlog_url = None
            else:
                errorlog_url = req.relative_url(
                    self._errorlog_url, to_application=True
                )
            error_text = NOTFOUND_MESSAGE if status == 404 else GENERAL_MESSAGE
            error_text %= {'system_name': self._system_name}
            resp = render_template_to_response(
                'karl.views:templates/wsgi_errormsg.pt',
                error_message='Not Found',
                static_url=static_url,
                error_text=error_text,
                home_url=home_url,
                errorlog_url=errorlog_url,
                traceback_info=None,
                )
            resp.status = status
            return resp(environ, start_response)

        return resp(environ, start_response)

    def handle_submit(self, converted):
        try:
            context = self.context
            request = self.request
            key = request.params.get("key")
            if not key or len(key) != 40:
                e = ResetFailed()
                e.page_title = "Password Reset URL Problem"
                raise e
            users = find_users(context)
            user = users.get_by_login(converted["login"])
            if user is None:
                raise ValidationError(login="No such user account exists")
            userid = user.get("id")
            if userid is None:
                userid = user["login"]

            profiles = find_profiles(context)
            profile = profiles.get(userid)
            if profile is None:
                raise ValidationError(login="No such profile exists")

            if key != getattr(profile, "password_reset_key", None):
                e = ResetFailed()
                e.page_title = "Password Reset Confirmation Problem"
                raise e

            now = datetime.datetime.now()
            t = getattr(profile, "password_reset_time", None)
            if t is None or now - t > max_reset_timedelta:
                e = ResetFailed()
                e.page_title = "Password Reset Confirmation Key Expired"
                raise e

            # The key matched.  Clear the key and reset the password.
            profile.password_reset_key = None
            profile.password_reset_time = None
            password = converted["password"].encode("UTF-8")
            users.change_password(userid, password)

            page_title = "Password Reset Complete"
            api = TemplateAPI(context, request, page_title)
            return render_template_to_response(
                "templates/reset_complete.pt", api=api, login=converted["login"], password=converted["password"]
            )

        except ResetFailed, e:
            api = TemplateAPI(context, request, e.page_title)
            return render_template_to_response("templates/reset_failed.pt", api=api)

def stats(context, request):
    me = sys.argv[0]
    me = os.path.abspath(me)
    sandbox = os.path.dirname(os.path.dirname(me))
    outfile_path = os.path.join(sandbox, 'var/stats/', 'stats.csv')
    f = open(outfile_path, 'r')
    lines = f.readlines()
    resp_out = ""
    line_arrays = []
    for line in lines:
        resp_out = resp_out + line + "<br/>"
        line2 = line
        myarr = line2.split(",")
        line_arrays.append(myarr)
    
    page_title = 'Admin Statistics'
    api = TemplateAPI(context, request, page_title)

    return render_template_to_response(
        'templates/stats.pt',
        api = api,
        stats = resp_out,
        comms = line_arrays,
        )

    
    return Response(resp_out)

def login_view(context, request):

    system_name = get_setting(context, 'system_name', 'KARL')

    page_title = '' # Per #366377, don't say what screen
    api = TemplateAPI(context, request, page_title)

    came_from = request.params.get('came_from', request.url)

    if came_from.endswith('login.html'):
        came_from = came_from[:-len('login.html')]
    elif came_from.endswith('logout.html'):
        came_from = came_from[:-len('logout.html')]

    api.status_message = status_message=request.params.get('reason', None)
    response = render_template_to_response(
        'templates/login.pt',
        api=api,
        came_from=came_from,
        nothing='',
        app_url=request.application_url,
        )
    plugins = request.environ.get('repoze.who.plugins', {})
    auth_tkt = plugins.get('auth_tkt')
    if auth_tkt is not None:
        forget_headers = auth_tkt.forget(request.environ, {})
        response.headers.update(forget_headers)
    return response

def delete_profile_view(context, request):

    confirm = request.params.get('confirm')
    if confirm:
        parent = context.__parent__
        name = context.__name__
        find_users(context).remove(name)
        del parent[name]

        if authenticated_userid(request) == name:
            return logout_view(context, request, reason='User removed')
        query = {'status_message': 'Deleted profile: %s' % name}
        location = model_url(parent, request, query=query)

        return HTTPFound(location=location)

    page_title = 'Delete Profile for %s %s' % (context.firstname,
                                               context.lastname)
    api = TemplateAPI(context, request, page_title)

    # Get a layout
    return render_template_to_response(
        'templates/delete_profile.pt',
        api=api,
        )

def stats(context, request):
    """
    This appears to no longer be in use.  If we can't confirm someone is using
    it after some period of time we shoudl probably get rid of it.
    --rossi 5/5/2011
    """
    me = sys.argv[0]
    me = os.path.abspath(me)
    sandbox = os.path.dirname(os.path.dirname(me))
    outfile_path = os.path.join(sandbox, 'var/stats/', 'stats.csv')
    if not os.path.exists(outfile_path):
        raise NotFound
    f = open(outfile_path, 'r')
    lines = f.readlines()
    resp_out = ""
    line_arrays = []
    for line in lines:
        resp_out = resp_out + line + "<br/>"
        line2 = line
        myarr = line2.split(",")
        line_arrays.append(myarr)

    page_title = 'Admin Statistics'
    api = TemplateAPI(context, request, page_title)

    return render_template_to_response(
        'templates/stats.pt',
        api = api,
        stats = resp_out,
        comms = line_arrays,
        )

def view_pw_reset(context, request):
    
    # Second step: User is visiting reset url
    if 'key' in request.params:
        key = request.params['key']
        
        if 'form.submitted' in request.params:
            try:
                # FormEncode validation
                schema = PWResetSchema()
                form_result = schema.to_python(request.params)
            except formencode.validators.Invalid, why:
                form = render_template('templates/password_reset.pt', request=request, api=TemplateAPI(request))
                # FormEncode fills template with error messages
                form = htmlfill.render(form, defaults=request.params, errors=why.error_dict)
                return Response(form)
            else:
                session = DBSession()
                user = session.query(User).filter_by(email=form_result['email']).one()
                if key == user.password_reset_key():
                    user.password = '{SHA}%s' % sha.new(form_result['password'].encode('utf-8')).hexdigest()
                    # Login directly
                    headers = []
                    plugins = request.environ.get('repoze.who.plugins', {})
                    identifier = plugins.get('auth_tkt')
                    if identifier:
                        identity = {'repoze.who.userid': form_result['email']}
                        headers = identifier.remember(request.environ, identity)
                    request.environ['repoze.who.userid'] = form_result['email']
                    return HTTPFound(location = model_url(context, request), headers=headers)
                else:
                    statusmessage.show(request, u"Retrieve request not valid.", u"error")
        
        return render_template_to_response('templates/password_reset.pt', request=request, api=TemplateAPI(request))

def calendar_setup_view(context, request):
    default_category_name = ICalendarCategory.getTaggedValue('default_name')
    categories = filter(lambda x: x.__name__ != default_category_name,
                        _get_calendar_categories(context))

    default_layer_name = ICalendarLayer.getTaggedValue('default_name')
    layers = filter(lambda x: x.__name__ != default_layer_name,
                    _get_calendar_layers(context))

    fielderrors = {}
    fielderrors_target = None

    page_title = 'Calendar Setup'
    api = TemplateAPI(context, request, page_title)

    return render_template_to_response(
        'templates/calendar_setup.pt',
        back_to_calendar_url=model_url(context, request),
        categories_url=model_url(context, request, 'categories.html'),
        layers_url=model_url(context, request, 'layers.html'),
        formfields=api.formfields,
        fielderrors=fielderrors,
        fielderrors_target = fielderrors_target,
        api=api,
        editable_categories = categories,
        editable_layers = layers,
        all_categories = _get_all_calendar_categories(context, request),
        colors = _COLORS,
        )

def forbidden(context, request):
    site = find_site(context)
    environ = request.environ
    referrer = environ.get('HTTP_REFERER', '')
    if 'repoze.who.identity' in environ:
        # the user is authenticated but he is not allowed to access this
        # resource
        api = TemplateAPI(context, request, 'Forbidden')
        response =  render_template_to_response(
            'templates/forbidden.pt',
            api=api,
            login_form_url = model_url(site, request, 'login.html'),
            homepage_url = model_url(site, request),
            )
        response.status = '403 Forbidden'
        return response
    elif '/login.html' in referrer:
        url = request.url
        # this request came from a user submitting the login form
        login_url = model_url(site, request, 'login.html',
                              query={'reason':'Bad username or password',
                                     'came_from':url})
        return HTTPFound(location=login_url)
    else:
        # the user is not authenticated and did not come in as a result of
        # submitting the login form
        url = request.url
        query = {'came_from':url}
        while url.endswith('/'):
            url = url[:-1]
        if url != request.application_url: # if request isnt for homepage
            query['reason'] = 'Not logged in'
        login_url = model_url(site, request, 'login.html', query=query)
        return HTTPFound(location=login_url)

def viewall_referencemanual_view(context, request):

    backto = {
        'href': model_url(context.__parent__, request),
        'title': context.__parent__.title,
        }

    page_title = context.title
    api = TemplateAPI(context, request, page_title)

    # Get a layout
    layout_provider = get_layout_provider(context, request)
    layout = layout_provider('intranet')

    # provide client data for rendering current tags in the tagbox
    client_json_data = dict(
        tagbox = get_tags_client_data(context, request),
        )

    return render_template_to_response(
        'templates/viewall_referencemanual.pt',
        api=api,
        actions=[],
        head_data=convert_to_script(client_json_data),
        sections=_get_viewall(context, request, api),
        backto=backto,
        layout=layout,
        )

def report_view(context, request):
    client_json_data = {
        'grid_data': get_grid_data(context, request),
        }
    api = TemplateAPI(context, request, context.title)
    peopledir = find_peopledirectory(context)
    section = context.__parent__
    peopledir_tabs = get_tabs(peopledir, request, section.__name__)

    mgr = ILetterManager(context)
    letter_info = mgr.get_info(request)
    kw, qualifiers = get_search_qualifiers(request)

    descriptions = get_report_descriptions(context)
    print_url = model_url(context, request, 'print.html', **kw)
    csv_url = model_url(context, request, 'csv', **kw)
    pictures_url = model_url(context, request, 'picture_view.html', **kw)
    opensearch_url = model_url(context, request, 'opensearch.xml')

    return render_template_to_response(
        'templates/people_report.pt',
        api=api,
        peopledir=peopledir,
        peopledir_tabs=peopledir_tabs,
        head_data=convert_to_script(client_json_data),
        descriptions=descriptions,
        letters=letter_info,
        print_url=print_url,
        csv_url=csv_url,
        pictures_url=pictures_url,
        qualifiers=qualifiers,
        opensearch_url=opensearch_url,
        actions=get_actions(context, request),
        )

def _add_existing_users(context, community, profiles, text, request, status=None):
    users = find_users(community)
    for profile in profiles:
        group_name = community.members_group_name
        user_name = profile.__name__
        users.add_group(user_name, group_name)

    # Generate HTML and text mail messages and send a mail for
    # each user added to the community.
    community_href = model_url(community, request)
    _send_aeu_emails(community, community_href, profiles, text)

    # We delivered invitation messages to each user.  Redirect to
    # Manage Members with a status message.
    n = len(profiles)
    if n == 1:
        msg = 'One member added and email sent.'
    else:
        fmt = '%s members added and emails sent.'
        msg = fmt % len(profiles)
    if status:
        msg = msg + ' ' + status    
    if request.POST.get('return_to') is not None:
        location  = request.POST['return_to']
        return render_template_to_response('templates/javascript_redirect.pt', 
                url=location)

    else:
        location = model_url(context, request, 'manage.html',
                             query={'status_message': msg})
        return HTTPFound(location=location)

def blog_post_view(context, request):
    result = {}
    obj = context
    dc = obj.metadata.get('dublin',{})
    result['title'] = dc.get('title', obj.__name__)
    result['description'] = dc.get('description', '')
    result['url'] = obj.__name__
    result['created'] = dc.get('created', '')
    result['creator'] = dc.get('creators', [])[0]

    pachs = request.url.split('/')
    img_url =  '/'.join(pachs[0:len(pachs)-2]) + '/img/'

    result['body'] = IHTMLRenderer(obj).html().replace('src="img/', 'src="%s' % img_url)
    tabs = render_tabs(context,request)

    settings = queryUtility(ISettings)
    idcomments_acct = str(getattr(settings, 'idcomments_acct', ''))
    return render_template_to_response('templates/blogpost.pt',
            title = dc.get('title', context.__name__),
            result = result,
            tabs = tabs,
            post_created = getDisplayTime(result['created']),
            idcomments_acct = idcomments_acct,
            )

def syslog_view(context, request):
    syslog_path = get_setting(context, 'syslog_view')
    instances = get_setting(context, 'syslog_view_instances', ['karl'])
    filter_instance = request.params.get('instance', '_any')
    if filter_instance == '_any':
        filter_instances = instances
    else:
        filter_instances = [filter_instance]

    entries = []
    with codecs.open(syslog_path, encoding='utf-8',
                     errors='replace') as syslog:
        for line in syslog:
            line = _decode(line)
            try:
                month, day, time, host, instance, message = line.split(None, 5)
            except ValueError:
                # Ignore lines that don't fit the format
                continue

            if instance not in filter_instances:
                continue
            entries.append(line)
    entries.reverse() # Show more recent entries first

    return render_template_to_response(
        'templates/admin/syslog.pt',
        api=AdminTemplateAPI(context, request),
        menu=_menu_macro(),
        instances=instances,
        instance=filter_instance,
        entries=entries,
    )

def _show_calendar_view(context, request, make_presenter):
    year, month, day = _date_requested(context, request)
    focus_datetime = datetime.datetime(year, month, day)
    now_datetime   = _now()

    # make the calendar presenter for this view
    url_for = _make_calendar_presenter_url_func(context, request)
    calendar = make_presenter(focus_datetime,
                              now_datetime,
                              url_for)

    # find events and paint them on the calendar
    selected_layer = _calendar_filter(context, request)

    events = _get_catalog_events(context, request,
                                 first_moment=calendar.first_moment,
                                 last_moment=calendar.last_moment,
                                 layer_name=selected_layer)
    calendar.paint_events(events)

    layers    = _get_calendar_layers(context)
    setup_url = _calendar_setup_url(context, request)

    # render
    api = TemplateAPI(context, request, calendar.title)
    return render_template_to_response(
        calendar.template_filename,
        api=api,
        setup_url=setup_url,
        calendar=calendar,
        selected_layer = selected_layer,
        layers = layers,
        quote = quote,
        may_create = has_permission(CREATE, context, request),
    )

def logs_view(context, request):
    log_paths = get_setting(context, 'logs_view')
    if len(log_paths) == 1:
        # Only one log file, just view that
        log = log_paths[0]

    else:
        # Make user pick a log file
        log = request.params.get('log', None)

        # Don't let users view arbitrary files on the filesystem
        if log not in log_paths:
            log = None

    if log is not None and os.path.exists(log):
        lines = codecs.open(log, encoding='utf-8',
                            errors='replace').readlines()
    else:
        lines = []

    return render_template_to_response(
        'templates/admin/log.pt',
        api=AdminTemplateAPI(context, request),
        menu=_menu_macro(),
        logs=log_paths,
        log=log,
        lines=lines,
    )

def show_profiles_view(context, request):
    system_name = get_setting(context, "system_name", "KARL")
    page_title = "%s Profiles" % system_name
    api = TemplateAPI(context, request, page_title)

    # Grab the data for the two listings, main communities and portlet
    search = ICatalogSearch(context)

    query = dict(sort_index="title", interfaces=[IProfile], limit=5)

    titlestartswith = request.params.get("titlestartswith")
    if titlestartswith:
        query["titlestartswith"] = (titlestartswith, titlestartswith)

    num, docids, resolver = search(**query)

    profiles = []
    for docid in docids:
        model = resolver(docid)
        if model is None:
            continue
        profiles.append(model)

    mgr = ILetterManager(context)
    letter_info = mgr.get_info(request)

    return render_template_to_response("templates/profiles.pt", api=api, profiles=profiles, letters=letter_info)

def retail_view(context, request):

    page_title = context.title
    api = TemplateAPI(context, request, page_title)

    middle_portlet_html = _get_portlet_html(context, request,
                                            context.middle_portlets)
    right_portlet_html = _get_portlet_html(context, request,
                                           context.right_portlets)
    current_intranet = api.current_intranet
    feature = getattr(find_intranets(current_intranet), 'feature', u'')

    # Rendering this separately gives us a chance later to think about
    # some kind of caching.
    body = render_template(
        'templates/intranethome_body.pt',
        current_intranet=current_intranet,
        feature=feature,
        middle_portlet_html=middle_portlet_html,
        right_portlet_html=right_portlet_html,
        )

    return render_template_to_response(
        'templates/intranet_homepage.pt',
        api=api,
        body=body,
        )

    def handle_submit(self, validated):
        context = self.context
        request = self.request
      
        name = make_unique_name(context, validated['title'])
        creator = authenticated_userid(request)

        text = safe_html(validated['description'])
        
        topic = create_content(IForumTopic,
            validated['title'],
            text,
            creator,
            )

        if text:
            topic.description = extract_description(text)
        else:
            topic.description = validated['title']    
        context[name] = topic
      
        if request.POST.get('return_to') is not None:
            location  = request.POST['return_to']
            return render_template_to_response('templates/javascript_redirect.pt', 
                    url=location)
        else:
            location = model_url(topic, request)
            return HTTPFound(location=location)