def edit_page(context, request): if 'form.submitted' in request.params: context.data = request.params['body'] return HTTPFound(location = model_url(context, request)) return dict(page = context, save_url = model_url(context, request, 'edit_page'))
def resource_to_url(self, resource, **kw): if ICollectionResource in provided_by(resource): query = {} query.update(kw) if not resource.filter is None: query['q'] = \ UrlPartsConverter.make_filter_string(resource.filter) if not resource.order is None: query['sort'] = \ UrlPartsConverter.make_order_string(resource.order) if not resource.slice is None: query['start'], query['size'] = \ UrlPartsConverter.make_slice_strings(resource.slice) if query != {}: url = model_url(resource, self.__request, query=query) else: url = model_url(resource, self.__request) elif not IMemberResource in provided_by(resource): raise ValueError('Can not convert non-resource object "%s to ' 'URL".' % resource) else: if resource.__parent__ is None: raise ValueError('Can not generate URL for floating member ' '"%s".' % resource) url = model_url(resource, self.__request) return unquote(url)
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, save_url=model_url(context, request, "edit_page"), logged_in=logged_in)
def get_forum_data(community, request): karldates = getUtility(IKarlDates) searcher = ICatalogSearch(community) total, docids, resolver = searcher( interfaces=[IForum], path={'query': model_path(community), 'depth': 2}, allowed={'query': effective_principals(request), 'operator': 'or'}, sort_index='title', ) if not total: return None forum_data = [] profiles = find_profiles(community) profiles_href = model_url(profiles, request) for docid in docids: forum = resolver(docid) if forum is not None: D = {} D['title'] = forum.title D['url'] = model_url(forum, request) D['number_of_topics'] = len(forum) D['number_of_comments'] = number_of_comments(forum, request) latest = latest_object(forum, request) _NOW = datetime.datetime.now() if latest: D['latest_activity_url'] = model_url(latest, request) D['latest_activity_link'] = getattr(latest, 'title', None) creator = getattr(latest, 'creator', None) D['latest_activity_byhref'] = profiles_href + creator profile = profiles[creator] D['latest_activity_byname'] = profile.title modified = getattr(latest, 'modified_date', _NOW) modified_str = karldates(modified, 'longform') D['latest_activity_at'] = modified_str else: D['latest_activity_url'] = None D['latest_activity_link'] = None D['latest_activity_by'] = None D['latest_activity_at'] = None forum_data.append(D) return forum_data
def home_view(context, request): main = get_renderer('templates/master.pt').implementation() results = context['results'] results_url = model_url(results, request) all_json_url = model_url(results, request, 'query.json') people_json_url = model_url(results, request, 'query.json', query=dict(category='People')) bottlecap_url = model_url(context, request, 'livesearch') return {'main': main, 'results_url': results_url, 'all_json_url': all_json_url, 'people_json_url': people_json_url, 'bottlecap_url': bottlecap_url, }
def add_page(context, request): name = request.subpath[0] if 'form.submitted' in request.params: body = request.params['body'] page = Page(body) page.__name__ = name page.__parent__ = context context[name] = page return HTTPFound(location = model_url(page, request)) save_url = model_url(context, request, 'add_page', name) page = Page('') page.__name__ = name page.__parent__ = context return dict(page = page, save_url = save_url)
def model_url(self, model, *elements, **kw): """ Return the URL for the model object named ``model``, using ``*elements`` and ``**kw`` as modifiers. This is a convenience method. The result of calling :meth:`pyramid.request.Request.model_url` is the same as calling :func:`pyramid.url.model_url` with an explicit ``request`` parameter. The :meth:`pyramid.request.Request.model_url` method calls the :func:`pyramid.url.model_url` function using the Request object as the ``request`` argument. The ``model``, ``*elements`` and ``*kw`` arguments passed to :meth:`pyramid.request.Request.model_url` are passed through to :func:`pyramid.url.model_url` unchanged and its result is returned. This call to :meth:`pyramid.request.Request.model_url`:: request.route_url(mymodel) Is completely equivalent to calling :func:`pyramid.url.model_url` like this:: from pyramid.url import model_url route_url(model, request) """ return model_url(model, self, *elements, **kw)
def test_it_notsubmitted(self): from pyramid.url import model_url context = testing.DummyModel() request = testing.DummyRequest() info = self._callFUT(context, request) self.assertEqual(info['page'], context) self.assertEqual(info['save_url'], model_url(context, request, 'edit_page'))
def add_page(context, request): name = request.subpath[0] if "form.submitted" in request.params: body = request.params["body"] page = Page(body) page.__name__ = name page.__parent__ = context context[name] = page return HTTPFound(location=model_url(page, request)) save_url = model_url(context, request, "add_page", name) page = Page("") page.__name__ = name page.__parent__ = context logged_in = authenticated_userid(request) return dict(page=page, save_url=save_url, logged_in=logged_in)
def test_it_notsubmitted(self): from pyramid.url import model_url context = testing.DummyModel() request = testing.DummyRequest() request.subpath = ['AnotherPage'] info = self._callFUT(context, request) self.assertEqual(info['page'].data,'') self.assertEqual(info['save_url'], model_url(context, request, 'add_page', 'AnotherPage'))
def check(match): word = match.group(1) if word in wiki: page = wiki[word] view_url = model_url(page, request) return '<a href="%s">%s</a>' % (view_url, word) else: add_url = request.application_url + '/add_page/' + word return '<a href="%s">%s</a>' % (add_url, word)
def results_view(context, request): main = get_renderer('templates/master.pt').implementation() results = [] for result in context.values(): url = model_url(result, request) results.append(dict(url=url, item=result, )) # sort results alphabetically for consistent ordering results.sort(key=lambda x:getattr(x['item'], 'label', None)) return {'main': main, 'results': results}
def view_page(context, request): wiki = context.__parent__ def check(match): word = match.group(1) if word in wiki: page = wiki[word] view_url = model_url(page, request) return '<a href="%s">%s</a>' % (view_url, word) else: add_url = request.application_url + '/add_page/' + word return '<a href="%s">%s</a>' % (add_url, word) content = publish_parts(context.data, writer_name='html')['html_body'] content = wikiwords.sub(check, content) edit_url = model_url(context, request, 'edit_page') return dict(page = context, content = content, edit_url = edit_url)
def generic_result_view(context, request): schema = BaseResultSchema() form = Form(schema, buttons=('submit',)) main = get_renderer('templates/master.pt').implementation() if 'submit' in request.POST: controls = request.POST.items() try: form.validate(controls) except ValidationFailure, e: return {'main': main, 'form':e.render()} context.label = request.POST['label'] context.category = request.POST['category'] context.url = request.POST['url'] context.type = request.POST['type'] return HTTPFound(location=model_url(context, request))
def view_page(context, request): wiki = context.__parent__ def check(match): word = match.group(1) if word in wiki: page = wiki[word] view_url = model_url(page, request) return '<a href="%s">%s</a>' % (view_url, word) else: add_url = request.application_url + "/add_page/" + word return '<a href="%s">%s</a>' % (add_url, word) content = publish_parts(context.data, writer_name="html")["html_body"] content = wikiwords.sub(check, content) edit_url = model_url(context, request, "edit_page") logged_in = authenticated_userid(request) return dict(page=context, content=content, edit_url=edit_url, logged_in=logged_in)
def person_view(context, request): person_schema = PersonSchema() person_form = Form(person_schema, buttons=('submit',)) main = get_renderer('templates/master.pt').implementation() if 'submit' in request.POST: controls = request.POST.items() try: person_form.validate(controls) except ValidationFailure, e: return {'main': main, 'form':e.render()} context.label = request.POST['label'] context.category = request.POST['category'] context.url = request.POST['url'] context.type = request.POST['type'] context.icon = request.POST['icon'] context.department = request.POST['department'] context.extension = request.POST['extension'] return HTTPFound(location=model_url(context, request))
def _callFUT(self, model, request, *elements, **kw): from pyramid.url import model_url return model_url(model, request, *elements, **kw)
def login(request): login_url = model_url(request.context, request, 'login') referrer = request.url if referrer == login_url: referrer = '/' # never use the login form itself as came_from plugins = request.environ.get('repoze.who.plugins', {}) auth_tkt = plugins.get('auth_tkt') login_counter = request.environ['repoze.who.logins'] if login_counter > 0: display_message("Wrong credentials", status="error") came_from = request.params.get("came_from") or "/" if request.params.get('form.submitted', None) is not None: login = request.POST.get('login') password = request.POST.get('password') if login is None or password is None: return HTTPFound(location='%s/login.html' % request.application_url) credentials = {'login': login, 'password': password} max_age = request.POST.get('max_age') if max_age is not None: credentials['max_age'] = int(max_age) # authenticate authenticators = filter(None, [plugins.get(name) for name in ['zodb', 'zodb_impersonate']]) userid = None if authenticators: reason = 'Bad username or password' else: reason = 'No authenticatable users' for plugin in authenticators: userid = plugin.authenticate(request.environ, credentials) if userid: break # if not successful, try again if not userid: challenge_qs['reason'] = reason return HTTPFound(location='%s/login.html?%s' % (request.application_url, urlencode(challenge_qs, doseq=True))) # else, remember credentials['repoze.who.userid'] = userid if auth_tkt is not None: remember_headers = auth_tkt.remember(request.environ, credentials) else: remember_headers = [] # log the time on the user's profile. # profiles = find_profiles(context) # if profiles is not None: # profile = profiles.get(userid) # if profile is not None: # profile.last_login_time = datetime.utcnow() # and redirect return HTTPFound(headers=remember_headers, location=came_from) return render("login", login_counter=login_counter, came_from=came_from)
def month_view(context, request): url = model_url(context, request, 'contenttype.html') return HTTPFound(location=url)
def backto_year(month, request): return dict( title=str(month.__parent__.__name__), href=model_url(month.__parent__, request), )
def backto_metrics(year, request): return dict( title=u'Metrics', href=model_url(year.__parent__, request), )
def view_wiki(context, request): return HTTPFound(location = model_url(context, request, 'FrontPage'))
def model_url_filter(model, *elements, **kw): """A filter from ``model`` to a string representing the absolute URL. this filter call `pyramid.url.model_url`. """ request = get_current_request() return model_url(model, request, *elements, **kw)
def __init__(self, context, request): super(SetupView, self).__init__(context, request) self.response = dict( save_setup_url=model_url(context, request, 'save-setup'), )
def __init__(self, context, request): super(FrontPageView, self).__init__(context, request) self.response = { 'state_url': model_url(context, request, 'state.json'), 'notification_url': model_url(context, request, 'notify'), }
def base_url(self): return model_url(self.context, self.request)
def _make_link(self, context, output): if context.__parent__ is None: return self.lineage_format.format(url=model_url(context, self.request), name='home') + output output = '<a> → </a>' + self.lineage_format.format(url=model_url(context, self.request), name=context.__name__) + output return self._make_link(context.__parent__, output)
def get_url(self, request): """ given the request, returns url to this model instance """ return model_url(self, request)