def render(self):
"""Initialize renderer"""
html = []
active = 'active' if self._active else 'inactive'
config = self._field._config.renderer
has_errors = len(self._field.get_errors())
has_warnings = len(self._field.get_warnings())
class_options = "form-group %s %s %s" % ((has_errors and 'has-error'),
(has_warnings and 'has-warning'), (active))
html.append(HTML.tag("div", _closed=False,
rules=u"{}".format(";".join(rules_to_string(self._field))),
formgroup="{}".format(self._field.name),
desired="{}".format(self._field.desired),
required="{}".format(self._field.required),
class_=class_options))
html.append(self._render_label())
# All items which can potentially be linked. However this list
# of items may be already filtered be defining a default filter
# in the overview configuration which is used for this renderer.
items = self.itemlist.items
selected_items = self._get_selected_items(items)
if self._field.readonly or self.onlylinked == "true":
items = selected_items
# Filter options based on the configured filter expression of
# the renderer. Please note the this method return a list of
# tuples.
item_tuples = self._field.filter_options(items)
# Get filtered options and only use the items which are
# in the origin items list and has passed filtering.
item_tuples = self._field.filter_options(items)
# Filter the items again based on the permissions. This means
# resetting the third value in the tuple.
if self.showall != "true" and not self._field.readonly:
item_tuples = filter_options_on_permissions(self._field._form._request,
item_tuples)
values = {'items': item_tuples,
'selected_item_ids': [i.id for i in selected_items],
'field': self._field,
'clazz': self.get_class(),
'pclazz': self._field._form._item.__class__,
'request': self._field._form._request,
'_': self._field._form._translate,
's': security,
'h': helpers,
'url_getter': get_link_url,
'tableconfig': get_table_config(self.itemlist.clazz,
config.table)}
html.append(literal(self.template.render(**values)))
html.append(self._render_errors())
html.append(self._render_help())
html.append(HTML.tag("/div", _closed=False))
return literal("").join(html)
def render(self, request):
"""Initialize renderer"""
# Get the bundles_actions.
# If bundle_actions is True, display checkboxes and more in the table.
bundled_actions = []
for action in get_item_actions(request, self.listing.clazz):
if action.bundle and security.has_permission(action.name.lower(),
request.context,
request):
bundled_actions.append(action)
table_id = self._get_table_id()
table_config = self._render_js_config(request, table_id)
values = {'items': self.listing.items,
'clazz': self.listing.clazz,
'listing': self.listing,
'request': request,
'_': request.translate,
's': security,
'h': ringo.lib.helpers,
'bundled_actions': bundled_actions,
'tableconfig': self.config,
'tableid': table_id,
'dtconfig': table_config}
return literal(self.template.render(**values))
def get_diagram_data(self):
def write_row(series, data, meanvalue=0):
row = []
row.append(str(serialize(getattr(data, self.diagram_data_time))))
for serie in series:
if serie == self._build_series_label(data):
value = getattr(data, self.diagram_data_value) - meanvalue
row.append(str(value))
if self.errors_enabled():
row.append(
str(getattr(data, self.diagram_data_error_value)))
else:
row.append("")
if self.errors_enabled():
row.append("")
return ",".join(row)
def write_header(series):
data = ["Date"]
for serie in series:
data.append(unicode(serie))
return ",".join(data)
series = self._get_series()
data = []
data.append(write_header(series))
for row in getattr(self, self.diagram_data_source):
data.append(write_row(series, row, self._get_meanvalue()))
return literal("\\n".join(data))
def render_file_preview(request, item, column, tableconfig):
"""Returns HTML code to embed a small preview of the file in the
overview"""
if isinstance(item, tuple):
item = item[0]
url = request.route_path(get_action_routename(item, "download"), id=item.id)
return literal('<embed src="{}" height="25" type="{}">'.format(url, item.mime))
def render(self, request):
"""Initialize renderer"""
# Get the bundles_actions.
# If bundle_actions is True, display checkboxes and more in the table.
bundled_actions = []
for action in get_item_actions(request, self.listing.clazz):
if action.bundle and security.has_permission(
action.name.lower(), request.context, request):
bundled_actions.append(action)
table_id = self._get_table_id()
table_config = self._render_js_config(request, table_id,
bundled_actions)
values = {
'items': self.listing.items,
'clazz': self.listing.clazz,
'listing': self.listing,
'request': request,
'_': request.translate,
's': security,
'h': ringo.lib.helpers,
'bundled_actions': bundled_actions,
'tableconfig': self.config,
'tableid': table_id,
'dtconfig': table_config
}
return literal(self.template.render(**values))
def render(self):
"""Initialize renderer"""
html = []
active = 'active' if self._active else 'inactive'
config = self._field._config.renderer
has_errors = len(self._field.get_errors())
has_warnings = len(self._field.get_warnings())
class_options = "form-group %s %s %s" % ((has_errors and 'has-error'),
(has_warnings and 'has-warning'),(active))
html.append(HTML.tag("div", _closed=False,
rules=u"{}".format(";".join(self._field.rules_to_string)),
formgroup="{}".format(self._field.name),
desired="{}".format(self._field.desired),
required="{}".format(self._field.required),
class_=class_options))
html.append(self._render_label())
if self._field.is_readonly() or self.onlylinked == "true":
items = self._get_selected_items(self.itemlist.items)
else:
items = self.itemlist.items
# Get filtered options and only use the items which are
# in the origin items list and has passed filtering.
items = self._field.filter_options(items)
# Now filter the items based on the user permissions
if self.showall != "true":
items = filter_options_on_permissions(self._field._form._request,
items)
values = {'items': items,
'field': self._field,
'clazz': self.get_class(),
'pclazz': self._field._form._item.__class__,
'request': self._field._form._request,
'_': self._field._form._translate,
's': security,
'h': helpers,
'tableconfig': get_table_config(self.itemlist.clazz,
config.table)}
html.append(literal(self.template.render(**values)))
html.append(self._render_errors())
html.append(self._render_help())
html.append(HTML.tag("/div", _closed=False))
return literal("").join(html)
def _render_label(self):
html = []
html.append(FormbarDropdown._render_label(self))
if not self._field.is_readonly() and not self.nolink == "true":
link = self.render_link()
if link:
html.append(" [")
html.append(link)
html.append("]")
return literal("").join(html)
def _render_label(self):
html = []
html.append(FormbarDropdown._render_label(self))
if not self._field.readonly and not self.nolink == "true":
link = self.render_link()
if link:
html.append(" [")
html.append(link)
html.append("]")
return literal("").join(html)
def render_file_preview(request, item, column, tableconfig):
"""Returns HTML code to embed a small preview of the file in the
overview if it is a image. Other file formats are not supported."""
if isinstance(item, tuple):
item = item[0]
if item.mime.startswith("image"):
return literal('<img src="data:{};base64,{}"/>'.format(
item.mime, base64.b64encode(item.thumbnail)))
else:
return ""
def render_link(self):
html = []
items = []
try:
item = getattr(self._field._form._item, self._field.name)
except AttributeError:
log.warning("Missing %s attribute in %s" %
(self._field.name, self._field._form._item))
return literal("").join(html)
if not isinstance(item, list):
items.append(item)
else:
items = item
for item in items:
url = get_link_url(item, self._field._form._request)
if url:
html.append(HTML.tag("a", href=("%s" % url), _closed=False))
html.append(escape(unicode(item)))
html.append(HTML.tag("/a", _closed=False))
return literal("").join(html)
def render_link(self):
html = []
items = []
try:
item = getattr(self._field._form._item, self._field.name)
except AttributeError:
log.warning("Missing %s attribute in %s"
% (self._field.name, self._field._form._item))
return literal("").join(html)
if not isinstance(item, list):
items.append(item)
else:
items = item
for item in items:
url = get_link_url(item, self._field._form._request)
if url:
html.append(HTML.tag("a", href=("%s" % url), _closed=False))
html.append(escape(unicode(item)))
html.append(HTML.tag("/a", _closed=False))
return literal("").join(html)
def render(self, items):
values = {}
values['request'] = self._request
values['items'] = items
values['body'] = self._render_body()
values['modul'] = get_item_modul(self._request, self._item).get_label(plural=True)
values['action'] = self._action.capitalize()
values['ok_url'] = self._request.current_route_path()
values['_'] = self._request.translate
values['cancel_url'] = self._request.referrer
values['evalurl'] = self._request.application_url+get_eval_url()
return literal(self.template.render(**values))
def render(self, items):
_ = self._request.translate
values = {}
values['request'] = self._request
values['items'] = items
values['body'] = self._render_body()
values['modul'] = get_item_modul(self._request, self._item).get_label(plural=True)
values['action'] = _(self._action.capitalize())
values['ok_url'] = self._request.current_route_path()
values['_'] = self._request.translate
values['cancel_url'] = self._request.referrer
values['eval_url'] = self._request.application_url+get_eval_url()
return literal(self.template.render(**values))
def render_strava_sync_status(request, item, field, tableconfig):
_ = request.translate
if not item.strava_id:
return ""
elif not item.time_stream:
filename = request.static_path(
'trainable:static/images/strava_sync.png')
title = _("Activity basically synced with strava")
else:
filename = request.static_path(
'trainable:static/images/strava_full_sync.png')
title = _("Activity completely synced with strava")
return literal('<img src="{}" title="{}"/>'.format(filename, title))
def render(self, url=None):
values = {}
values['icon'] = self.icon
values['header'] = self._title
values['body'] = self._body
history = self._request.session.get('history')
if url:
values['ok_url'] = url
elif history:
values['ok_url'] = self._request.session['history'].pop()
else:
values['ok_url'] = self._request.route_path('home')
values['eval_url'] = self._request.application_url+get_eval_url()
return literal(self.template.render(**values))
def render(self, url=None):
values = {}
values['icon'] = self.icon
values['header'] = self._title
values['body'] = self._body
history = self._request.ringo.history
if url:
values['ok_url'] = url
elif history and history.last():
values['ok_url'] = history.last()
else:
values['ok_url'] = self._request.route_path('home')
values['eval_url'] = self._request.application_url+get_eval_url()
return literal(self.template.render(**values))
def render(self, request):
"""Initialize renderer"""
table_id = self._get_table_id()
values = {'items': self.listing.items,
'clazz': self.listing.clazz,
'listing': self.listing,
'request': request,
'_': request.translate,
's': security,
'h': ringo.lib.helpers,
'tableconfig': self.config,
'tableid': table_id}
return literal(self.template.render(**values))
def render(self, request):
"""Initialize renderer"""
table_id = self._get_table_id()
values = {
'items': self.listing.items,
'clazz': self.listing.clazz,
'listing': self.listing,
'request': request,
'_': request.translate,
's': security,
'h': ringo.lib.helpers,
'tableconfig': self.config,
'tableid': table_id
}
return literal(self.template.render(**values))
def render(self):
modul = get_item_modul(self._request, self._item)
template_modul = get_item_modul(self._request, Printtemplate)
values = {}
values['request'] = self._request
values['body'] = self._render_body()
values['modul'] = modul.get_label(plural=True)
values['header'] = template_modul.get_label(plural=True)
values['action'] = self._action.capitalize()
values['ok_text'] = template_modul.get_label(plural=False)
values['ok_url'] = self._request.current_route_path()
values['_'] = self._request.translate
values['cancel_url'] = self._request.ringo.history.last(
) or self._request.url.replace("print", "read")
values['eval_url'] = self.form._eval_url
values['h'] = ringo.lib.helpers
return literal(self.template.render(**values))
def render(self, request):
# https://www.iconfinder.com/iconsets/sports-android-l-lollipop-icon-pack
if self.sport == 1:
img_url = request.static_path(
'trainable:static/images/sport_icons/running.png')
elif self.sport == 2:
img_url = request.static_path(
'trainable:static/images/sport_icons/regular_biking.png')
else:
img_url = request.static_path(
'trainable:static/images/sport_icons/swimming.png')
out = []
out.append(u'<img src="{}" style="width:55px;"/> '.format(img_url))
out.append(u"{} ".format(self.title))
out.append(u"<small>")
out.append(u"{}".format(self.date))
out.append(u"</small>")
return literal("".join(out))
def render(self, request):
"""Initialize renderer"""
# TODO: Enabled sorting of lists. Mind that these lists might be
# presorted if the user clicked on the header. In this case some
# get params with sort configurations are in the session. This
# logic is currently in base/view. (ti) <2014-01-23 23:15>
# sort_field = self.config.get_default_sort_column()
# sort_order = self.config.get_default_sort_order()
# self.listing.sort(sort_field, sort_order)
if len(self.listing.search_filter) > 0:
search = self.listing.search_filter[-1][0]
search_field = self.listing.search_filter[-1][1]
regexpr = self.listing.search_filter[-1][2]
else:
search = ""
search_field = ""
regexpr = False
ssearch = get_saved_searches(request, self.listing.clazz.__tablename__)
bundled_actions = []
for action in get_item_actions(request, self.listing.clazz):
if action.bundle and security.has_permission(
action.name.lower(), request.context, request):
bundled_actions.append(action)
values = {
'items': self.listing.items,
'clazz': self.listing.clazz,
'listing': self.listing,
'request': request,
'_': request.translate,
'h': ringo.lib.helpers,
's': security,
'bundled_actions': bundled_actions,
'search': search,
'regexpr': regexpr,
'search_field': search_field,
'saved_searches': ssearch,
'tableconfig': self.config
}
return literal(self.template.render(**values))
def render(self, request):
"""Initialize renderer"""
# TODO: Enabled sorting of lists. Mind that these lists might be
# presorted if the user clicked on the header. In this case some
# get params with sort configurations are in the session. This
# logic is currently in base/view. (ti) <2014-01-23 23:15>
# sort_field = self.config.get_default_sort_column()
# sort_order = self.config.get_default_sort_order()
# self.listing.sort(sort_field, sort_order)
if len(self.listing.search_filter) > 0:
search = self.listing.search_filter[-1][0]
search_field = self.listing.search_filter[-1][1]
regexpr = self.listing.search_filter[-1][2]
else:
search = ""
search_field = ""
regexpr = False
ssearch = get_saved_searches(request,
self.listing.clazz.__tablename__)
bundled_actions = []
for action in get_item_actions(request, self.listing.clazz):
if action.bundle and security.has_permission(action.name.lower(),
request.context,
request):
bundled_actions.append(action)
values = {'items': self.listing.items,
'clazz': self.listing.clazz,
'listing': self.listing,
'request': request,
'_': request.translate,
'h': ringo.lib.helpers,
's': security,
'bundled_actions': bundled_actions,
'search': search,
'regexpr': regexpr,
'search_field': search_field,
'saved_searches': ssearch,
'tableconfig': self.config}
return literal(self.template.render(**values))
def render(self, items):
_ = self._request.translate
mapping = {'Action': _(self._action.capitalize())}
values = {}
values['request'] = self._request
values['icon'] = self.icon
if self._title:
values['header'] = self._title
else:
values['header'] = _("Confirm ${Action}", mapping=mapping)
if self._body:
values['body'] = self._body
else:
values['body'] = self._render_body(items)
values['action'] = self.ok_label or _(self._action.capitalize())
values['ok_url'] = self._request.current_route_path()
values['_'] = self._request.translate
values['cancel_url'] = self._request.referrer
values['eval_url'] = self._request.application_url+get_eval_url()
return literal(self.template.render(**values))
def render(self, items):
_ = self._request.translate
mapping = {'Action': _(self._action.capitalize())}
values = {}
values['request'] = self._request
values['icon'] = self.icon
if self._title:
values['header'] = self._title
else:
values['header'] = _("Confirm ${Action}", mapping=mapping)
if self._body:
values['body'] = self._body
else:
values['body'] = self._render_body(items)
values['action'] = self.ok_label or _(self._action.capitalize())
values['ok_url'] = self._request.current_route_path()
values['_'] = self._request.translate
values['cancel_url'] = self._request.referrer
values['eval_url'] = self._request.application_url+get_eval_url()
return literal(self.template.render(**values))
def get_diagram_data(self):
def write_header(series):
header = ["Time"]
for s in sorted(series.keys()):
header.append(str(s))
return ",".join(header)
def write_row(idx, x, series):
row = [str(x)]
for s in sorted(series.keys()):
serie = series.get(s)
if serie:
row.append(str(serie[idx]))
return ",".join(row)
data = []
data.append(write_header(self.diagram_data_series))
if self.diagram_X_data:
for index, value in enumerate(self.diagram_X_data):
data.append(write_row(index, value, self.diagram_data_series))
return literal("\\n".join(data))
def _render_body(self, items):
out = []
_ = self._request.translate
item_label = escape(get_item_modul(self._request,
self._item).get_label())
mapping = {'action': escape(_(self._action.capitalize()).lower()),
'item': item_label,
'Action': escape(_(self._action.capitalize()))}
out.append(_("Do you really want to ${action}"
" the following ${item} items?",
mapping=mapping))
out.append(HTML.tag("br", _closed=False))
out.append(HTML.tag("ol", _closed=False))
for item in items:
out.append(HTML.tag("li", _closed=False))
out.append(escape(unicode(item)))
out.append(HTML.tag("/li", _closed=False))
out.append(HTML.tag("/ol", _closed=False))
out.append(_('Please press "${Action}" to ${action} the item.'
' Press "Cancel" to cancel the action.',
mapping=mapping))
return literal("").join(out)
def _render_body(self, items):
out = []
_ = self._request.translate
item_label = escape(get_item_modul(self._request,
self._item).get_label())
mapping = {'action': escape(_(self._action.capitalize()).lower()),
'item': item_label,
'Action': escape(_(self._action.capitalize()))}
out.append(_("Do you really want to ${action}"
" the following ${item} items?",
mapping=mapping))
out.append(HTML.tag("br", _closed=False))
out.append(HTML.tag("ol", _closed=False))
for item in items:
out.append(HTML.tag("li", _closed=False))
out.append(escape(unicode(item)))
out.append(HTML.tag("/li", _closed=False))
out.append(HTML.tag("/ol", _closed=False))
out.append(_('Please press "${Action}" to ${action} the item.'
' Press "Cancel" to cancel the action.',
mapping=mapping))
return literal("").join(out)
def auto_translate(string, default=None, mapping=None):
"""The translation function will iterate over the available
TranslationStringFactorys in the translators varibale and try to
translate the given string. TranslationsStrings will be iterated
in reversed order and iteration stops as soon as the
TranslationsString returns a string different from the given
string (msgid)"""
# An empty string leads to returning the header of the PO file.
# So if no string to translate is provided return an empty string.
if not string:
return string
if mapping is None:
mapping = {}
for _ in translators[::-1]:
ts = localizer.translate(_(string, default=default))
if ts != string:
break
translated = Template(ts).safe_substitute(mapping)
# If the origin string is a "literal" object (has __html__
# attribute, then return a literal again.
if hasattr(string, '__html__'):
return literal(translated)
return translated
def auto_translate(string, default=None, mapping=None):
"""The translation function will iterate over the available
TranslationStringFactorys in the translators varibale and try to
translate the given string. TranslationsStrings will be iterated
in reversed order and iteration stops as soon as the
TranslationsString returns a string different from the given
string (msgid)"""
# An empty string leads to returning the header of the PO file.
# So if no string to translate is provided return an empty string.
if not string:
return string
if mapping is None:
mapping = {}
for _ in translators[::-1]:
ts = localizer.translate(_(string,
default=default))
if ts != string:
break
translated = Template(ts).safe_substitute(mapping)
# If the origin string is a "literal" object (has __html__
# attribute, then return a literal again.
if hasattr(string, '__html__'):
return literal(translated)
return translated
def handle_POST_request(form, request, callback, event="", renderers=None):
"""@todo: Docstring for handle_POST_request.
:name: @todo
:request: @todo
:callback: @todo
:renderers: @todo
:event: Name of the event (update, create...) Used for the event handler
:returns: True or False
"""
_ = request.translate
clazz = request.context.__model__
item_label = get_item_modul(request, clazz).get_label()
item = get_item_from_request(request)
mapping = {"item_type": item_label, "item": item}
# Add a *special* validator to the form to trigger rendering a
# permanent info pane at the top of the form in case of errors on
# validation. This info has been added because users reported data
# loss because of formbar/ringo default behaviour of not saving
# anything in case of errors. Users seems to expect that the valid
# part of the data has been saved. This info should make the user
# aware of the fact that nothing has been saved in case of errors.
error_message = _(
"The information contained errors. "
"<strong>All entries (including error-free) were not "
"saved!</strong> Please correct your entries in the "
"fields marked in red and resave."
)
form.add_validator(Validator(None, literal(error_message), callback=form_has_errors, context=form))
# Begin a nested transaction. In case an error occours while saving
# the data the nested transaction will be rolled back. The parent
# session will be still ok.
request.db.begin_nested()
if form.validate(request.params) and "blobforms" not in request.params:
checker = ValueChecker()
try:
if event == "create":
try:
factory = clazz.get_item_factory(request)
except TypeError:
# Old version of get_item_factory method which does
# not take an request parameter.
factory = clazz.get_item_factory()
factory._request = request
checker.check(clazz, form.data, request)
item = factory.create(request.user, form.data)
item.save({}, request)
request.context.item = item
handle_add_relation(request, item)
else:
values = checker.check(clazz, form.data, request, item)
item.save(values, request)
handle_event(request, item, event)
handle_callback(request, callback)
handle_caching(request)
if event == "create":
msg = _("Created new ${item_type} successfully.", mapping=mapping)
log_msg = u"User {user.login} created {item_label} {item.id}".format(
item_label=item_label, item=item, user=request.user
)
else:
msg = _('Edited ${item_type} "${item}" successfully.', mapping=mapping)
log_msg = u"User {user.login} edited {item_label} {item.id}".format(
item_label=item_label, item=item, user=request.user
)
log.info(log_msg)
request.session.flash(msg, "success")
# Set next form page.
if request.params.get("_submit") == "nextpage":
table = clazz.__table__
itemid = item.id
page = get_next_form_page(form, get_current_form_page(clazz, request))
set_current_form_page(table, itemid, page, request)
# In case all is ok merge the nested session.
request.db.merge(item)
return True
except Exception as error:
request.db.rollback()
mapping["error"] = unicode(error.message)
if event == "create":
msg = _("Error while saving new " "${item_type}: ${error}.", mapping=mapping)
else:
msg = _("Error while saving " '${item_type} "${item}": ${error}.', mapping=mapping)
log.exception(msg)
request.session.flash(msg, "critical")
return False
elif "blobforms" in request.params:
pass
else:
request.db.rollback()
if event == "create":
msg = _("Error on validation new " "${item_type}.", mapping=mapping)
else:
msg = _("Error on validation " '${item_type} "${item}".', mapping=mapping)
log.debug(msg)
request.session.flash(msg, "error")
return False
def _render_label(self):
return literal("")
def bundle_(request):
clazz = request.context.__model__
module = get_item_modul(request, clazz)
handle_history(request)
handle_params(request)
_ = request.translate
# Handle bundle params. If the request has the bundle_action param
# the request is the intial request for a bundled action. In this
# case we can delete all previous selected and stored item ids in
# the session.
params = request.params.mixed()
if params.get('bundle_action'):
request.session['%s.bundle.action' % clazz] = params.get('bundle_action')
try:
del request.session['%s.bundle.items' % clazz]
except KeyError:
pass
request.session['%s.bundle.items' % clazz] = params.get('id', [])
bundle_action = request.session.get('%s.bundle.action' % clazz)
ids = request.session.get('%s.bundle.items' % clazz)
# Check if the user selected at least one item. If not show an
# dialog informing that the selection is empty.
if not ids:
title = _("Empty selection")
body = _("You have not selected any item in the list. "
"Click 'OK' to return to the overview.")
renderer = WarningDialogRenderer(request, title, body)
rvalue = {}
rvalue['dialog'] = literal(renderer.render(url=request.referrer))
return rvalue
# If the user only selects one single item it is not a list. So
# convert it to a list with one item.
if not isinstance(ids, list):
ids = [ids]
factory = clazz.get_item_factory()
items = []
ignored_items = []
for id in ids:
# Check if the user is allowed to call the requested action on
# the loaded item. If so append it the the bundle, if not ignore
# it.
item = factory.load(id)
if has_permission(bundle_action.lower(), item, request):
items.append(item)
else:
ignored_items.append(item)
# After checking the permissions the list of items might be empty.
# If so show a warning to the user to inform him that the selected
# action is not applicable.
if not items:
title = _("${action} not applicable",
mapping={"action": bundle_action})
body = _("After checking the permissions no items remain "
"for which an '${action}' can be performed. "
"(${num} items were filtered out.)",
mapping={"action": bundle_action,
"num": len(ignored_items)})
renderer = WarningDialogRenderer(request, title, body)
rvalue = {}
rvalue['dialog'] = literal(renderer.render(url=request.referrer))
return rvalue
handler = get_bundle_action_handler(_bundle_request_handlers,
bundle_action.lower(),
module.name)
return handler(request, items, None)
def _render_body(self):
# The output of the form render function of formbar is
# considered safe here as formbar already handles the escapeing.
# So we put it into the literal function to mark it save.
return literal(self.form.render(buttons=False))
def _render_label(self):
return literal("")
def bundle_(request):
clazz = request.context.__model__
module = get_item_modul(request, clazz)
_ = request.translate
# Handle bundle params. If the request has the bundle_action param
# the request is the intial request for a bundled action. In this
# case we can delete all previous selected and stored item ids in
# the session.
params = request.params.mixed()
if params.get('bundle_action'):
request.session['%s.bundle.action' %
clazz] = params.get('bundle_action')
try:
del request.session['%s.bundle.items' % clazz]
except KeyError:
pass
request.session['%s.bundle.items' % clazz] = params.get('id', [])
bundle_action = request.session.get('%s.bundle.action' % clazz)
ids = request.session.get('%s.bundle.items' % clazz)
# Check if the user selected at least one item. If not show an
# dialog informing that the selection is empty.
if not ids:
title = _("Empty selection")
body = _("You have not selected any item in the list. "
"Click 'OK' to return to the overview.")
renderer = WarningDialogRenderer(request, title, body)
rvalue = {}
rvalue['dialog'] = literal(renderer.render(url=request.referrer))
return rvalue
# If the user only selects one single item it is not a list. So
# convert it to a list with one item.
if not isinstance(ids, list):
ids = [ids]
factory = clazz.get_item_factory()
items = []
ignored_items = []
for id in ids:
# Check if the user is allowed to call the requested action on
# the loaded item. If so append it the the bundle, if not ignore
# it.
item = factory.load(id)
if has_permission(bundle_action.lower(), item, request):
items.append(item)
else:
ignored_items.append(item)
# After checking the permissions the list of items might be empty.
# If so show a warning to the user to inform him that the selected
# action is not applicable.
if not items:
title = _("${action} not applicable",
mapping={"action": bundle_action})
body = _(
"After checking the permissions no items remain "
"for which an '${action}' can be performed. "
"(${num} items were filtered out.)",
mapping={
"action": bundle_action,
"num": len(ignored_items)
})
renderer = WarningDialogRenderer(request, title, body)
rvalue = {}
rvalue['dialog'] = literal(renderer.render(url=request.referrer))
return rvalue
handler = get_bundle_action_handler(_bundle_request_handlers,
bundle_action.lower(), module.name)
return handler(request, items, None)
def _render_body(self):
out = []
out.append(self.form.render(buttons=False))
return literal("").join(out)
def handle_POST_request(form, request, callback, event="", renderers=None):
"""@todo: Docstring for handle_POST_request.
:name: @todo
:request: @todo
:callback: @todo
:renderers: @todo
:event: Name of the event (update, create...) Used for the event handler
:returns: True or False
"""
_ = request.translate
clazz = request.context.__model__
item_label = get_item_modul(request, clazz).get_label()
item = get_item_from_request(request)
mapping = {'item_type': item_label, 'item': item}
# Add a *special* validator to the form to trigger rendering a
# permanent info pane at the top of the form in case of errors on
# validation. This info has been added because users reported data
# loss because of formbar/ringo default behaviour of not saving
# anything in case of errors. Users seems to expect that the valid
# part of the data has been saved. This info should make the user
# aware of the fact that nothing has been saved in case of errors.
error_message = _("The information contained errors. "
"<strong>All entries (including error-free) were not "
"saved!</strong> Please correct your entries in the "
"fields marked in red and resave.")
form.add_validator(
Validator(None,
literal(error_message),
callback=form_has_errors,
context=form))
# Begin a nested transaction. In case an error occours while saving
# the data the nested transaction will be rolled back. The parent
# session will be still ok.
request.db.begin_nested()
if form.validate(request.params) and "blobforms" not in request.params:
checker = ValueChecker()
try:
# Handle new callback objects wich are configured to be
# called previous the origin action. Old simple callbacks
# are ignored.
handle_callback(request, callback, mode="pre")
if event == "create":
try:
factory = clazz.get_item_factory(request)
except TypeError:
# Old version of get_item_factory method which does
# not take an request parameter.
factory = clazz.get_item_factory()
factory._request = request
checker.check(clazz, form.data, request)
item = factory.create(request.user, form.data)
handle_add_relation(request, item)
item.save({}, request)
request.context.item = item
else:
values = checker.check(clazz, form.data, request, item)
item.save(values, request)
handle_event(request, item, event)
# Maintain old behaviour of callbacks. Callback are called
# post the origin action of the view. Therefor the callback
# must either be an instance of :class:Callback with mode
# "post" or it is a simple callable.
handle_callback(request, callback, mode="post,default")
handle_caching(request)
if event == "create":
msg = _('Created new ${item_type} successfully.',
mapping=mapping)
log_msg = u'User {user.login} created {item_label} {item.id}'\
.format(item_label=item_label,
item=item, user=request.user)
else:
msg = _('Edited ${item_type} "${item}" successfully.',
mapping=mapping)
log_msg = u'User {user.login} edited {item_label} {item.id}'\
.format(item_label=item_label,
item=item, user=request.user)
log.info(log_msg)
request.session.flash(msg, 'success')
# Set next form page.
if request.params.get("_submit") == "nextpage":
table = clazz.__table__
itemid = item.id
page = get_next_form_page(
form, get_current_form_page(clazz, request))
set_current_form_page(table, itemid, page, request)
# In case all is ok merge the nested session.
request.db.merge(item)
return True
except Exception as error:
request.db.rollback()
mapping['error'] = unicode(error.message)
if event == "create":
log_msg = _(u'User {user.login} created'
'{item_label}').format(item_label=item_label,
user=request.user)
msg = _('Error while saving new '
'${item_type}: ${error}.',
mapping=mapping)
else:
log_msg = _(u'User {user.login} edited '
'{item_label} {item.id}').format(
item_label=item_label,
item=item,
user=request.user)
msg = _(
'Error while saving '
'${item_type} "${item}": ${error}.',
mapping=mapping)
log.exception(log_msg)
request.session.flash(msg, 'critical')
return False
elif "blobforms" in request.params:
pass
else:
request.db.rollback()
if event == "create":
msg = _('Error on validation new '
'${item_type}.',
mapping=mapping)
else:
msg = _('Error on validation '
'${item_type} "${item}".',
mapping=mapping)
log.debug(msg)
request.session.flash(msg, 'error')
return False
def _render_body(self):
# The output of the form render function of formbar is
# considered safe here as formbar already handles the escapeing.
# So we put it into the literal function to mark it save.
return literal(self.form.render(buttons=False))
def nl2br(self, value=""):
return literal("<br />".join(cgi.escape(value).split("\n")))
