def _normalize_member_display(self, obj, member, value, display,
**context):
if isinstance(display, type) and issubclass(display, Element):
display = display()
elif callable(display):
method_subject = getattr(display, "im_self", None)
if method_subject is self:
display = display(obj, member, value, **context)
else:
display = display(self, obj, member, value, **context)
if isinstance(display, str):
display = templates.new(display)
if display is not None:
if not display.is_valid_display(self, obj, member, value, **
context):
return None
display.ui_generator = self
display.data = obj
display.member = member
display.language = get_language()
display.value = value
for key, value in context.items():
setattr(display, key, value)
return display
def create_element_display(self, item, member):
display = templates.new("woost.views.ItemLabel")
display.tag = "label"
display["for"] = "selection_" + str(item.id)
display.item = item
display.referer = self.referer
return display
def render(self, info, format="html", fragment=False, template=None):
"Renders the template to a string using the provided info."
if isinstance(template, str):
element = templates.new(template)
else:
element = template()
if self.extra_vars_func:
for key, value in self.extra_vars_func().items():
setattr(element, key, value)
for key, value in info.items():
setattr(element, key, value)
renderer = None
if format:
if format == "html":
format = "default"
try:
renderer = getattr(renderers, "%s_renderer" % format)
except AttributeError:
raise ValueError("Can't render '%s' using format '%s'" %
(template, format))
if fragment:
html = element.render(renderer=renderer)
else:
html = element.render_page(renderer=renderer)
element.dispose()
return html
def _default_code_block_edit_control(ui_generator, obj, member, value,
**context):
display = templates.new("cocktail.html.CodeEditor")
display.syntax = member.language
if member.language == "python":
display.cols = 80
return display
def display_item_reference(self, obj, member):
display = templates.new("woost.views.ContentLink")
display.item = self.get_member_value(obj, member)
display.base_url = self.base_url
display.referer = obj
display.member = member
return display
def _build(self):
self.add_resource("cocktail://scripts/tinymce/js/tinymce/tinymce.min.js")
self.add_client_code("tinymce.init(this.tinymceSettings);")
self.textarea = templates.new("cocktail.html.TextArea")
self.data_binding_delegate = self.textarea
self.append(self.textarea)
self.data_binding_delegate = self.textarea
def display_item_collection(self, obj, member):
display = templates.new("woost.views.ContentList")
display.items = self.get_member_value(obj, member)
display.base_url = self.base_url
display.referer = obj
display.member = member
return display
def _get_reference_display(self, obj, member):
if member.class_family is not None:
display = templates.new("woost.views.ContentTypePickerDropdown")
display.content_type_picker.root = member.class_family
else:
display = "woost.views.ItemSelector"
return display
def embeded_form(ui_generator, obj, member, value, **context):
form = templates.new("cocktail.html.Form")
form.tag = "div"
form.embeded = True
form.schema = member
form.name_prefix = getattr(ui_generator, "name_prefix", None)
form.name_suffix = getattr(ui_generator, "name_suffix", None)
return form
def _ready(self):
Element._ready(self)
options = self.recaptcha_options.copy()
language = get_language()
options["lang"] = language
if language == "ca":
options["lang"] = "es"
options["custom_translations"] = {
"instructions_visual": "Escriu les 2 paraules:",
"instructions_audio": "Escriu el que sentis:",
"play_again": "Tornar a escoltar",
"cant_hear_this": "Descarregar so en MP3",
"visual_challenge": "Obtindre un repte visual",
"audio_challenge": "Obtindre un repte audible",
"refresh_btn": "Obtindre un nou repte",
"help_btn": "Ajuda",
"incorrect_try_again": "Incorrecte. Torna a provar-ho."
}
elif language not in ("en", "nl", "fr", "de", "pt", "ru", "es", "tr"):
options["lang"] = "en"
if ReCaptchaExtension.instance.theme == "custom":
options.setdefault(
"custom_theme_widget",
ReCaptchaExtension.instance.custom_theme_widget
)
options.setdefault("theme", ReCaptchaExtension.instance.theme)
init_options = Element("script")
init_options["type"] = "text/javascript"
init_options.append("var RecaptchaOptions = %s;" % dumps(options))
init_script = Element()
init_script.append("""<script type="text/javascript" src="%(api_server)s/challenge?k=%(public_key)s%(error_param)s"></script>
<noscript>
<iframe src="%(api_server)s/noscript?k=%(public_key)s%(error_param)s" style="height: 300px; width: 500px; border: 0;" ></iframe><br />
<textarea name="recaptcha_challenge_field" rows="3" cols="40"></textarea>
<input type='hidden' name='recaptcha_response_field' value='manual_challenge' />
</noscript>
""" % self.recaptcha_params)
self.append(init_options)
if ReCaptchaExtension.instance.theme == "custom":
custom_container = templates.new(
ReCaptchaExtension.instance.custom_template
)
custom_container.widgetid = ReCaptchaExtension.instance.custom_theme_widget
self.append(custom_container.render())
self.append(init_script)
def _build(self):
Element._build(self)
data_bound(self)
self.add_resource("/resources/scripts/ItemSelector.js")
self.set_client_param("emptyLabel", self.empty_label)
self.input = templates.new("cocktail.html.HiddenInput")
self.append(self.input)
self.binding_delegate = self.input
self.selection_label = templates.new("woost.views.ItemLabel")
self.selection_label.tag = "span"
self.selection_label.add_class("selection_label")
self.append(self.selection_label)
self.buttons = self.create_buttons()
self.append(self.buttons)
def func(ui_generation, obj, member, value, **context):
display = templates.new(display_name)
for k, v in kwargs.items():
if hasattr(display, k):
setattr(display, k, v)
else:
display[k] = v
return display
def render(self, **values):
"""Renders the document using its template."""
if self.template is None:
raise ValueError("Can't render a document without a template")
values["publishable"] = self
view = templates.new(self.template.identifier)
for key, value in values.iteritems():
setattr(view, key, value)
return view.render_page()
def create_entry_content(self, item):
link = templates.new("woost.views.ContentLink")
link.icon_visible = True
link.item = item
link.referer = self.referer
link.member = self.member
if self.referer and self.member:
link["data-woost-relativedrop"] = "%d.%s.%d" % (
self.referer.id, self.member.name, item.id)
return link
def view(self):
if self.view_class:
view = templates.new(self.view_class)
cms = self.context["cms"]
output = self.output
cms.producing_output(controller=self, output=output)
for key, value in output.iteritems():
setattr(view, key, value)
view.submitted = self.submitted
view.successful = self.successful
return view
def __call__(self, *args, **kwargs):
node = self.stack_node
previewed_item = self.previewed_item
publishable = self.preview_publishable
preview_language = self.preview_language
user = get_current_user()
# Set the language for the preview
if preview_language:
set_language(preview_language)
# Enforce permissions
user.require_permission(ReadPermission, target=previewed_item)
if publishable is not previewed_item:
user.require_permission(ReadPermission, target=publishable)
# Disable the preview if the item's unsaved state produces validation
# errors; these would usually lead to unhandled server errors during
# rendering.
errors = schema.ErrorList(node.iter_errors())
if errors:
error_box = templates.new("cocktail.html.ErrorBox")
error_box.errors = errors
message = Element("div",
class_name="preview-error-box",
children=[
translations(
"woost.backoffice invalid item preview",
preview_language), error_box
])
message.add_resource("/resources/styles/backoffice.css")
return message.render_page()
# Update the edited item with the data to preview
node.import_form_data(node.form_data, previewed_item)
self.context.update(original_publishable=self.context["publishable"],
publishable=publishable)
controller = publishable.resolve_controller()
if controller is None:
raise cherrypy.NotFound()
if isinstance(controller, type):
controller = controller()
return controller()
def create_new_button(self):
new_button = Element(class_name="ItemSelector-button new")
instantiable_types = set(
content_type
for content_type in ([self.member.type] +
list(self.member.type.derived_schemas()))
if content_type.visible and content_type.instantiable
and get_current_user().has_permission(CreatePermission,
target=content_type))
if len(instantiable_types) > 1:
new_button.add_class("selector")
label = Element("span", class_name="label")
new_button.append(label)
container = Element(class_name="selector_content")
new_button.append(container)
content_type_tree = templates.new("woost.views.ContentTypeTree")
content_type_tree.root = self.member.type
content_type_tree.filter_item = instantiable_types.__contains__
@extend(content_type_tree)
def create_label(tree, content_type):
label = call_base(content_type)
label.tag = "button"
label["type"] = "submit"
label["name"] = "relation-new"
label[
"value"] = self.member.name + "-" + content_type.full_name
return label
container.append(content_type_tree)
else:
new_button.tag = "button"
new_button["type"] = "submit"
new_button["name"] = "relation-new"
new_button["value"] = \
self.member.name + "-" + list(instantiable_types)[0].full_name
label = new_button
label.append(translations("woost.views.ItemSelector new"))
return new_button
def create_view(self):
if self.view_class is None:
raise ValueError("No view specified for block %s" % self)
view = templates.new(self.view_class)
self.init_view(view)
if self.controller:
controller_class = import_object(self.controller)
controller = controller_class()
controller.block = self
controller.view = view
controller()
for key, value in controller.output.iteritems():
setattr(view, key, value)
return view
def _normalize_view(self, value, item, **parameters):
if isinstance(value, basestring):
view = templates.new(value)
view.item = item
elif isinstance(value, ViewFactory):
view = value.create_view(item, **parameters)
elif isinstance(value, type):
view = value()
view.item = item
elif callable(value):
view = value(item, parameters)
# Set any remaining parameters as attributes of the resulting view
if view:
for key, value in parameters.iteritems():
setattr(view, key, value)
return view
def create_player(self, video):
player = templates.new(video.video_player)
player_initialization = self.player_initialization.get(video.__class__)
if player_initialization:
player_initialization(player, self, video)
return player
def issuu_viewer(item, parameters):
viewer = templates.new("cocktail.html.IssuuViewer")
viewer.config_id = item.issuu_config_id
viewer.page_number = item.thumbnail_page
return viewer
def create_label(self, item):
label = templates.new("woost.views.ContentLink")
label.base_url = self.base_url
label.item = item
label.edit_stack = self.edit_stack
return label
def video_player_dialog(item, parameters):
if item.resource_type == "video":
view = templates.new("woost.views.PublishablePopUp")
view.item = item
view.view_factory = publishable_view_factory
return view
def image_gallery(item, parameters):
if item.resource_type == "image":
view = templates.new("woost.views.ImageGallery")
view.images = [item]
view.labels_visible = False
return view
def _destination_edit_control(parent, obj, member):
display = templates.new("cocktail.html.DropdownSelector")
display.empty_label = translations(
"woost.extensions.staticsite any destination"
)
return display
def create_pager(self):
pager = templates.new("cocktail.html.Pager")
return pager
except Exception, ex:
errors.append(ex)
if not isinstance(ex, InstallFolderExists):
traceback.print_tb(sys.exc_info()[2])
try:
rmtree(form_data["project_path"])
except Exception, rmex:
tb = sys.exc_info()[2]
traceback.print_tb(sys.exc_info()[2])
errors.append(rmex)
else:
successful = True
else:
form_schema.init_instance(form_data)
view = templates.new("woost.views.Installer")
view.submitted = submitted
view.successful = successful
view.schema = form_schema
view.data = form_data
view.errors = errors
return view.render_page()
def install(self, params):
params["project_module"] = params["project_name"].lower()
self.create_project(params)
self._init_project(params)
def create_project(self, params):
