def getLanguage(self, langs, env):
envadapter = IUserPreferredLanguages(env)
userlangs = envadapter.getPreferredLanguages()
# Always add the template language to the available ones. This allows the
# template language to be picked without the need for a message catalog
# for every domain for it to be registered.
langs = tuple(langs) + TEMPLATE_LANGUAGE
global _cache, _bcache
l_cache = _cache
b_cache = _bcache
notnormalized = [l for l in langs if l not in b_cache]
if notnormalized:
l_cache.update(normalize_langs(notnormalized))
b_cache.update(dict((v, k) for k, v in l_cache.items()))
# Prioritize on the user preferred languages. Return the
# first user preferred language that the object has available.
#langs = normalize_langs(langs)
for lang in userlangs:
if lang in l_cache:
return l_cache[lang]
# If the user asked for a specific variation, but we don't
# have it available we may serve the most generic one,
# according to the spec (eg: user asks for ('en-us',
# 'de'), but we don't have 'en-us', then 'en' is preferred
# to 'de').
parts = lang.split('-')
if len(parts) > 1 and parts[0] in l_cache:
return l_cache.get(parts[0])
return None
def get_homepage_html(self):
adapter = IUserPreferredLanguages(self.request)
language = adapter.getPreferredLanguages()[0]
if language == 'en':
return self.context['admin'].english_home_html
else:
return self.context['admin'].dutch_home_html
def adjust_request_interface_for_preferred_languages(event):
"""
Checks the conditions outlined in this package's documentation and
adds a marker interface (:class:`.IPreferredLanguagesRequest`) to
the request if they hold true.
This is registered as a subscriber for Pyramid's
:class:`.IContextFound` event by this package's ``configure.zcml``
"""
request = event.request
# Does pyramid's default negotiator, which uses explicit settings
# like a request param or cookie have an answer? If so, we need
# our custom policy...these override the Accept-Language header
if default_locale_negotiator(request):
interface.alsoProvides(request, IPreferredLanguagesRequest)
return
# What about the zope/plone cookie?
if request.cookies.get('I18N_LANGUAGE'):
# For benefit of the default localization machinery
# in case it's used, copy
request._LOCALE_ = request.cookies.get('I18N_LANGUAGE')
interface.alsoProvides(request, IPreferredLanguagesRequest)
return
# Ok, is there an authenticated user with preferred languages?
# (We leave detecting defaults up to the actual policy)
remote_user = IPrincipal(request, None)
if remote_user and not IUnauthenticatedPrincipal.providedBy(remote_user):
remote_user_langs = IUserPreferredLanguages(remote_user)
if remote_user_langs and remote_user_langs.getPreferredLanguages(): # pylint:disable=too-many-function-args
interface.alsoProvides(request, IPreferredLanguagesRequest)
def getPreferredLanguages(self):
# If the default locale negotiater can get a value,
# that means we had a parameter or one of the cookies
# (because of the subscriber that gets us here).
negotiated = default_locale_negotiator(self.request)
if negotiated:
return [negotiated]
# Here is where we would check for something during traversal,
# but we don't actually support that at this time because it
# relies on implementation details
# Is there a non-default user preference? Right now we know
# what a default is due to implementation details above. We also
# know for sure that we *have* a remote use, otherwise we wouldn't
# be here
remote_user = IPrincipal(self.request, None)
remote_user_langs = IUserPreferredLanguages(remote_user)
if remote_user_langs is not EnglishUserPreferredLanguagesImpl:
return remote_user_langs.getPreferredLanguages() # pylint:disable=too-many-function-args
# Ok, see what the HTTP request can come up with. Note that we're
# going to the Zope interface so that we don't get into an infinite
# loop
browser_request = IBrowserRequest(self.request)
browser_langs = IModifiableUserPreferredLanguages(browser_request)
return browser_langs.getPreferredLanguages() # pylint:disable=too-many-function-args
def preferred_language_locale_negotiator(request):
"""
A pyramid locale negotiator that piggybacks off
the preferred language support. We return a valid locale
name consisting of at most language-territory, but at least language.
A valid locale is one for which we have available locale data,
not necessarily one for which any translation data is available.
"""
# pylint:disable=too-many-function-args, assignment-from-no-return
# This code is similar to that in zope.publisher.http.HTTPRequest.
# it's point is to find the most specific available locale possible.
# We differ in that, instead of returning a generic default, we
# specifically return the english default. We also differ in that we
# return a locale name instead of a locale object.
result = EnglishUserPreferredLanguagesImpl.PREFERRED_LANGUAGES[0]
pref_langs = IUserPreferredLanguages(request, ())
if pref_langs:
pref_langs = pref_langs.getPreferredLanguages()
for lang in pref_langs:
parts = (lang.split('-') + [None, None])[:3]
try:
locales.getLocale(*parts)
result = lang
break
except LoadLocaleError: # pragma: no cover
continue
return result
def __call__(self, objectId, instance, *args, **kw):
lang = IUserPreferredLanguages(instance.request, None)
if lang is not None:
lang = lang.getPreferredLanguages()
if lang:
return {'request:%s'%self.name: lang[0]}
return ()
def __init__(self, request):
self._send = getUtility(IMessageService).send
self.request = request
adapter = IUserPreferredLanguages(self.request)
languages = adapter.getPreferredLanguages()
if languages:
self._language = languages[0]
else:
self._language = 'en'
def today(self):
today = datetime.date.today()
adapter = IUserPreferredLanguages(self.request)
lang = adapter.getPreferredLanguages()[0]
if lang == 'en':
month = months[today.month - 1]
return '%s %s' % (month, today.day)
else:
month = maanden[today.month - 1]
return '%s %s' % (today.day, month)
def getLanguage(self):
"""
"""
languages = IUserPreferredLanguages(self.context.REQUEST)
langs = languages.getPreferredLanguages()
if langs:
language = langs[0]
else:
plone_props = getToolByName(self.context, 'portal_properties')
language = plone_props.site_properties.default_language
language = language.split('-')
return language[0]
def hour_time_formatter(self, timeobj):
"""uses zope.i18n.locales to determine hour/min format
"""
#grab locale from request
languages = IUserPreferredLanguages(self.request)
langs = languages.getPreferredLanguages()
if langs:
parts = (langs[0].split('-') + [None,None])[:3]
else:
parts = (None,None,None)
locale = locales.getLocale(*parts)
#create formatted hour minute string
formatter = locale.dates.getFormatter('time', 'short')
return formatter.format(timeobj)
def hour_time_formatter(self, timeobj):
"""uses zope.i18n.locales to determine hour/min format
"""
#grab locale from request
languages = IUserPreferredLanguages(self.request)
langs = languages.getPreferredLanguages()
if langs:
parts = (langs[0].split('-') + [None, None])[:3]
else:
parts = (None, None, None)
locale = locales.getLocale(*parts)
#create formatted hour minute string
formatter = locale.dates.getFormatter('time', 'short')
return formatter.format(timeobj)
def getPreferredLanguages(self):
"""See the IRequestPreferredLanguages interface"""
codes = IUserPreferredLanguages(self.request).getPreferredLanguages()
languageset = getUtility(ILanguageSet)
languages = set()
for code in codes:
# We need to ensure that the code received contains only ASCII
# characters otherwise SQLObject will crash if it receives a query
# with non printable ASCII characters.
if isinstance(code, str):
try:
code = code.decode('ASCII')
except UnicodeDecodeError:
# skip language codes that can't be represented in ASCII
continue
else:
try:
code = code.encode('ASCII')
except UnicodeEncodeError:
# skip language codes that can't be represented in ASCII
continue
code = languageset.canonicalise_language_code(code)
try:
languages.add(languageset[code])
except KeyError:
pass
languages = [language for language in languages if language.visible]
return sorted(languages, key=lambda x: x.englishname)
def negotiate(request):
"""Monkey patch zope.i18n.negotiate not to rely on environment
variable, and to cache its computation.
"""
if IRequest.providedBy(request):
if 'I18N_LANGUAGE' in request.other:
return request.other['I18N_LANGUAGE']
adapter = IUserPreferredLanguages(request)
languages = adapter.getPreferredLanguages()
if languages:
language = languages[0]
else:
language = 'en'
request.other['I18N_LANGUAGE'] = language
return language
return None
def getLocale(request):
envadapter = IUserPreferredLanguages(request, None)
if envadapter is None:
return None
langs = envadapter.getPreferredLanguages()
for httplang in langs:
parts = (httplang.split('-') + [None, None])[:3]
try:
return locales.getLocale(*parts)
except LoadLocaleError:
# Just try the next combination
pass
else:
# No combination gave us an existing locale, so use the default,
# which is guaranteed to exist
return locales.getLocale(None, None, None)
def _getLocale(request):
envadapter = IUserPreferredLanguages(request, None)
if envadapter is None:
return None
langs = envadapter.getPreferredLanguages()
for httplang in langs:
parts = (httplang.split('-') + [None, None])[:3]
try:
return locales.getLocale(*parts)
except LoadLocaleError:
# Just try the next combination
pass
else:
# No combination gave us an existing locale, so use the default,
# which is guaranteed to exist
return locales.getLocale(None, None, None)
def browser_language(self):
language = 'en'
pl = IUserPreferredLanguages(self.request)
if pl is not None:
languages = pl.getPreferredLanguages()
for httplang in languages:
parts = (httplang.split('-') + [None, None])[:3]
if parts[0] == parts[1]:
# Avoid creating a country code for simple languages codes
parts = [parts[0], None, None]
try:
locale = locales.getLocale(*parts)
language = locale.getLocaleID().replace('_', '-').lower()
break
except LoadLocaleError:
# Just try the next combination
pass
return language
def getLanguage(self, langs, env):
envadapter = IUserPreferredLanguages(env)
userlangs = envadapter.getPreferredLanguages()
# Prioritize on the user preferred languages. Return the
# first user preferred language that the object has available.
langs = normalize_langs(langs)
for lang in userlangs:
if lang in langs:
return langs.get(lang)
# If the user asked for a specific variation, but we don't
# have it available we may serve the most generic one,
# according to the spec (eg: user asks for ('en-us',
# 'de'), but we don't have 'en-us', then 'en' is preferred
# to 'de').
parts = lang.split('-')
if len(parts) > 1 and parts[0] in langs:
return langs.get(parts[0])
return None
def normalize(self, text):
"""Returns a normalized Unicode string."""
locale = None
langs = IUserPreferredLanguages(self.context).getPreferredLanguages()
if langs:
locale = langs[0]
util = queryUtility(IURLNormalizer)
return util.normalize(text, locale=locale)
def getLanguage(self, langs, env):
envadapter = IUserPreferredLanguages(env)
userlangs = envadapter.getPreferredLanguages()
# Prioritize on the user preferred languages. Return the
# first user preferred language that the object has available.
langs = normalize_langs(langs)
for lang in userlangs:
if lang in langs:
return langs.get(lang)
# If the user asked for a specific variation, but we don't
# have it available we may serve the most generic one,
# according to the spec (eg: user asks for ('en-us',
# 'de'), but we don't have 'en-us', then 'en' is preferred
# to 'de').
parts = lang.split('-')
if len(parts) > 1 and parts[0] in langs:
return langs.get(parts[0])
return None
def browser_language(self):
language = 'en'
pl = IUserPreferredLanguages(self.request)
if pl is not None:
languages = pl.getPreferredLanguages()
for httplang in languages:
parts = (httplang.split('-') + [None, None])[:3]
if parts[0] == parts[1]:
# Avoid creating a country code for simple languages codes
parts = [parts[0], None, None]
try:
locale = locales.getLocale(*parts)
language = locale.getLocaleID().replace('_', '-').lower()
break
except LoadLocaleError:
# Just try the next combination
pass
return language
def getLanguage(self):
"""
Ogone requires en_EN or en_US language id
We are parsing the request to get the right
Note: took this code from getpaid.ogone (thanks)
"""
languages = IUserPreferredLanguages(self.context.REQUEST)
langs = languages.getPreferredLanguages()
if langs:
language = langs[0]
else:
plone_props = getToolByName(self.context, 'portal_properties')
language = plone_props.site_properties.default_language
language = language.split('-')
if len(language) == 1:
language.append(language[0])
language = language[:2]
return "_".join(language)
def menu_items(self):
items = [
(self.application_url(), _('home')),
(self.application_url('zoek'), _('zoeken')),
(self.application_url('personen') + '?beginletter=a', _('bladeren')),
(self.application_url('about'), _('project')),
]
adapter = IUserPreferredLanguages(self.request)
lang = adapter.getPreferredLanguages()[0]
if lang != 'en':
items += [(self.application_url('blog'), _('blog')),
(self.application_url('agenda'), _('agenda')), ]
items += [
(self.application_url('links'), _('links')),
(self.application_url('faq'), _('vragen')),
(self.application_url('contact'), _('contact')),
]
return items
def setupLocale(self):
envadapter = IUserPreferredLanguages(self, None)
if envadapter is None:
self._locale = None
return
langs = envadapter.getPreferredLanguages()
for httplang in langs:
parts = (httplang.split("-") + [None, None])[:3]
try:
self._locale = locales.getLocale(*parts)
return
except LoadLocaleError:
# Just try the next combination
pass
else:
# No combination gave us an existing locale, so use the default,
# which is guaranteed to exist
self._locale = locales.getLocale(None, None, None)
def getLanguage(self, langs, env):
envadapter = IUserPreferredLanguages(env)
userlangs = envadapter.getPreferredLanguages()
# Always add the template language to the available ones. This allows the
# template language to be picked without the need for a message catalog
# for every domain for it to be registered.
langs = list(langs) + TEMPLATE_LANGUAGE
# Prioritize on the user preferred languages. Return the
# first user preferred language that the object has available.
langs = normalize_langs(langs)
for lang in userlangs:
if lang in langs:
return langs.get(lang)
# If the user asked for a specific variation, but we don't
# have it available we may serve the most generic one,
# according to the spec (eg: user asks for ('en-us',
# 'de'), but we don't have 'en-us', then 'en' is preferred
# to 'de').
parts = lang.split('-')
if len(parts) > 1 and parts[0] in langs:
return langs.get(parts[0])
return None
def getLanguage(self, langs, env):
envadapter = IUserPreferredLanguages(env)
userlangs = envadapter.getPreferredLanguages()
# Always add the template language to the available ones. This allows the
# template language to be picked without the need for a message catalog
# for every domain for it to be registered.
langs = list(langs) + TEMPLATE_LANGUAGE
# Prioritize on the user preferred languages. Return the
# first user preferred language that the object has available.
langs = normalize_langs(langs)
for lang in userlangs:
if lang in langs:
return langs.get(lang)
# If the user asked for a specific variation, but we don't
# have it available we may serve the most generic one,
# according to the spec (eg: user asks for ('en-us',
# 'de'), but we don't have 'en-us', then 'en' is preferred
# to 'de').
parts = lang.split('-')
if len(parts) > 1 and parts[0] in langs:
return langs.get(parts[0])
return None
def setupLocale(self, request):
# slightly adapted from zope.publisher.http.HTTPRequest.setupLocale
if getattr(request, 'locale', None) is not None:
return
envadapter = IUserPreferredLanguages(request, None)
if envadapter is None:
request.locale = locales.getLocale(None, None, None)
return
langs = envadapter.getPreferredLanguages()
for httplang in langs:
parts = (httplang.split('-') + [None, None])[:3]
try:
request.locale = locales.getLocale(*parts)
return
except LoadLocaleError:
# Just try the next combination
pass
else:
# No combination gave us an existing locale, so use the default,
# which is guaranteed to exist
request.locale = locales.getLocale(None, None, None)
def setupLocale( self, request ):
# slightly adapted from zope.publisher.http.HTTPRequest.setupLocale
if getattr( request, 'locale', None) is not None:
return
envadapter = IUserPreferredLanguages(request, None)
if envadapter is None:
request.locale = locales.getLocale(None, None, None)
return
langs = envadapter.getPreferredLanguages()
for httplang in langs:
parts = (httplang.split('-') + [None, None])[:3]
try:
request.locale = locales.getLocale(*parts)
return
except LoadLocaleError:
# Just try the next combination
pass
else:
# No combination gave us an existing locale, so use the default,
# which is guaranteed to exist
request.locale = locales.getLocale(None, None, None)
def language(self):
adapter = IUserPreferredLanguages(self.request)
languages = adapter.getPreferredLanguages()
if languages:
return languages[0]
return "en"
def language(self):
return IUserPreferredLanguages(self.request).getPreferredLanguages()[0]
def get_current_language(self):
adapter = IUserPreferredLanguages(self.request)
return adapter.getPreferredLanguages()[0]
def _langs(self):
langs = IUserPreferredLanguages(self.request)
return langs.getPreferredLanguages()
def languages(self):
upl = IUserPreferredLanguages(self.request)
if ICookieLanguageSelector.providedBy(upl):
return upl.getLanguageList()
return None
def selected_lang(self):
upl = IUserPreferredLanguages(self.request)
return upl.getSelectedLanguage()
def languages(self):
upl = IUserPreferredLanguages(self.request)
if ICookieLanguageSelector.providedBy(upl):
return upl.getLanguageList()
return None
def selected_lang(self):
upl = IUserPreferredLanguages(self.request)
return upl.getSelectedLanguage()
def traverse(self, name):
if name == 'en':
preferred_languages = IUserPreferredLanguages(self.request)
preferred_languages.setPreferredLanguages(['en'])
alsoProvides(self.request, IEnglishRequest)
return self.context
def language_switch(object, event):
"This is registered in zcml as a pre-traversal hook on Bioport"
context = object
request = event.request
preferred_languages = IUserPreferredLanguages(request)
preferred_languages.setPreferredLanguages(['nl'])
def setupPortalContent(self, p):
"""
Import default plone content
"""
existing = p.objectIds()
wftool = getToolByName(p, "portal_workflow")
# Figure out the current user preferred language
language = None
locale = None
request = getattr(p, 'REQUEST', None)
if request is not None:
pl = IUserPreferredLanguages(request)
if pl is not None:
languages = pl.getPreferredLanguages()
for httplang in languages:
parts = (httplang.split('-') + [None, None])[:3]
try:
locale = locales.getLocale(*parts)
break
except LoadLocaleError:
# Just try the next combination
pass
if len(languages) > 0:
language = languages[0]
# Set the default language of the portal
if language is not None and locale is not None:
localeid = locale.getLocaleID()
base_language = locale.id.language
# If we get a territory, we enable the combined language codes
use_combined = False
if locale.id.territory:
use_combined = True
# As we have a sensible language code set now, we disable the
# start neutral functionality
tool = getToolByName(p, "portal_languages")
pprop = getToolByName(p, "portal_properties")
sheet = pprop.site_properties
tool.manage_setLanguageSettings(language,
[language],
setUseCombinedLanguageCodes=use_combined,
startNeutral=False)
# Enable visible_ids for non-latin scripts
# See if we have an url normalizer
normalizer = queryUtility(IURLNormalizer, name=localeid)
if normalizer is None:
normalizer = queryUtility(IURLNormalizer, name=base_language)
# If we get a script other than Latn we enable visible_ids
if locale.id.script is not None:
if locale.id.script.lower() != 'latn':
sheet.visible_ids = True
# If we have a normalizer it is safe to disable the visible ids
if normalizer is not None:
sheet.visible_ids = False
# Special handling of the front-page, as we want to translate it
if 'front-page' in existing:
fp = p['front-page']
if wftool.getInfoFor(fp, 'review_state') != 'published':
wftool.doActionFor(fp, 'publish')
# Show off presentation mode
fp.setPresentation(True)
# Mark as fully created
fp.unmarkCreationFlag()
if language is not None:
util = queryUtility(ITranslationDomain, 'plonefrontpage')
if util is not None:
front_title = util.translate(u'front-title',
target_language=language,
default="Welcome to Plone")
front_desc = util.translate(u'front-description',
target_language=language,
default="Congratulations! You have successfully installed Plone.")
front_text = util.translate(u'front-text',
target_language=language)
fp.setLanguage(language)
fp.setTitle(front_title)
fp.setDescription(front_desc)
if front_text <> u'front-text':
fp.setText(front_text)
# News topic
if 'news' not in existing:
news_title = 'News'
news_desc = 'Site News'
if language is not None:
util = queryUtility(ITranslationDomain, 'plonefrontpage')
if util is not None:
news_title = util.translate(u'news-title',
target_language=language,
default='News')
news_desc = util.translate(u'news-description',
target_language=language,
default='Site News')
_createObjectByType('Large Plone Folder', p, id='news',
title=news_title, description=news_desc)
_createObjectByType('Topic', p.news, id='aggregator',
title=news_title, description=news_desc)
folder = p.news
folder.setConstrainTypesMode(constraintypes.ENABLED)
folder.setLocallyAllowedTypes(['News Item'])
folder.setImmediatelyAddableTypes(['News Item'])
folder.setDefaultPage('aggregator')
folder.unmarkCreationFlag()
if language is not None:
folder.setLanguage(language)
if wftool.getInfoFor(folder, 'review_state') != 'published':
wftool.doActionFor(folder, 'publish')
topic = p.news.aggregator
if language is not None:
topic.setLanguage(language)
type_crit = topic.addCriterion('Type','ATPortalTypeCriterion')
type_crit.setValue('News Item')
sort_crit = topic.addCriterion('created','ATSortCriterion')
state_crit = topic.addCriterion('review_state', 'ATSimpleStringCriterion')
state_crit.setValue('published')
topic.setSortCriterion('effective', True)
topic.setLayout('folder_summary_view')
topic.unmarkCreationFlag()
if wftool.getInfoFor(topic, 'review_state') != 'published':
wftool.doActionFor(topic, 'publish')
# Events topic
if 'events' not in existing:
events_title = 'Events'
events_desc = 'Site Events'
if language is not None:
util = queryUtility(ITranslationDomain, 'plonefrontpage')
if util is not None:
events_title = util.translate(u'events-title',
target_language=language,
default='Events')
events_desc = util.translate(u'events-description',
target_language=language,
default='Site Events')
_createObjectByType('Large Plone Folder', p, id='events',
title=events_title, description=events_desc)
_createObjectByType('Topic', p.events, id='aggregator',
title=events_title, description=events_desc)
folder = p.events
folder.setConstrainTypesMode(constraintypes.ENABLED)
folder.setLocallyAllowedTypes(['Event'])
folder.setImmediatelyAddableTypes(['Event'])
folder.setDefaultPage('aggregator')
folder.unmarkCreationFlag()
if language is not None:
folder.setLanguage(language)
if wftool.getInfoFor(folder, 'review_state') != 'published':
wftool.doActionFor(folder, 'publish')
topic = folder.aggregator
topic.unmarkCreationFlag()
if language is not None:
topic.setLanguage(language)
type_crit = topic.addCriterion('Type','ATPortalTypeCriterion')
type_crit.setValue('Event')
sort_crit = topic.addCriterion('start','ATSortCriterion')
state_crit = topic.addCriterion('review_state', 'ATSimpleStringCriterion')
state_crit.setValue('published')
date_crit = topic.addCriterion('start', 'ATFriendlyDateCriteria')
# Set date reference to now
date_crit.setValue(0)
# Only take events in the future
date_crit.setDateRange('+') # This is irrelevant when the date is now
date_crit.setOperation('more')
else:
topic = p.events
if wftool.getInfoFor(topic, 'review_state') != 'published':
wftool.doActionFor(topic, 'publish')
# Previous events subtopic
if 'previous' not in topic.objectIds():
prev_events_title = 'Past Events'
prev_events_desc = 'Events which have already happened.'
if language is not None:
util = queryUtility(ITranslationDomain, 'plonefrontpage')
if util is not None:
prev_events_title = util.translate(u'prev-events-title',
target_language=language,
default='Past Events')
prev_events_desc = util.translate(u'prev-events-description',
target_language=language,
default='Events which have already happened.')
_createObjectByType('Topic', topic, id='previous',
title=prev_events_title,
description=prev_events_desc)
topic = topic.previous
if language is not None:
topic.setLanguage(language)
topic.setAcquireCriteria(True)
topic.unmarkCreationFlag()
sort_crit = topic.addCriterion('start','ATSortCriterion')
sort_crit.setReversed(True)
date_crit = topic.addCriterion('start','ATFriendlyDateCriteria')
# Set date reference to now
date_crit.setValue(0)
# Only take events in the past
date_crit.setDateRange('-') # This is irrelevant when the date is now
date_crit.setOperation('less')
if wftool.getInfoFor(topic, 'review_state') != 'published':
wftool.doActionFor(topic, 'publish')
if 'Members' in existing:
# configure Members folder (already added by the content import)
members_title = 'Users'
members_desc = "Container for users' home directories"
if language is not None:
util = queryUtility(ITranslationDomain, 'plonefrontpage')
if util is not None:
members_title = util.translate(u'members-title',
target_language=language,
default='Users')
members_desc = util.translate(u'members-description',
target_language=language,
default="Container for users' home directories")
members = getattr(p , 'Members')
members.setTitle(members_title)
members.setDescription(members_desc)
members.unmarkCreationFlag()
if language is not None:
members.setLanguage(language)
members.reindexObject()
if wftool.getInfoFor(members, 'review_state') != 'published':
wftool.doActionFor(members, 'publish')
# Disable portlets here
rightColumn = getUtility(IPortletManager, name=u'plone.rightcolumn', context=p)
portletAssignments = getMultiAdapter((members, rightColumn,), ILocalPortletAssignmentManager)
portletAssignments.setBlacklistStatus(CONTEXT_PORTLETS, True)
# add index_html to Members area
if 'index_html' not in members.objectIds():
addPy = members.manage_addProduct['PythonScripts'].manage_addPythonScript
addPy('index_html')
index_html = getattr(members, 'index_html')
index_html.write(member_indexhtml)
index_html.ZPythonScript_setTitle('User Search')
