def get_path(self, publishable, language):
if not language:
language = get_language()
if language:
title = translations(publishable, language)
else:
title = None
if title:
title = self.title_splitter_regexp.sub(
self.word_separator,
title
)
title = title.lower()
ref = self.format % {
"title": title,
"id": publishable.id,
"separator": self.id_separator
}
else:
ref = str(publishable.id)
if self.include_file_extensions:
ext = self.get_publishable_file_extension(publishable)
if ext:
ref += ext
return ref
def visible_languages(self):
return get_parameter(schema.Collection("language",
items=schema.String(),
default=[get_language()]),
source=CookieParameterSource(
cookie_naming="visible_languages",
cookie_duration=self.settings_duration))
def translate_locale_component(locale, component, index, language=None):
if index == 1:
language = language or get_language()
location = first(
Location.select({
"location_type": "country",
"code": component
}))
if location is not None:
location_name = translations(location,
language=language,
discard_generic_translation=True)
if not location_name and language != "en":
location_name = translations(location,
"en",
discard_generic_translation=True)
return " - " + location_name
return base_translate_locale_component(locale,
component,
index,
language=language)
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 to_json_value(self, value, **options):
languages = options.get("languages", None)
if languages is None:
languages = get_language()
if value is None:
return None
record = {}
accessor = get_accessor(value)
for member in self.iter_members():
if member.translated and not isinstance(languages, str):
member_value = dict(
(lang,
member.to_json_value(accessor.get(value, language=lang),
**options))
for lang in accessor.languages(value, member.name))
else:
member_value = member.to_json_value(
accessor.get(value, member.name), **options)
record[member.name] = member_value
return record
def _add_language(self):
language = self.metadata.language or get_language()
if language:
self["lang"] = language
if rendering_xml():
self["xml:lang"] = language
self["dir"] = directionality.get(language)
def eval(self, context, accessor = None):
languages = self.languages
if languages is None:
languages = [get_language()]
subject_tokens = set()
stemming = self.stemming
if stemming is None:
stemming = getattr(self.subject, "stemming", False)
if stemming:
iter_tokens = words.iter_stems
else:
def iter_tokens(text, language = None):
text = words.normalize(text, locale = language)
return words.split(text, locale = language)
for language in languages:
with language_context(language):
lang_text = self.subject.eval(context, accessor)
if not lang_text:
continue
get_searchable_text = getattr(
lang_text, "get_searchable_text", None
)
if get_searchable_text is not None:
lang_text = get_searchable_text(languages = (language,))
subject_tokens.update(iter_tokens(lang_text, language))
for language in languages:
query_tokens = words.get_unique_stems(self.query, language)
if self.match_mode == "whole_word":
if self.logic == "and":
if subject_tokens.issuperset(query_tokens):
return True
elif not query_tokens.isdisjoint(subject_tokens):
return True
else:
if self.match_mode == "prefix":
query_tokens = [token + "*" for token in query_tokens]
operand = all if self.logic == "and" else any
if operand(
fnmatch.filter(subject_tokens, token)
for token in query_tokens
):
return True
return False
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 validate_publishable(self, publishable):
if not publishable.is_published():
raise cherrypy.NotFound()
user = get_current_user()
user.require_permission(ReadPermission, target=publishable)
user.require_permission(ReadTranslationPermission,
language=get_language())
def create_control(self, obj, member):
control = self.create_member_display(
obj, member, self.get_member_value(obj, member))
control.add_class("control")
if self.errors and self.errors.in_member(
member, member.translated and get_language() or None):
control.add_class("error")
return control
def _add_client_translations(self):
if self.metadata.client_translations:
self._add_core_scripts()
language = self.metadata.language or get_language()
self.client_setup_container.append(
"".join("\t\tcocktail.setTranslation(%s, %s);\n" %
(dumps(key), dumps(translations(key, language)))
for key in self.metadata.client_translations))
def _produce_content(self, **kwargs):
content = base_produce_content(self, **kwargs)
if app.x_staticpub_exporting and self.view:
tags = app.publishable.get_cache_tags(language=get_language())
if self.view:
tags.update(self.view.cache_tags)
cherrypy.response.headers["X-Woost-Cache-Tags"] = " ".join(tags)
return content
def impl(dataset):
per_lang_pub_index = Publishable.per_language_publication.index
# Exclude disabled items
enabled_subset = set(per_lang_pub_index.values(key=False))
enabled_subset.intersection_update(
Publishable.enabled.index.values(key=True))
language = get_language()
from woost.models import Configuration
if Configuration.instance.language_is_enabled(language):
enabled_for_current_language = set(
Publishable.per_language_publication.index.values(
key=True))
enabled_for_current_language.intersection_update(
Publishable.translation_enabled.index.values(key=(language,
True)))
enabled_subset.update(enabled_for_current_language)
dataset.intersection_update(enabled_subset)
# Exclude content by website:
if len(Configuration.instance.websites) > 1:
website = get_current_website()
per_website_index = Publishable.per_website_publication_index
# - content that can be published on any website
website_subset = set(per_website_index.values(key=None))
# - content that can be published on the active website
if website:
website_subset.update(
per_website_index.values(key=website.id))
dataset.intersection_update(website_subset)
# Remove items outside their publication window
now = datetime.now()
dataset.difference_update(
Publishable.start_date.index.values(
min=Publishable.start_date.get_index_value(now),
exclude_min=True))
dataset.difference_update(
Publishable.end_date.index.values(
min=None,
exclude_min=True,
max=Publishable.end_date.get_index_value(now),
exclude_max=True))
return dataset
def create_hidden_input(self, obj, member):
input = HiddenInput()
input.data = obj
input.member = member
input.data_display = self
input.value = self.get_member_value(obj, member)
if member.translated:
input.language = get_language()
return input
def initiate_payment(self, payment_id):
"""Begin a payment transaction, redirecting the user to the payment
gateway.
@param payment_id: The identifier of the payment to execute.
"""
url, params = self.get_payment_form_data(payment_id, get_language())
location = Location(url)
location.method = "POST"
location.form_data = OrderedDict(params)
location.go()
def google_cse_search(search_engine_id,
query,
page=0,
page_size=10,
language=None,
filter=True,
results_per_page=None):
"""Returns Google CSE results for the given query.
@param query: The query to search.
@type query: unicode
@param page: The ordinal index of the results page to return, starting
at 0.
@type page: int
@param page_size: The maximum number of results per page.
@type page_size: int
@param language: Restricts search results to matches for the given
language. The language must be indicated using a two letter ISO
language code.
@type language: str
@param filter: Indicates if Google should apply filtering over the
search results (ie. to remove redundant matches).
@type filter: bool
@return: The results for the given query.
@rtype: L{GoogleSearchResultsList}
"""
cse_url = URL_TEMPLATE % {
"search_engine_id": search_engine_id,
"query": quote_plus(query.encode("utf-8")),
"page": page * page_size,
"page_size": page_size,
"language": language or get_language(),
"filter": int(bool(filter))
}
f = urlopen(cse_url)
xml_response = f.read()
f.close()
results = []
parser = GoogleCSEXMLParser()
parseString(xml_response, parser)
return GoogleSearchResultsList(parser.results, page, page_size,
parser.result_count)
def _fill_head(self):
# Cache sorted columns
if self.order:
self._sorted_columns = sorted_columns = {}
for criteria in self.order:
sign = criteria.__class__
expr = criteria.operands[0]
if isinstance(expr, TranslationExpression):
member = expr.operands[0].name
language = expr.operands[1].value
else:
member = expr.name
language = None
sorted_columns[(member, language)] = sign
# Selection column
if (self.selection_mode != NO_SELECTION
and self.use_separate_selection_column):
selection_header = Element("th")
selection_header.add_class("selection")
self.head_row.append(selection_header)
# Column groups
if not self.grouped or not self.column_groups_displayed:
self.column_groups_row.visible = False
# Regular columns
if self.grouped:
self.columns_by_group = list(self.displayed_members_by_group)
else:
self.columns_by_group = [(None, list(self.displayed_members))]
for group, columns in self.columns_by_group:
if self.grouped and self.column_groups_displayed:
self.column_groups_row.append(
self.create_column_group_header(group, columns))
for column in columns:
if column.translated:
for language in self.translations or (get_language(), ):
header = self.create_header(column, language)
self.head_row.append(header)
else:
header = self.create_header(column)
self.head_row.append(header)
def session(self):
session = WebConsoleController.session(self)
session.context.update(config=Configuration.instance,
user=get_current_user(),
language=get_language(),
translations=translations,
first=first,
last=last)
for model in PersistentObject.schema_tree():
session.context[model.name] = model
return session
def _ready(self):
Element._ready(self)
params = self.aggregate_tinymce_params()
if self.language:
params.setdefault(
"directionality",
directionality.get(self.language)
)
# Override essential TinyMCE parameters
params["mode"] = "exact"
params["language"] = get_language()
params["elements"] = self.textarea.require_id()
self.set_client_param("tinymceSettings", params);
def get_analytics_values(self, publishable):
return {
# Custom dimension: language
"dimension1":
get_language() or "",
# Custom dimension: roles
"dimension2":
self.serialize_collection(
role.id for role in get_current_user().iter_roles()),
# Custom dimension: path
"dimension3":
"" if publishable is None else self.serialize_collection(
ancestor.id
for ancestor in reversed(list(publishable.ascend_tree(True))))
}
def _export(self, context, status_tracker=None):
StaticSiteDestination._export(self,
context,
status_tracker=status_tracker)
# Close the zip file before export it to the CMS
context["zip_file"].close()
upload_path = app.path("upload")
with changeset_context(get_current_user()):
file = File.from_path(context["temp_file"],
upload_path,
languages=[get_language()])
file.title = "export-%s" % date.today().strftime("%Y%m%d")
file.file_name = file.title + ".zip"
file.insert()
context.update(file=file)
def get_content_tags(self, publishable, base = None, **context):
tags = publishable.get_cache_tags(
language = context.get("language") or get_language()
)
tags.add(self.main_cache_tag)
if base:
tags.update(base)
expression = self.cache_tags_expression
if expression:
context["tags"] = tags
exec expression in context
tags = context.get("tags")
return tags
def __init__(self,
query_text,
languages,
emphasis="*%s*",
context_radius=None,
ellipsis=None,
match_mode="whole_word",
stemming=None):
self.match_mode = match_mode
if isinstance(emphasis, str):
self.__emphasize = lambda text: emphasis % text
elif callable(emphasis):
self.__emphasize = emphasis
else:
raise TypeError(
"SearchHighlighter constructor received an invalid value for "
"its 'emphasis' parameter: expected a formatting string or a "
"callable with a single parameter, got %r instead." % emphasis)
if languages is None:
self.__languages = (None, get_language())
else:
self.__languages = languages
if stemming is not None:
self.stemming = stemming
self.__query_terms = set()
for language in self.__languages:
terms = self._iter_terms(
query_text,
language,
preserve_patterns=(match_mode == "pattern"))
if match_mode == "prefix":
terms = [term + "*" for term in terms]
self.__query_terms.update(terms)
if context_radius is not None:
self.context_radius = context_radius
if ellipsis is not None:
self.ellipsis = ellipsis
def post_redirection(destination, data):
"""Redirect the client to the given URL using a POST request."""
with language_context(get_language() or "en"):
trans_prefix = "cocktail.controllers.redirection.post_redirection."
title = translations(trans_prefix + "title")
submit_label = translations(trans_prefix + "submit_button")
explanation = translations(trans_prefix + "explanation")
form_content = "\n".join("""<input type="hidden" name="%s" value="%s">""" %
(key, value) for key, value in data.items())
cherrypy.response.status = 200
cherrypy.response.body = ("""
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8">
<title>%(title)s</title>
<script type="text/javascript">
<!--
onload = function () {
document.getElementById("redirectionForm").submit();
}
//-->
</script>
</head>
<body>
<form id="redirectionForm" method="POST" action="%(action)s">
%(form_content)s
<noscript>
<p>%(explanation)s</p>
<input type="submit" value="%(submit_label)s">
</noscript>
</form>
</body>
</html>
""" % {
"title": title,
"action": destination,
"form_content": form_content,
"explanation": explanation,
"submit_label": submit_label
})
raise StopRequest()
def _get_publication_parameters(self, publishable):
og = OpenGraphExtension.instance
og_properties = og.get_properties(publishable)
post_data = {
"access_token": self.auth_token,
"name": og_properties.get("og:title") or translations(publishable),
"link": og_properties.get("og:url")
}
# Disregard any default image; only show an image if the published
# content defines one
if "og:image" not in og_properties:
post_data["picture"] = ""
if self.targeting:
context = {
"language":
get_language(),
"og_properties":
og_properties,
"publishable":
publishable,
"locales":
facebook_locales,
"include_locales":
(lambda included:
[facebook_locales[loc_name] for loc_name in included]),
"exclude_locales": (lambda excluded: [
loc_id
for loc_name, loc_id in facebook_locales.iteritems()
if loc_name not in excluded
])
}
targeting_code = self.targeting.replace("\r\n", "\n")
exec targeting_code in context
targeting = context.get("targeting")
if targeting:
post_data["feed_targeting"] = dumps(targeting)
return post_data
def _ready(self):
if self.items is None:
config = Configuration.instance
user = get_current_user()
self.items = [
language for language in
(config.get_setting("published_languages") or config.languages)
if user.has_permission(ReadTranslationPermission,
language=language)
]
if self.value is None:
self.value = get_language()
if not self.autohide or len(self.items) > 1:
LinkSelector._ready(self)
# Hack for IE <= 6
if self.children:
self.children[-1].add_class("last")
def _add_core_scripts(self):
if not self.__core_scripts_added:
self.__core_scripts_added = True
for uri in reversed(self.get_core_scripts()):
self.metadata.resources.insert(0, uri)
language = self.metadata.language or get_language()
self.client_setup.append("\t\tcocktail.setLanguage(%s);\n" %
dumps(language))
init_code = "cocktail.init();"
if self.root_element_id:
init_code = (
"cocktail.rootElement = document.getElementById(%s); " %
dumps(self.root_element_id)) + init_code
self.client_setup.append("\t\tjQuery(function () { %s });\n" %
init_code)
def create_field(self, member):
hidden = self.get_member_hidden(member)
entry = Element("tr" if self.table_layout else "div")
entry.field_instances = []
if hidden:
entry.tag = None
else:
entry.add_class("field")
entry.add_class(member.name + "_field")
if member.required:
entry.add_class("required")
def create_instance(language=None):
if hidden:
with language_context(language):
return self.create_hidden_input(self.data, member)
else:
instance = self.create_field_instance(member, language)
entry.field_instances.append(instance)
return instance
if member.translated:
entry.add_class("translated")
if not hidden and not self.redundant_translation_labels:
entry.append(self.create_label(member))
for language in (self.translations if self.translations is not None
else (get_language(), )):
field_instance = create_instance(language)
field_instance.add_class(language)
entry.append(field_instance)
else:
entry.append(create_instance())
return entry
def translate_uri(self, path=None, language=None):
current_language = get_language()
if language is None:
language = current_language
if path is None:
is_current_publishable = True
path = cherrypy.request.path_info
qs = cherrypy.request.query_string
else:
is_current_publishable = False
qs = u""
if isinstance(path, str):
path = try_decode(path)
if isinstance(qs, str):
qs = try_decode(qs)
if is_current_publishable and language != current_language:
publishable = context.get("original_publishable") \
or context["publishable"]
current_uri = publishable.get_uri(language=current_language,
encode=False)
translation_uri = publishable.get_uri(language=language)
path = path.replace(current_uri, translation_uri)
else:
path_components = path.strip("/").split("/")
if (path_components and path_components[0]
in Configuration.instance.languages):
path_components.pop(0)
path_components.insert(0, self.language_to_uri_component(language))
path = u"/" + u"/".join(path_components)
return path + (u"?" + qs if qs else u"")
def create_translated_values(self, member):
cell = Element("td")
table = Element("table")
table.add_class("translated_values")
cell.append(table)
for language in (self.translations or (get_language(), )):
language_row = Element("tr")
language_row.add_class(language)
table.append(language_row)
language_label = Element("th")
language_label.append(translations(language))
language_row.append(language_label)
with language_context(language):
language_value_cell = self.create_value(member)
language_row.append(language_value_cell)
return cell
