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