Python url.model_url函数代码示例

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 _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 add_referencemanual_view(context, request):
    tags_list=request.POST.getall('tags')
    form = AddReferenceManualForm(tags_list=tags_list)

    if 'form.cancel' in request.POST:
        return HTTPFound(location=model_url(context, request))

    if 'form.submitted' in request.POST:
        try:
            converted = form.validate(request.POST)
            # Create the reference manual and store it
            creator = authenticated_userid(request)
            reference_manual = create_content(IReferenceManual,
                                              converted['title'],
                                              converted['description'],
                                              creator,
                                              )
            name = make_unique_name(context, converted['title'])
            context[name] = reference_manual

            # Save the tags on it.
            set_tags(reference_manual, request, converted['tags'])

            location = model_url(reference_manual, request)
            return HTTPFound(location=location)

        except Invalid, e:
            fielderrors = e.error_dict
            fill_values = form.convert(request.POST)
            tags_field = dict(
                records = [dict(tag=t) for t in request.POST.getall('tags')]
                )

def edit_referencesection_view(context, request):

    tags_list = request.POST.getall('tags')
    form = EditReferenceSectionForm(tags_list=tags_list)

    if 'form.cancel' in request.POST:
        return HTTPFound(location=model_url(context, request))

    if 'form.submitted' in request.POST:
        try:
            converted = form.validate(request.POST)
            # *will be* modified event
            objectEventNotify(ObjectWillBeModifiedEvent(context))

            context.title = converted['title']
            context.description = converted['description']

            # Save the tags on it
            set_tags(context, request, converted['tags'])

            # Modified
            context.modified_by = authenticated_userid(request)
            objectEventNotify(ObjectModifiedEvent(context))

            location = model_url(context, request)
            msg = "?status_message=Reference%20section%20edited"
            return HTTPFound(location=location+msg)

        except Invalid, e:
            fielderrors = e.error_dict
            fill_values = form.convert(request.POST)

    def __init__(self, context, request, page_title=None):
        self.context = context
        self.request = request
        self.snippets = get_template("templates/snippets.pt")
        self.snippets.doctype = xhtml
        self.userid = authenticated_userid(request)
        self.app_url = app_url = request.application_url
        self.profile_url = app_url + "/profiles/%s" % self.userid
        self.here_url = self.context_url = model_url(context, request)
        self.view_url = model_url(context, request, request.view_name)
        settings = queryUtility(ISettings)
        self.js_devel_mode = settings and getattr(settings, "js_devel_mode", None)
        self.static_url = "%s/static/%s" % (app_url, _get_static_rev())

        # Provide a setting in the INI to fully control the entire URL
        # to the static.  This is when the proxy runs a different port
        # number, or to "pipeline" resources on a different URL path.
        full_static_path = getattr(settings, "full_static_path", False)
        if full_static_path:
            if "%d" in full_static_path:
                full_static_path = full_static_path % _start_time
            self.static_url = full_static_path
        self.page_title = page_title
        self.system_name = get_setting(context, "system_name", "KARL")
        self.user_is_admin = "group.KarlAdmin" in effective_principals(request)
        site = find_site(context)
        self.admin_url = model_url(site, request, "admin.html")
        self.site_announcement = getattr(site, "site_announcement", "")

def _send_signup_email(request, invitation):
    site = find_site(request.context)
    mailer = getUtility(IMailDelivery)
    
    info = {}
    info['system_name'] = get_setting(site, 'system_name', 'OpenCore')
    info['system_email_domain'] = get_setting(site, 'system_email_domain')
    info['from_name'] = '%s invitation' % info['system_name']
    info['from_email'] = '[email protected]%s' % info['system_email_domain']
    info['c_title'] = info['system_name']
    info['c_description'] = ""
    info['c_href'] = model_url(site, request)
    info['mfrom'] = '%s <%s>' % (info['from_name'], info['from_email'])
    info['subject'] = 'Please join the %s community' % info['system_name']
    
    body_template = get_template('templates/email_signup.pt')

    msg = Message()
    msg['From'] = info['mfrom']
    msg['To'] = invitation.email
    msg['Subject'] = info['subject']
    body = body_template(
        system_name=info['system_name'],
        personal_message=invitation.message,
        invitation_url=model_url(site, request, 'signup', invitation.__name__)
        )

    if isinstance(body, unicode):
        body = body.encode("UTF-8")

    msg.set_payload(body, "UTF-8")
    msg.set_type('text/html')
    mailer.send(info['mfrom'], [invitation.email,], msg)    

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 get_previous_next(context, request):

    # Reference Manual sections have inter-item navigation, which
    # means (sigh) that files and pages do as well.

    # Only works on resources whose parents are orderable
    parent = context.__parent__
    ordering = getattr(parent, 'ordering', None)
    if ordering is None:
        return None, None

    # Be a chicken and sync
    ordering.sync(parent.keys())

    # Find the prev/next names, then flatten some info about them for
    # the ZPT
    current_name = context.__name__
    previous = parent.get(ordering.previous_name(current_name))
    next = parent.get(ordering.next_name(current_name))

    if previous:
        previous = {'title': previous.title,
                    'href': model_url(previous, request)}
    if next:
        next = {'title': next.title,
                    'href': model_url(next, request)}

    return previous, next

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 lock_info_for_view(context, request, from_time=None):
    """return a structure suitable for displaying in a template"""

    if is_locked(context, from_time):
        lock = lock_info(context)
        userid = lock['userid']
        profiles = find_profiles(context)
        profile = profiles.get(userid, None)
        if profile is not None:
            return dict(
                is_locked = True,
                url = model_url(profile, request),
                name = '%s %s' % (profile.firstname,
                                            profile.lastname),
                email = profile.email,
                )
        else:
            return dict(
                is_locked = True,
                url = model_url(profiles, request),
                name = 'Unknown',
                email = '',
                )
    else:
        return dict(
            is_locked = False,
            url = None,
            name = None,
            email = None,
            )

def pages_view(context, request):
    page_urls = [(context[p].dublincore['title'],
                  model_url(context, request, p))
                 for p in request.context.keys()]
    return {'project': PROJECT,
            'page_urls': page_urls,
            'page_add_url': model_url(context, request, "@@page_add")
            }

def edit_page(context, request):
    if 'form.submitted' in request.params:
        context.data = request.params['body']
        return HTTPFound(location = model_url(context, request))

    logged_in = authenticated_userid(request)
    return dict(page = context, logged_in=logged_in,
                save_url = model_url(context, request, 'edit_page'))

def calendar_setup_layers_view(context, request):
    form = CalendarLayersForm()

    default_layer_name = ICalendarLayer.getTaggedValue('default_name')
    layers = filter(lambda x: x.__name__ != default_layer_name,
                    _get_calendar_layers(context))
    layer_titles = [ x.title for x in layers]
    layer_names = [ x.__name__ for x in layers ]

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

    if 'form.delete' in request.POST:
        layer_name = request.POST['form.delete']
        if layer_name == default_layer_name:
            message = 'Cannot delete default layer'
        elif layer_name and layer_name in layer_names:
            title = context[layer_name].title
            del context[layer_name]
            message = '%s layer removed' % title
        else:
            message = 'Layer is invalid'

        location = model_url(context, request, 'layers.html',
                             query={'status_message': message})
        return HTTPFound(location=location)

    fielderrors_target = None
    fielderrors = {}

    if 'form.submitted' in request.POST:
        try:
            converted = form.validate(request.POST)
            category_paths = list(set(request.POST.getall('category_paths')))
            layer_name = generate_name(context)
            layer_title = converted['layer_title']
            layer_color = converted['layer_color']

            if layer_title in layer_titles:
                msg = "Name is already used"
                raise Invalid(value=layer_title, state=None,
                          msg=msg, error_list=None,
                          error_dict={'layer_title': msg})

            layer = create_content(ICalendarLayer,
                                   layer_title, layer_color, category_paths)
            context[layer_name] = layer

            location = model_url(
                context, request,
                'layers.html',
                query={'status_message':'Calendar layer added'})
            return HTTPFound(location=location)

        except Invalid, e:
            fielderrors_target = '__add_layer__'
            fielderrors = e.error_dict

def jquery_livesearch_view(context, request):
    # Prefix search is with a wildcard at the end
    searchterm = request.params.get("val", None)

    if searchterm is None:
        # The request forgot to send the key we use to do a search, so
        # make a friendly error message.  Important for the unit test.
        msg = "Client failed to send a 'val' parameter as the searchterm"
        return HTTPBadRequest(msg)
    else:
        searchterm = searchterm + "*"

    records = LivesearchResults()
    principals = effective_principals(request)

    site_path = model_path(context)

    records.set_header("", pre='<div class="header"></div>')
    records.append_to(
        rowclass="showall",
        title="Show All",
        href=model_url(context, request, "searchresults.html", query={"body": searchterm}),
    )

    for listitem in get_listitems(IGroupSearchFactory):
        utility = listitem["component"]

        factory = utility(context, request, searchterm)

        if factory is None:
            continue

        try:
            num, docids, resolver = factory()
        except ParseError:
            continue

        groupname = listitem["title"]

        records.set_header(groupname, pre='<div class="header">%s</div>' % (groupname,))

        results = filter(None, map(resolver, docids))

        qs = {"body": searchterm, "kind": groupname}
        sr_href = model_url(context, request, "searchresults.html", query=qs)

        for result in results:
            records.append_to(
                rowclass="result", title=getattr(result, "title", "<No Title>"), href=model_url(result, request)
            )

        if results:
            records.append_to(rowclass="showall", title="Show All", href=sr_href)
        else:
            records.append_to(rowclass="noresult", title="No Result", href=sr_href)

    result = JSONEncoder().encode(list(records))
    return Response(result, content_type="application/x-json")

def redirector_view(context, request):
    where = context.target_url
    if not where.startswith('http'):
        if where.startswith('/'):
            where = basejoin(model_url(context, request), where)
        else:
            elements = where.split('/')
            where = model_url(context.__parent__, request, *elements)
    return HTTPFound(location=where)